package com.zt.life.modules.configItemOutbound.service;

import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson.JSONObject;
import com.zt.common.db.query.QueryFilter;
import com.zt.common.service.BaseService;
import com.zt.common.utils.UUIDUtil;
import com.zt.core.context.User;
import com.zt.core.context.UserContext;
import com.zt.life.export.dto.WordFile;
import com.zt.life.export.service.WordFileService;
import com.zt.life.modules.configItemOutbound.dao.ConfigItemOutboundDao;
import com.zt.life.modules.configItemOutbound.dto.ConfigItemOutboundDto;
import com.zt.life.modules.configItemOutbound.model.ConfigItemOutbound;
import com.zt.life.modules.configItemOutbound.model.OutboundConfigItem;
import com.zt.life.modules.configItemWarehouse.model.WarehouseConfigItem;
import com.zt.life.modules.configItemWarehouse.service.WarehouseConfigItemService;
import com.zt.life.modules.mainPart.utils.GetFilesPath;
import com.zt.life.modules.mainPart.utils.GetShowDictList;
import com.zt.life.util.ZipCipherUtil;
import com.zt.life.modules.project.service.ProjectService;
import com.zt.life.modules.testCheckOrder.model.TestCheckOrder;
import com.zt.life.modules.testCheckOrder.service.TestCheckOrderService;
import com.zt.life.sys.service.SysOssConfigService;
import com.zt.modules.coderule.service.SysCodeRuleService;
import com.zt.modules.oss.model.SysOss;
import com.zt.modules.oss.service.SysOssService;
import com.zt.modules.workflow.dto.FlowInfoDto;
import com.zt.modules.workflow.service.WorkflowService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * config_item_warehouse
 *
 * @author zt generator
 * @since 1.0.0 2023-11-27
 */
@Service
public class ConfigItemOutboundService extends BaseService<ConfigItemOutboundDao, ConfigItemOutbound> {
    @Autowired
    private SysOssConfigService sysOssConfigService;

    @Autowired
    private SysOssService sysOssService;

    @Autowired
    private WorkflowService workflowService;

    @Autowired
    private SysCodeRuleService sysCodeRuleService;

    @Autowired
    private ProjectService projectService;

    @Value("${zt.oss.local-server}")
    private String localServer;

    @Autowired
    private WarehouseConfigItemService configItemService;

    @Autowired
    private OutboundConfigItemService outboundItemService;

    @Autowired
    private TestCheckOrderService testCheckOrderService;

    @Autowired
    private GetShowDictList getShowDictList;

    @Autowired
    private WordFileService wordFileService;

    @Autowired
    private GetFilesPath getFilesPath;

    @Value("${data.sync-path}")
    private String syncPath;

    @Value("${data.key}")
    private String key;

    /**
     * 分页查询
     *
     * @param queryFilter
     * @return
     */
    public List<ConfigItemOutbound> page(QueryFilter queryFilter) {
        User user = UserContext.getUser();
        Integer secretClass = user.getSecretClass();
        Long deptId = user.getDeptId();
        queryFilter.getQueryParams().put("secretClass", secretClass);
        queryFilter.getQueryParams().put("deptId", deptId);
        List<ConfigItemOutbound> list = baseDao.getList(queryFilter.getQueryParams());
        if (list.size() > 0) {
            workflowService.getRunFlow(list, "pzxck");
        }
        return list;
    }

    /**
     * 删除
     *
     * @param ids
     */
    public void delete(Long[] ids) {
        super.deleteLogic(ids);
    }

