package com.fzzy.sys.manager.grain;

import com.fzzy.igds.constant.OrderRespEnum;
import com.fzzy.igds.constant.RespCodeEnum;
import com.fzzy.igds.data.*;
import com.fzzy.igds.domain.Depot;
import com.fzzy.igds.domain.DepotConf;
import com.fzzy.igds.domain.DeviceSer;
import com.fzzy.igds.domain.Grain;
import com.fzzy.igds.io.manager.RemoteManager;
import com.fzzy.igds.io.order.ExeOrderService;
import com.fzzy.igds.io.service.RemoteGrainService;
import com.fzzy.igds.request.ExeBaseRequest;
import com.fzzy.igds.request.GrainReqData;
import com.fzzy.igds.request.ReqStatus;
import com.fzzy.igds.response.GrainResponse;
import com.fzzy.igds.service.DepotConfService;
import com.fzzy.igds.service.DepotService;
import com.fzzy.igds.service.DeviceSerService;
import com.fzzy.igds.service.GrainService;
import com.fzzy.igds.utils.ContextUtil;
import com.fzzy.igds.utils.DateUtil;
import com.fzzy.igds.utils.GrainDataBuilder;
import com.fzzy.igds.utils.GrainPrintBuilder;
import com.ruoyi.common.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.text.Collator;
import java.util.*;

/**
 * @Description
 * @Author CZT
 * @Date 2025/12/9 9:56
 */
@Slf4j
@Component
public class GrainManager {

    @Resource
    private DepotService depotService;
    @Resource
    private DepotConfService depotConfService;
    @Resource
    private GrainService grainService;
    @Resource
    private DeviceSerService deviceSerService;
    @Resource
    private RemoteManager remoteManager;
    @Resource
    private ExeOrderService exeOrderService;
    @Resource
    private GrainExportBuilder grainExportBuilder;

