package com.ld.igds.gas.manager;

import com.ld.igds.common.CoreCommonService;
import com.ld.igds.common.CoreSerService;
import com.ld.igds.constant.BizType;
import com.ld.igds.constant.RespCodeEnum;
import com.ld.igds.data.PageResponse;
import com.ld.igds.gas.CoreGasService;
import com.ld.igds.gas.dto.GasData;
import com.ld.igds.gas.dto.GasParam;
import com.ld.igds.io.RemoteGasService;
import com.ld.igds.io.RemoteManager;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.request.CheckGasRequest;
import com.ld.igds.io.response.GasResponse;
import com.ld.igds.models.*;
import com.ld.igds.order.ExeOrderService;
import com.ld.igds.order.data.ExeRequest;
import com.ld.igds.order.data.ExeResponse;
import com.ld.igds.pressure.dto.PressureData;
import com.ld.igds.pressure.service.CorePressureService;
import com.ld.igds.util.ContextUtil;
import com.ld.igds.util.DateUtil;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 气体模块控制层
 */
@Slf4j
@Component
public class GasManager {

    @Autowired
    private CoreGasService coreGasService;
    @Autowired
    private CoreSerService coreSerService;
    @Autowired
    private CorePressureService corePressureService;
    @Autowired
    private CoreCommonService coreCommonService;
    @Autowired
    private ExeOrderService exeOrderService;
    @Autowired
    private RemoteManager remoteManager;


