package cn.com.ctop.manage.modules.material.service.impl;

import cn.com.ctop.common.module.entity.CtopOauthToken;
import cn.com.ctop.common.module.entity.MaterialInfo;
import cn.com.ctop.common.module.entity.MaterialParameter;
import cn.com.ctop.common.module.enums.MaterialEnum;
import cn.com.ctop.common.module.mapper.CtopOauthTokenMapper;
import cn.com.ctop.common.module.mapper.MaterialInfoMapper;
import cn.com.ctop.common.module.mapper.MaterialParameterMapper;
import cn.com.ctop.common.module.service.IFileInfoService;
import cn.com.ctop.common.module.service.IMaterialParameterService;
import cn.com.ctop.common.module.utils.Check;
import cn.com.ctop.common.module.utils.KuaishouInterfaceConstant;
import cn.com.ctop.common.module.utils.LoadFileUtil;
import cn.com.ctop.common.module.utils.PropertiesUtils;
import cn.com.ctop.kuaishou.modules.batch.entity.KuaiShouVideoGet;
import cn.com.ctop.kuaishou.modules.batch.service.IKuaiShouVideoGetService;
import cn.com.ctop.manage.modules.material.service.IMaterialUploadImageService;
import cn.com.ctop.manage.modules.material.service.IMaterialUploadService;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.FileSystemResource;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Slf4j
@Service
public class MaterialUploadServiceImpl implements IMaterialUploadService {
    static ExecutorService kuaiShouExecutorService = Executors.newFixedThreadPool(5);
    static ExecutorService touTiaoExecutorService = Executors.newFixedThreadPool(5);
    @Value("${oss.replace.replace-value}")
    private String replaceValue;
    @Value("${oss.replace.replace-old-value}")
    private String replaceOldValue;
    @Value("${oss.replace.download}")
    private String downloadUrl;


    @Autowired
    private CtopOauthTokenMapper oauthTokenMapper;
    @Autowired
    private MaterialInfoMapper materialInfoMapper;

    @Autowired
    private IFileInfoService fileInfoService;
    @Autowired
    private IMaterialParameterService materialParameterService;
    @Autowired
    private MaterialParameterMapper parameterMapper;
    @Autowired
    private IKuaiShouVideoGetService kuaiShouVideoGetService;
    @Autowired
    private IMaterialUploadImageService materialUploadImageService;


    /**
     * 同步素材到账号下
     *
     * @param mediaId
     * @param materialArray
     * @param accountArray
     */