    public Boolean save(ConfigItemOutboundDto configItemDto) {
        Long OutboundId = configItemDto.getConfigItemOutbound().getId();
        if (OutboundId != null)
            baseDao.updateById(configItemDto.getConfigItemOutbound());
        else {
            Map<String, String> map = new HashMap<>();
            map.put("funCode", "config_item_Outbound");
            map.put("projectId", configItemDto.getProjectId().toString());
            configItemDto.getConfigItemOutbound().setProjectId(configItemDto.getProjectId());
            configItemDto.getConfigItemOutbound().setCode(sysCodeRuleService.getNewCode(map));
            baseDao.insert(configItemDto.getConfigItemOutbound());
            OutboundId = configItemDto.getConfigItemOutbound().getId();
        }

        for (OutboundConfigItem configItem : configItemDto.getConfigOutboundList()) {
            configItem.setOutboundId(OutboundId);
            configItem.setWarehouseDetailId(configItem.getSelectId());
            if (configItem.getId() != null) {
                outboundItemService.update(configItem);
            } else {
                configItem.setOutboundId(OutboundId);
                configItem.setProjectId(configItemDto.getConfigItemOutbound().getProjectId());
                outboundItemService.insert(configItem);
            }
            Long checkId = configItem.getCheckId();
            if (checkId != null) {
                TestCheckOrder testCheckOrder = testCheckOrderService.get(checkId);
                if (testCheckOrder.getConfigItemId() == null) {
                    Long configItemId = configItem.getId();
                    testCheckOrder.setConfigItemId(configItemId);
                    testCheckOrderService.update(testCheckOrder);
                }
            }
        }

        Long bizId = configItemDto.getConfigItemOutbound().getId();
        FlowInfoDto flowInfoDto = configItemDto.getFlowInfoDto();

        if (flowInfoDto != null && flowInfoDto.getSubmitType() != null && "tj,bl".contains(flowInfoDto.getSubmitType())) {
            if ("tj".equals(flowInfoDto.getSubmitType())) {
                workflowService.startFlow(flowInfoDto.getFlowCode(), bizId);
            }
            workflowService.approvePass(flowInfoDto.getFlowCode(), bizId, flowInfoDto.getStepIdMark());
        }
        return true;
    }

    public ConfigItemOutboundDto getDto(Long projectId, Long OutboundId) {
        ConfigItemOutboundDto data = new ConfigItemOutboundDto();
        if (OutboundId != null) {
            data.setId(OutboundId);
            ConfigItemOutbound configItemOutbound = this.get(OutboundId);
            data.setConfigItemOutbound(configItemOutbound);

            if (projectId == null) {
                projectId = configItemOutbound.getProjectId();
            }
            List<OutboundConfigItem> configOutboundList = outboundItemService.getList(OutboundId);
            data.setConfigOutboundList(configOutboundList);

        } else {
            ConfigItemOutbound configItemOutbound = new ConfigItemOutbound();
            data.setConfigItemOutbound(configItemOutbound);
        }
        if (projectId != null) {
            data.setProjectId(projectId);
            data.setProject(projectService.get(projectId));
        }

        return data;
    }

    public void exportConfigOutbound(Long id, HttpServletRequest request, HttpServletResponse response) {
        try {
            ConfigItemOutboundDto dataObj = this.getDto(null, id);
            String approvalSignPath = "文件图片:" + getFilesPath.getSignPath(Convert.toLong(dataObj.getConfigItemOutbound().getApprovalId()));
            dataObj.getConfigItemOutbound().setApprovalSign(approvalSignPath);
            String OperatorPath = "文件图片:" + getFilesPath.getSignPath(Convert.toLong(dataObj.getConfigItemOutbound().getOperatorId()));
            dataObj.getConfigItemOutbound().setOperator(OperatorPath);
            //通用字典列表字符串生成
            String libraryTypeStr = getShowDictList.getShowDictList(dataObj.getConfigItemOutbound().getLibraryType(), "library_type", false);
            dataObj.getConfigItemOutbound().setLibraryType(libraryTypeStr);
            String ApprovalOpinionStr = getShowDictList.getShowDictList(dataObj.getConfigItemOutbound().getApprovalOpinions(), "is_agree", false);
            dataObj.getConfigItemOutbound().setApprovalOpinions(ApprovalOpinionStr);
            for (OutboundConfigItem configItemList : dataObj.getConfigOutboundList()) {
                String value = configItemList.getSecretClass();
                String secretClassStr = getShowDictList.getShowDictList(value, "secret_class", false);
                configItemList.setSecretClass(secretClassStr);
            }
            WordFile wordFile = new WordFile();
            wordFile.setModulePath("配置项出库申请单.docx");
            wordFile.setWordName(dataObj.getProject().getSoftwareName() + "_配置项出库申请单.docx");
            wordFileService.exportWordFile(request, dataObj, wordFile, response);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    public void downloadFiles(HttpServletResponse response, HttpServletRequest request, Long id) {
        ConfigItemOutboundDto data = this.getDto(null, id);
        String projectName = data.getProject().getSoftwareName() + "出库文件";
        List<SysOss> list = baseDao.getFilesByBusiId(id);
        sysOssConfigService.downloadFilesByosList(request, response, list, projectName);
    }
}