package com.example.erp.service.pp;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.example.erp.common.RabbitMQUtil;
import com.example.erp.entity.pp.FlowCard;
import com.example.erp.entity.pp.OptimizeProjectMange;
import com.example.erp.entity.userInfo.Log;
import com.example.erp.entity.userInfo.SysError;
import com.example.erp.mapper.pp.GlassOptimizeMapper;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.io.IOException;
import java.math.BigDecimal;
import java.sql.Date;
import java.text.DecimalFormat;
import java.util.*;
import java.util.concurrent.TimeoutException;

@Service
@DS("sd")
public class GlassOptimizeService {
    @Autowired
    GlassOptimizeMapper glassOptimizeMapper;

    RabbitMQUtil rabbitMQUtil;
    //模拟计算

    public Map<String, Object> SimulationCalculation(Map<String,Object> message) {
        Map<String, Object> map = new HashMap<>();
        try {
            rabbitMQUtil = new RabbitMQUtil();
            // 发送消息


            // 获取 computeData 和 cardData
            Object computeData = message.get("computeData");
            Object cardData = message.get("cardData");

           rabbitMQUtil.sendMessage("6");
            System.out.println("send message: " + message);
            String date = rabbitMQUtil.receiveMessages();
            System.out.println("Received message: " + date);

            // 关闭连接
            rabbitMQUtil.close();
            map.put("data", date);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException | InterruptedException e) {
            e.printStackTrace();
        }

        return map;
    }


//模拟计算保存
    public Boolean addSimulation(Map<String, Object> object) {
        try {
            glassOptimizeMapper.addSimulation(object);
            glassOptimizeMapper.addratioResult(object);
            glassOptimizeMapper.addratioProjectResult(object);

            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    //优化设置保存
    public Boolean optimizeParmsSave(Map<String, Object> object) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            String jsonString = mapper.writeValueAsString(object);

            glassOptimizeMapper.optimizeParmsSave(jsonString);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }



    //优化调整结果保存
    public Boolean saveOptimizeResult(Map<String, Object> object) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            String jsonString = mapper.writeValueAsString(object);
            glassOptimizeMapper.optimizeResultSave(jsonString);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    public Boolean updateOptimizeResult(Map<String, Object> object,String processId){
        try {
            ObjectMapper mapper = new ObjectMapper();
            String jsonString = mapper.writeValueAsString(object);
            glassOptimizeMapper.updateOptimizeResult(jsonString,processId);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

   //优化调整结果查询
    public Map<String, Object> selectOptimizeResult(String processId) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.selectOptimizeResult(processId));
        return map;
    }

    //工程信息
    public Map<String, Object> projectInfoSv(String projectNo) {
        Map<String, Object> stringObjectMap = glassOptimizeMapper.selectProjectCount(projectNo);
        Map<String, Object> map = new HashMap<>();
        if(Integer.parseInt(stringObjectMap.get("state").toString())<10){
            map.put("data", glassOptimizeMapper.projectInfoMp(projectNo));
            map.put("grindingTrimming", glassOptimizeMapper.getEdgeTrimming());
        }else if(stringObjectMap.get("state").equals(10)){
            map.put("data", glassOptimizeMapper.projectInfoMp(projectNo));
            map.put("grindingTrimming", glassOptimizeMapper.getEdgeTrimming());
        }else{
            map.put("data", glassOptimizeMapper.projectInfoMp(projectNo));
            map.put("grindingTrimming", null);
        }
        return map;
    }


    //工程信息流程卡
    public Map<String, Object> getProcessCardSv(String projectNo) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.getProcessCardMp(projectNo));
        return map;
    }

    //库存信息
    public Map<String, Object> materialStoreSv(String thickness, String model, String projectNumber) {
        Map<String, Object> stringObjectMap = glassOptimizeMapper.selectProjectCount(projectNumber);
        Map<String, Object> map = new HashMap<>();
        if(Integer.parseInt(stringObjectMap.get("state").toString())<=10){
            map.put("data", glassOptimizeMapper.materialStoreMp(thickness,model));
            map.put("edgeTrimming", glassOptimizeMapper.getEdgeTrimming());
        }else{
            map.put("data", glassOptimizeMapper.materialStoreOptimizeUse(projectNumber));
            map.put("edgeTrimming", null);
        }

        return map;
    }


    //工程查询流程卡
    public Map<String, Object> getFlowCardList(String optionVal, Integer radio) {
        Map<String, Object> map = new HashMap<>();
        if(radio==1){
            map.put("data", glassOptimizeMapper.getFlowCardListWhole(optionVal));
        }else if(radio==2){
            map.put("data", glassOptimizeMapper.getFlowCardListNormal(optionVal));
        }else{
            map.put("data", glassOptimizeMapper.getFlowCardListPatch(optionVal));
        }


        return map;
    }

    //工程管理查询
    public Map<String, Object> OptimizeProjectMange(Date startSelectTime, Date endSelectTime, OptimizeProjectMange optimizeProjectMange) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.optimizeProjectMangeMp(startSelectTime, endSelectTime , optimizeProjectMange));
        return map;
    }

    //修改排版状态
    public Boolean updateProjectState(String projectNumber, Integer state, Integer code) {
        if (!projectNumber.isEmpty()) {
            //撤销模拟计算
            if(code==1){
                glassOptimizeMapper.deleteOptimizeHeatDetail(projectNumber);
                glassOptimizeMapper.deleteOptimizeHeatLayout(projectNumber);
                glassOptimizeMapper.updateProjectStateMp(projectNumber, state);
            }
            //撤销优化排版
            else if(code==2){
                glassOptimizeMapper.deleteOptimizeHeatDetail(projectNumber);
                glassOptimizeMapper.deleteOptimizeHeatDetail(projectNumber);
                glassOptimizeMapper.deleteOptimizeHeatLayout(projectNumber);
                glassOptimizeMapper.updateProjectStateMp(projectNumber, state);
            }
            //允许生产
            else if(code==3){
                glassOptimizeMapper.updateProjectStateMp(projectNumber, state);
            }
            //生产不可见
            else if(code==4){
                glassOptimizeMapper.updateProjectStateMp(projectNumber, state);
            }
            //初始化工程
            else if(code==5){
                glassOptimizeMapper.updateProjectStateMp(projectNumber, state);
            }
            return true;
        } else {
            return false;
        }
    }

    //删除工程
    public boolean deleteProject(String projectNumber) {
        Map<String, Object> stringObjectMap = glassOptimizeMapper.selectProjectCount(projectNumber);
        if(stringObjectMap.get("state").equals(10)){
            glassOptimizeMapper.deleteOptimizeHeatDetail(projectNumber);
            glassOptimizeMapper.deleteOptimizeHeatLayout(projectNumber);
        }else if(stringObjectMap.get("state").equals(20)){
            glassOptimizeMapper.deleteOptimizeDetail(projectNumber);
            glassOptimizeMapper.deleteOptimizeHeatDetail(projectNumber);
            glassOptimizeMapper.deleteOptimizeHeatLayout(projectNumber);
        }
        List<FlowCard> flowCardList =glassOptimizeMapper.getFlowCardList(projectNumber);
        for (FlowCard flowCard:flowCardList){
            glassOptimizeMapper.updateFlowCardProjectReturn(flowCard.getProcessId(),flowCard.getTechnologyNumber(),projectNumber);
        }
        glassOptimizeMapper.deleteProjectMp(projectNumber);
        return true;
    }


    public Map<String, Object> getProjectListSv() {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.getProjectListMp());
        return map;
    }

    //模拟计算工程号查询
    public Map<String, Object>selectProjectComputeSv(String projectNumber) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.selectProjectComputeMp(projectNumber));
        //map.put("project", glassOptimizeMapper.selectProjectCount(projectNumber));
        return map;
    }

    //模拟计算流程卡详情
    public Map<String, Object>selectComputeDetailSv(String processId) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.selectComputeDetailMp(processId));
        return map;
    }

    public Map<String, Object> getProcessCardDetailSv(String processId, Integer technologyNumber) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.getProcessCardDetailmMp(processId,technologyNumber));
        return map;
    }

    public Map<String, Object> selectGlassTypeSv() {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.selectGlassTypeMp());
        return map;
    }


    public Map<String, Object> getProjectIdSv() {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.getProjectIdSv());
        return map;
    }

    public Boolean addProjectSv(String optionVal, String projectId, String projectNmae, Map<String, Object> object) {
        String userName = "";
        if (object.get("userName") != null) {
            userName = object.get("userName").toString();
        }
        if ("null".equals(projectNmae)) {
            projectNmae = "";
        }
        BigDecimal sumArea = new BigDecimal(0);
        double area = 0;
        Integer sumQuantity = 0;
        Integer type = 1;
        StringBuilder processId= new StringBuilder();
        List<FlowCard> flowCardList = JSONArray.parseArray(JSONObject.toJSONString(object.get("projectdetail")), FlowCard.class);
        if (!flowCardList.isEmpty()) {
            for (FlowCard flowCard : flowCardList) {
                //给流程卡表添加对应的工程号
                glassOptimizeMapper.updateFlowCardProject(flowCard.getProcessId(),flowCard.getTechnologyNumber(),projectId);
                area = glassOptimizeMapper.getSelectArea(flowCard.getProcessId(),flowCard.getTechnologyNumber()).doubleValue();
                sumArea = sumArea.add(BigDecimal.valueOf(area));
                sumQuantity +=flowCard.getQuantity();
                processId.append(flowCard.getProcessId()).append("-").append(flowCard.getTechnologyNumber()).append(";");
            }
            int index = optionVal.indexOf("mm");
            // 获取 "mm" 前面的部分
            String glass_thickness = optionVal.substring(0, index);
            // 获取 "mm" 后面的部分
            String glass_type = optionVal.substring(index + 2);
            glassOptimizeMapper.addProjectMp(projectId,projectNmae,glass_thickness,glass_type,sumQuantity,sumArea.doubleValue(),userName,
                    flowCardList.size(), String.valueOf(processId),type);
            return true;
        }
        else {
            return false;

        }
    }

    public Map<String, Object> getConfiguration(String type) {
        Map<String, Object> map = new HashMap<>();
        if(type.equals("钢化")){
            map.put("data", glassOptimizeMapper.getTemperedConfiguration());
        }else if(type.equals("磨量")){
            map.put("data", glassOptimizeMapper.getGrindingTrimming());
        }else if(type.equals("修边")){
            map.put("data", glassOptimizeMapper.getEdgeTrimming());
        }

        return map;
    }

    public Boolean saveConfiguration(Map<String,Object> object,String type) {
        String json = "";
        if (object.get("json") != null) {
            json = object.get("json").toString();
        }
        if(type.equals("钢化")){
            glassOptimizeMapper.updateOptimizeConfig(json,1);
        } else if (type.equals("修边")) {
            glassOptimizeMapper.updateOptimizeConfig(json,5);
        }else if (type.equals("磨量")) {
            glassOptimizeMapper.updateOptimizeConfig(json,4);
        }
        return true;

    }
}