    public PageResponse<List<GasData>> queryListPest(GasParam 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);
        }

        List<GasData> list = coreGasService.pageQueryList(param);

        if (null == list || list.isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "根据条件获取数据为空");
        }

        // 添加仓库信息
        Depot depotData = coreCommonService.getCacheDepot(param.getCompanyId(),
                param.getDepotId());

        if (null == depotData) {
            log.error("未获取到仓库信息");
        }

        // 添加仓库数据信息
        for (GasData data : list) {
            data.setDepotData(depotData);
        }

        return new PageResponse<List<GasData>>(RespCodeEnum.CODE_0000, list);
    }

    public PageResponse<GasData> flushGas(GasParam 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);
        }

        List<GasData> list = coreGasService.pageQueryList(param);

        if (null == list || list.isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "根据条件获取数据为空");
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000, list.get(0));
    }

    public PageResponse<GasData> flushGasByDepot(GasParam param) {
        if (StringUtils.isEmpty(param.getDepotId())) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "没有获取到仓库参数。");
        }

        Map<String, GasData> mapData = coreGasService.cacheMapGasData(param.getCompanyId(), param.getDeptId());

        if (null == mapData && !param.isTagPressure()) {
            return new PageResponse<>(RespCodeEnum.CODE_1008.getCode(),
                    "返回信息为空");
        }

        GasData result = mapData.get(param.getDepotId());

        //是否有压力信息
        if (param.isTagPressure()) {
            if (null == result) {
                result = new GasData();
            }

            PressureData pressure = corePressureService.getCachePressure(param.getCompanyId(), param.getDepotId());
            if (null != pressure) {
                result.setPressure(pressure.getPressure());
                result.setPressureDate(pressure.getReceiveDate());
            }

            Depot depot = coreCommonService.getCacheDepot(param.getCompanyId(), param.getDepotId());
            if (null != depot) {
                result.setDepotData(depot);
            }
        }

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


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

        DepotConf conf = coreCommonService.getCacheDepotConf(
                param.getCompanyId(), param.getDepotId());

        if (null == conf) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "没有获取到当前仓库的配置信息，请联系管理员");
        }

        if (conf.getGasStart() == 0 || conf.getGasEnd() == 0) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "当前仓库的气体配置信息，不正确，请联系管理员配置");
        }

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

    /**
     * 根据参数获取 详细的Gas信息
     *
     * @param parameter
     * @return
     */
    public List<GasInfo> getInfoGas(Map<String, Object> parameter)
            throws Exception {
        return coreGasService.getInfoGas(parameter);
    }

    public GasResponse checkGas(GasParam param) {
        log.debug("开始执行气体检测……");
        if (StringUtils.isEmpty(param.getDepotId())) {
            return new GasResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "没有获取到仓库参数，请重新选择仓库并执行！");
        }
        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        // 缓存获仓库配置信息
        DepotConf depotConf = coreCommonService.getCacheDepotConf(
                param.getCompanyId(), param.getDepotId());

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

        CheckGasRequest request = new CheckGasRequest();
        request.setDepotId(param.getDepotId());
        request.setCompanyId(param.getCompanyId());
        request.setIp(deviceSer.getIp());
        request.setPort(deviceSer.getPort());
        request.setBizType(BizType.GAS.getCode());
        request.setSerId(deviceSer.getId());
        request.setGasStart(depotConf.getGasStart());
        request.setGasEnd(depotConf.getGasEnd());
        request.setSerName(deviceSer.getName());
        request.setDepotName(depotConf.getDepotName());

        // 避免重复发送命令和添加操作记录
        ExeRequest exeRequest = new ExeRequest(request);
        ExeResponse exeResponse = exeOrderService.checkExecute(exeRequest);
        if (ExeResponse.CHECK_ERROR.equals(exeResponse.getCode())) {
            return new GasResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    exeResponse.getMsg());
        }

        RemoteGasService remoteGasService = remoteManager.getRemoteGasService(deviceSer.getProtocol());

        if (null == remoteGasService) {
            return new GasResponse(OrderRespEnum.ORDER_ERROR.getCode(), "系统没有"
                    + deviceSer.getProtocol() + "的协议实现，执行被拒绝！");
        }

        GasResponse result = remoteGasService.checkGas(request);

        // 如果命令发送成功，则添加命令缓存，作为参考
        if (OrderRespEnum.ORDER_SUCCESS.getCode().equals(result.getCode())) {
            exeOrderService.addCache(exeRequest);
        }

        return result;
    }

    public GasResponse checkSelect(GasParam param) {
        log.debug("开始执行气体检测……");
        if (StringUtils.isEmpty(param.getDepotId())) {
            return new GasResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "没有获取到仓库参数，请重新选择仓库并执行！");
        }
        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        // 缓存获仓库配置信息
        DepotConf depotConf = coreCommonService.getCacheDepotConf(
                param.getCompanyId(), param.getDepotId());

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

        CheckGasRequest request = new CheckGasRequest();
        request.setDepotId(param.getDepotId());
        request.setCompanyId(param.getCompanyId());
        request.setIp(deviceSer.getIp());
        request.setPort(deviceSer.getPort());
        request.setBizType(BizType.GAS.getCode());
        request.setSerId(deviceSer.getId());
        request.setGasStart(depotConf.getGasStart());
        request.setGasEnd(depotConf.getGasEnd());
        request.setCheckPoints(param.getCheckPoints());
        request.setSerName(deviceSer.getName());
        request.setDepotName(depotConf.getDepotName());

        // 避免重复发送命令和添加操作记录
        ExeRequest exeRequest = new ExeRequest(request);

        ExeResponse exeResponse = exeOrderService.checkExecute(exeRequest);
        if (ExeResponse.CHECK_ERROR.equals(exeResponse.getCode())) {
            return new GasResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    exeResponse.getMsg());
        }

        RemoteGasService remoteGasService = remoteManager.getRemoteGasService(deviceSer
                .getProtocol());

        if (null == remoteGasService) {
            return new GasResponse(OrderRespEnum.ORDER_ERROR.getCode(), "系统没有"
                    + deviceSer.getProtocol() + "的协议实现，执行被拒绝！");
        }

        GasResponse result = remoteGasService.checkGasByPoint(request);

        // 如果命令发送成功，则添加命令缓存，作为参考
        if (OrderRespEnum.ORDER_SUCCESS.getCode().equals(result.getCode())) {
            exeOrderService.addCache(exeRequest);
        }
        return result;
    }

    public Map<String, Object> lineChart(GasParam param) {
        if (StringUtils.isEmpty(param.getDepotId())) {
            return null;
        }
        List<GasData> list = coreGasService.queryChartList(param);

        if (null == list || list.isEmpty())
            return null;

        Map<String, Object> result = new HashMap<String, Object>();
        try {
            List<Double> o2Ave = new ArrayList<>();
            List<Double> o2Max = new ArrayList<>();
            List<Double> o2Min = new ArrayList<>();
            List<Double> ph3Ave = new ArrayList<>();
            List<Double> ph3Max = new ArrayList<>();
            List<Double> ph3Min = new ArrayList<>();
            List<Double> co2Ave = new ArrayList<>();
            List<Double> co2Max = new ArrayList<>();
            List<Double> co2Min = new ArrayList<>();
            List<Double> n2Ave = new ArrayList<>();
            List<Double> n2Max = new ArrayList<>();
            List<Double> n2Min = new ArrayList<>();
            List<String> listDate = new ArrayList<>();
            list.stream().forEachOrdered(
                    item -> {
                        listDate.add(DateFormatUtils.format(
                                item.getReceiveDate(), "yyyy-MM-dd HH:mm"));
                        o2Ave.add(null == item.getPerO2() ? 0.0 : item
                                .getPerO2());
                        o2Max.add(null == item.getPerO2Max() ? 0.0 : item
                                .getPerO2Max());
                        o2Min.add(null == item.getPerO2Min() ? 0.0 : item
                                .getPerO2Min());
                        ph3Ave.add(null == item.getPerPh3() ? 0.0 : item
                                .getPerPh3());
                        ph3Max.add(null == item.getPerPh3Max() ? 0.0 : item
                                .getPerPh3Max());
                        ph3Min.add(null == item.getPerPh3Min() ? 0.0 : item
                                .getPerPh3Min());
                        co2Ave.add(null == item.getPerCo2() ? 0.0 : item
                                .getPerCo2());
                        co2Max.add(null == item.getPerCo2Max() ? 0.0 : item
                                .getPerCo2Max());
                        co2Min.add(null == item.getPerCo2Min() ? 0.0 : item
                                .getPerCo2Min());
                        n2Ave.add(null == item.getPerN2() ? 0.0 : item
                                .getPerN2());
                        n2Min.add(null == item.getPerN2Min() ? 0.0 : item
                                .getPerN2Min());
                        n2Max.add(null == item.getPerN2Max() ? 0.0 : item
                                .getPerN2Max());
                    });

            result.put("o2Ave", o2Ave);
            result.put("o2Max", o2Max);
            result.put("o2Min", o2Min);
            result.put("ph3Ave", ph3Ave);
            result.put("ph3Max", ph3Max);
            result.put("ph3Min", ph3Min);
            result.put("co2Ave", co2Ave);
            result.put("co2Max", co2Max);
            result.put("co2Min", co2Min);
            result.put("n2Min", n2Min);
            result.put("n2Max", n2Max);
            result.put("n2Ave", n2Ave);
            result.put("listDate", listDate);
            log.debug("result=" + result.toString());
        } catch (Exception e) {
            log.error("接口获取气体失败:" + e.getMessage());
        }
        return result;
    }

    /**
     * 气体检测-图形报表统计
     *
     * @param companyId
     * @return
     */
    public Map<String, GasData> getCacheGasMap(String companyId, String deptId) {
        return coreGasService.cacheMapGasData(companyId, deptId);
    }

    public GasResponse checkBatch(GasParam param) {
        if (null == param.getDepotIds()) {
            return new GasResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "没有获取到仓库参数，请重新选择仓库并执行！");
        }

        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        try {
            String[] attr = param.getDepotIds().split(",");
            GasResponse tempResp;
            Map<String, String> mapError = new HashMap<String, String>();
            for (String depotId : attr) {
                param.setDepotId(depotId);

                tempResp = this.checkGas(param);

                if (!OrderRespEnum.ORDER_SUCCESS.getCode().equals(
                        tempResp.getCode())) {
                    mapError.put(depotId, tempResp.getMsg());
                }

                Thread.sleep(3 * 1000);
            }

            if (mapError.isEmpty()) {
                return new GasResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                        "批量执行检测命令发送成功，请等待终端响应……");
            } else {
                Depot depot;
                String errorMsg = "";
                for (String key : mapError.keySet()) {
                    depot = coreCommonService.getCacheDepot(
                            param.getCompanyId(), key);
                    errorMsg += "仓库：" + depot.getName() + "采集失败，异常："
                            + mapError.get(key) + "\n\r";
                }
                return new GasResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                        errorMsg);
            }

        } catch (Exception e) {
            log.error("批量气体异常：{}", e);
            return new GasResponse(OrderRespEnum.ORDER_ERROR.getCode(), "系统异常："
                    + e.getMessage());
        }
    }

    public PageResponse<Map<String, GasData>> queryCheckDateMap(GasParam param) {
        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }
        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);
        }
        param.setLimit(100);
        // param.setPageSize(100);
        List<GasData> list = coreGasService.pageQueryList(param);

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

        Map<String, GasData> result = new HashMap<String, GasData>();
        for (GasData gasData : list) {
            if (null == result.get(gasData.getDepotId())) {
                result.put(gasData.getDepotId(), gasData);
            }
        }

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


}