    @Override
    public void uploadAccount(String mediaId, JSONArray materialArray, JSONArray accountArray) {
        try {
            if ("2".equals(mediaId)) {
                this.kuaiShouUpload(mediaId, materialArray, accountArray);
            } else if ("1".equals(mediaId)) {
                this.touTiaoUpload(mediaId, materialArray, accountArray);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }


    }


    private void touTiaoUpload(String mediaId, JSONArray materialArray, JSONArray accountArray) {
        for (int j = 0; j < materialArray.size(); j++) {
            String materialId = materialArray.getString(j);
            MaterialInfo materialInfo = materialInfoMapper.selectById(materialId);
            if (Check.isNull(materialInfo) || Check.isNull(materialInfo.getUrl())) {
                continue;
            }
            try {
                String url = materialInfo.getUrl().replace(replaceOldValue, replaceValue);
                String localUrl = LoadFileUtil.downLoadFromUrl(url, downloadUrl);

                for (int i = 0; i < accountArray.size(); i++) {
                    Long accountId = accountArray.getLong(i);
                    if (Check.isNull(accountId)) {
                        continue;
                    }
                    touTiaoExecutorService.submit(new Runnable() {
                                @Override
                                public void run() {
                            try {
                                log.info("头条文件多线程上传:{}，accountId:{}", Thread.currentThread().getName(), accountId);
                                if ("VIDEO".equals(materialInfo.getType())) {
                                    fileInfoService.uploadVideoToBytedance(String.valueOf(accountId), localUrl);

                                } else if ("IMAGE".equals(materialInfo.getType())) {
                                    fileInfoService.uploadImageToBytedance(String.valueOf(accountId), localUrl);
                                }

                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }
                    });
                }
            } catch (Exception e) {
                e.printStackTrace();
            }


        }


    }


    private void kuaiShouUpload(String mediaId, JSONArray materialArray, JSONArray accountArray) {
        for (int j = 0; j < materialArray.size(); j++) {
            String materialId = materialArray.getString(j);
            MaterialInfo materialInfo = materialInfoMapper.selectById(materialId);
            if (Check.isNull(materialInfo) || Check.isNull(materialInfo.getUrl())) {
                continue;
            }
            try {
                String url = materialInfo.getUrl().replace(replaceOldValue, replaceValue);
                log.info("replaceUrl:{}", url);
                String localUrl = LoadFileUtil.downLoadFromUrl(url, downloadUrl);
                FileSystemResource resource = new FileSystemResource(new File(localUrl));
                Map<String, String> headerMap = new HashMap<>();
                headerMap.put("Content-Type", "multipart/form-data");
                JSONObject requestJson = new JSONObject();
                requestJson.put("file", resource);
                requestJson.put("signature", materialInfo.getCode());

                QueryWrapper<MaterialParameter> parameterQueryWrapper = new QueryWrapper<>();
                parameterQueryWrapper.eq("material_id", materialInfo.getCode());
                parameterQueryWrapper.orderByDesc("create_time").last("limit 1");
                MaterialParameter materialParameter = materialParameterService.getOne(parameterQueryWrapper);
                if (!Check.isNull(materialParameter)) {
                    Integer type = MaterialEnum.getTypeBySize(Integer.valueOf(materialParameter.getWidth()), Integer.valueOf(materialParameter.getHeight()));
                    if (!Check.isNull(type) && type != 0) {
                        requestJson.put("type", type);
                    }
                }
                for (int i = 0; i < accountArray.size(); i++) {
                    Long accountId = accountArray.getLong(i);
                    QueryWrapper<CtopOauthToken> tokenQueryWrapper = new QueryWrapper<>();
                    tokenQueryWrapper.eq("account_id", accountId);
                    tokenQueryWrapper.eq("media_id", mediaId);
                    tokenQueryWrapper.orderByDesc("create_time");
                    tokenQueryWrapper.last("limit 1");
                    CtopOauthToken ctopOauthToken = oauthTokenMapper.selectOne(tokenQueryWrapper);
                    if (Check.isNull(ctopOauthToken)) {
                        continue;
                    }
                    requestJson.put("advertiser_id", accountId);
                    headerMap.put("Access-Token", ctopOauthToken.getAccessToken());
                    kuaiShouExecutorService.submit(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                log.info("快手文件多线程上传:{}，accountId:{}", Thread.currentThread().getName(), accountId);
                                String url = PropertiesUtils.getConfig("kuaishou_api_url") + KuaishouInterfaceConstant.VIDEO_UPLOAD;

                                String result = exceptInfoForRestTemplate(url, requestJson, headerMap);
                                JSONObject resultJson = JSONObject.parseObject(result);
                                if (!Check.isNull(resultJson)) {
                                    if (resultJson.getInteger("code") == 0) {
                                        JSONObject dataJson = resultJson.getJSONObject("data");
                                        if (!Check.isNull(dataJson)) {
                                            String photoId = dataJson.getString("photo_id");
                                            String signature = dataJson.getString("signature");
                                            KuaiShouVideoGet videoGet = new KuaiShouVideoGet();
                                            videoGet.setAccountId(accountId);
                                            videoGet.setId(accountId + photoId);
                                            videoGet.setUrl(materialInfo.getUrl());
                                            QueryWrapper<MaterialParameter> parameterQueryWrapper = new QueryWrapper<>();
                                            parameterQueryWrapper.eq("material_id", signature);
                                            parameterQueryWrapper.last("limit 1");

                                            MaterialParameter materialParameter = parameterMapper.selectOne(parameterQueryWrapper);
                                            if (!Check.isNull(materialParameter)) {
                                                String width = materialParameter.getWidth();
                                                String height = materialParameter.getHeight();
                                                videoGet.setWidth(Integer.valueOf(width));
                                                videoGet.setHeight(Integer.valueOf(height));
                                                Integer type = MaterialEnum.getTypeBySize(Integer.valueOf(width), Integer.valueOf(height));
                                                if (!Check.isNull(type)) {
                                                    videoGet.setMaterialType(type);
                                                }
                                            }
                                            videoGet.setPhotoId(photoId);
                                            videoGet.setSignature(signature);
                                            kuaiShouVideoGetService.saveOrUpdate(videoGet);
                                            materialUploadImageService.uploadImage(videoGet.getId(), accountId, ctopOauthToken.getAccessToken());

                                        }
                                        log.info("快手素材同步完成，accountId：{}，code：{},返回信息：{}", accountId, materialInfo.getCode(), resultJson);
                                    } else {
                                        log.error("快手同步素材失败，返回信息：{}，请求参数：{}", resultJson, requestJson);
                                    }
                                }

                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }
                    });

                }
                /*boolean isTrue = LoadFileUtil.delFile(localUrl);
                if (isTrue) {
                    log.info("删除本地缓存素材成功，code：{}", materialInfo.getCode());
                }*/

            } catch (Exception e) {
                e.printStackTrace();
            }
        }


    }


    @Autowired
    private RestTemplate rest;

    private String exceptInfoForRestTemplate(String url, Map<String, Object> paramMap, Map<String, String> headerMap) {
        try {
            MultiValueMap<String, Object> param = new LinkedMultiValueMap<>();
            if (!Check.isNullMap(paramMap)) {
                for (String key : paramMap.keySet()) {
                    param.add(key, paramMap.get(key));
                }
                HttpHeaders headers = new HttpHeaders();
                if (!Check.isNullMap(headerMap)) {
                    for (String key : headerMap.keySet()) {
                        headers.add(key, headerMap.get(key));
                    }
                }
                HttpEntity<MultiValueMap<String, Object>> httpEntity = new HttpEntity<>(param, headers);
                ResponseEntity<String> responseEntity = rest.exchange(url, HttpMethod.POST, httpEntity, String.class);
                return responseEntity.getBody();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