    public PageResponse<List<GrainData>> queryListGrainData(GrainParam param) {
        if (StringUtils.isEmpty(param.getDepotId())) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "没有获取到仓库参数。");
        }
        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        if (null != param.getCheckDate()) {
            param.setStart(DateUtil.getCurZero(param.getCheckDate()));
            param.setEnd(DateUtil.getNextZero(param.getCheckDate()));
            param.setCheckDate(null);
        }

        if (null != param.getCheckMonth()) {
            param.setStart(DateUtil.getMonthFirst(param.getCheckMonth()));
            param.setEnd(DateUtil.getNextMonthFirst(param.getCheckMonth()));
            param.setCheckMonth(null);
        }

        List<Grain> list = grainService.listData(param);
        if (null == list || list.isEmpty()) {
            return null;
        }

        // 添加仓库信息
        Depot depotData = depotService.getCacheDepot(param.getCompanyId(), param.getDepotId());
        if (null == depotData) {
            log.error("未获取到仓库信息");
        }

        List<GrainData> result = new ArrayList<>();
        DepotConf depotConf;
        GrainData data;
        for (Grain grain : list) {
            depotConf = depotConfService.getCacheDepotConfByDepotId(grain.getCompanyId(), grain.getDepotId());
            data = new GrainData();
            BeanUtils.copyProperties(grain, data);
            GrainDataBuilder.updateGrainData(data, depotConf, depotData.getDepotType());
            data.setDepotData(depotData);
            result.add(data);
        }


        for (GrainData grainData : result) {
            grainData.setDepotData(depotData);
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000, result);
    }

    /**
     * 单仓采集
     *
     * @param param
     * @return
     */
    public GrainResponse checkSingle(GrainParam param) {
        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        if (StringUtils.isEmpty(param.getDeptId())) {
            param.setDeptId(ContextUtil.subDeptId(null));
        }

        if (StringUtils.isEmpty(param.getDepotId())) {
            return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "没有获取到仓库参数，请重新选择仓库并执行！");
        }

        try {
            // 缓存获仓库配置信息
            DepotConf depotConf = depotConfService.getCacheDepotConfByDepotId(param.getCompanyId(), param.getDepotId());

            if (null == depotConf) {
                return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                        "当前仓库没有配置粮情参数，执行被拒绝！");
            }

            // 获取分机信息
            DeviceSer deviceSer = deviceSerService.getCacheSer(param.getCompanyId(), depotConf.getGrainSer());

            if (null == deviceSer) {
                return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                        "当前仓库没有配置粮情分机，执行被拒绝！");
            }

            Depot depot = depotService.getCacheDepot(depotConf.getCompanyId(), depotConf.getDepotId());

            //数据封装
            ExeBaseRequest request = new ExeBaseRequest<GrainReqData>();
            request.setDepotId(param.getDepotId());
            request.setCompanyId(param.getCompanyId());
            request.setBizType("grain");
            request.setExeUser(ContextUtil.getLoginUserName());
            request.setDepotName(depot.getName());
            request.setDeptId(ContextUtil.subDeptId(null));
            request.setProtocol(deviceSer.getProtocol());
            request.setAddLogTag(true);
            request.setIp(deviceSer.getIp());
            request.setPort(deviceSer.getPort());
            request.setSerId(deviceSer.getId());
            request.setSerName(deviceSer.getName());
            request.setSn(deviceSer.getSn());

            request.setExeMsg("粮情采集，仓库=" + request.getDepotName());

            GrainReqData reqData = new GrainReqData();
            reqData.setCableStart(depotConf.getCableStart());
            reqData.setCableEnd(depotConf.getCableEnd());
            reqData.setCableRule(depotConf.getCableRule());
            // 新增温湿度信息
            reqData.setThSerId(depotConf.getThSer());
            reqData.setThConf(depotConf.getThConf());
            //多仓并发标志
            reqData.setIsMoreDepot(deviceSer.getIsMoreDepot());

            request.setReqData(reqData);

            RemoteGrainService remoteGrainService = remoteManager.getRemoteGrainService(deviceSer.getProtocol());

            if (null == remoteGrainService) {
                String msg = "系统没有" + request.getProtocol() + "的协议实现，执行被拒绝！";
                request.setErrorMsg(msg);
                request.setStatus(ReqStatus.SEND_ERROR.getCode());
                exeOrderService.addLogAndCache(request);
                return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(), msg);
            }

            GrainResponse result = remoteGrainService.checkGrain(request);

            if (!OrderRespEnum.ORDER_SUCCESS.getCode().equals(result.getCode())) {
                String msg = request.getDepotName() + "请求失败:" + result.getMsg();
                request.setErrorMsg(msg);
                request.setStatus(ReqStatus.SEND_ERROR.getCode());
            }

            exeOrderService.addLogAndCache(request);
            return result;

        } catch (Exception e) {
            log.error("粮情执行异常：{}", e.getLocalizedMessage());
            return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "系统异常：" + e.getMessage());
        }
    }

    /**
     * 批量采集
     *
     * @param param
     * @return
     */
    public GrainResponse checkBatch(GrainParam param) {
        if (null == param.getDepotIds()) {
            return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "没有获取到仓库参数，请重新选择仓库并执行！");
        }
        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        if (StringUtils.isEmpty(param.getDeptId())) {
            param.setDeptId(ContextUtil.subDeptId(null));
        }

        try {
            String[] attr = param.getDepotIds().split(",");

            // 缓存获仓库配置信息
            DepotConf depotConf;
            // 获取分机信息
            DeviceSer deviceSer;
            ExeBaseRequest request;
            GrainReqData reqData;
            //执行发送命令
            RemoteGrainService remoteGrainService;
            GrainResponse result;
            Depot depot;
            for (String depotId : attr) {
                param.setDepotId(depotId);

                //数据封装
                request = new ExeBaseRequest<GrainReqData>();
                request.setDepotId(param.getDepotId());
                request.setCompanyId(param.getCompanyId());
                request.setBizType("grain");
                request.setExeUser(ContextUtil.getLoginUserName());

                request.setDeptId(ContextUtil.subDeptId(null));
                request.setAddLogTag(true);

                reqData = new GrainReqData();

                depotConf = depotConfService.getCacheDepotConfByDepotId(param.getCompanyId(), param.getDepotId());

                depot = depotService.getCacheDepot(depotConf.getCompanyId(), depotConf.getDepotId());

                if (null == depotConf) {
                    request.setErrorMsg("执行失败，没有获取粮情参数配置");
                    request.setReqData(reqData);
                    request.setStatus(ReqStatus.SEND_ERROR.getCode());
                    exeOrderService.addLogAndCache(request);
                    continue;
                }
                request.setDepotName(depot.getName());

                deviceSer = deviceSerService.getCacheSer(param.getCompanyId(), depotConf.getGrainSer());

                if (null == deviceSer) {
                    request.setErrorMsg("执行失败，没有获取到分机信息");
                    request.setReqData(reqData);
                    request.setStatus(ReqStatus.SEND_ERROR.getCode());
                    exeOrderService.addLogAndCache(request);
                    continue;
                }

                request.setProtocol(deviceSer.getProtocol());
                request.setIp(deviceSer.getIp());
                request.setPort(deviceSer.getPort());
                request.setSerId(deviceSer.getId());
                request.setSerName(deviceSer.getName());
                request.setSn(deviceSer.getSn());

                request.setExeMsg("粮情采集，仓库=" + request.getDepotName());

                reqData.setCableStart(depotConf.getCableStart());
                reqData.setCableEnd(depotConf.getCableEnd());
                reqData.setCableRule(depotConf.getCableRule());

                // 新增温湿度信息
                reqData.setThSerId(depotConf.getThSer());
                reqData.setThConf(depotConf.getThConf());
                //多仓并发
                reqData.setIsMoreDepot(deviceSer.getIsMoreDepot());
                request.setReqData(reqData);

                //执行命令
                remoteGrainService = remoteManager.getRemoteGrainService(deviceSer.getProtocol());
                if (null == remoteGrainService) {
                    //发送异常
                    request.setErrorMsg("系统没有" + request.getProtocol() + "的协议实现，执行被拒绝！");
                    request.setStatus(ReqStatus.SEND_ERROR.getCode());
                    exeOrderService.addLogAndCache(request);
                    continue;
                }

                result = remoteGrainService.checkGrain(request);
                if (!OrderRespEnum.ORDER_SUCCESS.getCode().equals(result.getCode())) {
                    request.setErrorMsg(request.getDepotName() + "请求失败:" + result.getMsg());
                    request.setStatus(ReqStatus.SEND_ERROR.getCode());
                }

                exeOrderService.addLogAndCache(request);

                Thread.sleep(200);
            }
        } catch (Exception e) {
            return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "后台执行异常：" + e.getMessage());
        }
        return new GrainResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                "批量执行粮情检测命令发送成功，请等待终端响应……");
    }

    /**
     *
     * @param param
     * @return
     */
    public PageResponse<List<GrainData>> pageListGrainData(GrainParam param) {
        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }
        if (StringUtils.isEmpty(param.getDepotId())) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "没有获取到仓库参数，执行失败！");
        }

        param.setTagUpdate(false);
        List<Grain> list = grainService.listData(param);

        DepotConf depotConf;
        GrainData data;
        Depot depotData;
        List<GrainData> result = new ArrayList<>();
        for (Grain grain : list) {
            depotConf = depotConfService.getCacheDepotConfByDepotId(grain.getCompanyId(), grain.getDepotId());
            data = new GrainData();
            BeanUtils.copyProperties(grain, data);
            // 添加仓库信息
            depotData = depotService.getCacheDepot(param.getCompanyId(), param.getDepotId());
            GrainDataBuilder.updateGrainData(data, depotConf, depotData.getDepotType());
            result.add(data);
        }

        if (null == result) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(), "当前条件下没有获取到粮情信息！！");
        }

        return new PageResponse<List<GrainData>>(RespCodeEnum.CODE_0000, result);
    }

    /**
     * 根据参数获取当前打印需要的模板
     *
     * @param param
     * @return
     */
    public PageResponse<PrintModeData> buildPrintModel(GrainParam param) {
        if (null == param.getCompanyId()) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }
        if (StringUtils.isEmpty(param.getDepotType())) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "没有获取到当前仓库的仓库类型");
        }
        if (StringUtils.isEmpty(param.getCableRule()) && StringUtils.isEmpty(param.getCableCir())) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "没有获取当前仓库的布线规则");
        }
        PrintModeData result = GrainPrintBuilder.buildPrintModel(param);

        if (null == result) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "系统没有获取当前仓库的表单模板");
        }

        if (StringUtils.isNotEmpty(result.getMsg())) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    result.getMsg());
        }

        return new PageResponse<>(RespCodeEnum.CODE_0000, result);
    }

    /**
     *
     * @param param
     * @return
     */
    public PageResponse<Map<String, PrintModeData>> buildPrintModelAll(GrainParam param) {

        Map<String, PrintModeData> result = new HashMap<>();

        List<DepotConf> depotConfList = depotConfService.getCacheDepotConfList(param.getCompanyId());
        PrintModeData modeData;
        String key;
        Depot cacheDepot;
        for (DepotConf conf : depotConfList) {
            cacheDepot = depotService.getCacheDepot(param.getCompanyId(), conf.getDepotId());
            param.setCableRule(conf.getCableRule());
            param.setDepotId(conf.getDepotId());
            param.setCableCir(conf.getCableCir());
            param.setDepotType(cacheDepot.getDepotType());

            if (StringUtils.isNotEmpty(param.getCableCir())) {
                key = param.getDepotType() + "_" + param.getCableRule() + "_" + param.getCableCir();
            } else {
                key = param.getDepotType() + "_" + param.getCableRule();
            }
            if (null == result.get(key)) {
                modeData = GrainPrintBuilder.buildPrintModel(param);
                result.put(key, modeData);
            }
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000, result);
    }

    /**
     *
     * @param param
     * @return
     */
    public GrainResponse exportBatch(GrainParam param) {

        //根据条件获取需要打印的粮情信息

        if (null != param.getCheckDate()) {
            param.setStart(DateUtil.getCurZero(param.getCheckDate()));
            param.setEnd(DateUtil.getNextZero(param.getCheckDate()));
            param.setCheckDate(null);
        }

        //获取已经粮情格式化完成的粮情数据
        param.setTagUpdate(true);
        PageResponse<List<GrainData>> listPageResponse = this.pageListGrainData(param);
        List<GrainData> list = listPageResponse.getData();

        if (null == list || list.isEmpty()) {
            return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "当前条件下没有查询到粮情检测记录，取消导出");
        }

        //按照仓库编码从新排序
        Collator sortChina = Collator.getInstance(Locale.CHINA);
        Collections.sort(list, (a, b) -> sortChina.compare(a.getDepotId(), b.getDepotId()));

        //获取缓存的仓库列表，用于获取仓库名称
        List<Depot> listDepot = depotService.getCacheDepotList(param.getCompanyId(), param.getDeptId());

        //去除重复的粮情数据
        LinkedHashMap<String, GrainData> dataMap = new LinkedHashMap<>();
        for (GrainData data : list) {
            if (null != dataMap.get(data.getDepotId())) continue;

            dataMap.put(data.getDepotId(), data);
        }


        String fileName = grainExportBuilder.exportByMapData(dataMap, listDepot);

        if (fileName.startsWith("ERROR")) {
            return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "执行导出出现错误：" + fileName);
        }

        return new GrainResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                fileName);
    }

    /**
     *
     * @param deptId
     * @return
     */
    public List<ExeBaseRequest> orderList(String deptId) {
        return exeOrderService.getAllOrderByDeptId("grain","BIZ", deptId, 2 * 60 * 8);
    }

    /**
     *
     * @param param
     * @return
     */
    public PageResponse<String> cleanOrderList(IgdsBaseParam param) {
        exeOrderService.clean(param.getCompanyId(), "grain", param.getDeptId());

        return new PageResponse<>(RespCodeEnum.CODE_0000, "执行成功");
    }
}