package com.ld.igds.pest.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.ChartLine;
import com.ld.igds.data.PageResponse;
import com.ld.igds.io.RemoteManager;
import com.ld.igds.io.RemotePestService;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.request.CheckPestRequest;
import com.ld.igds.io.response.PestResponse;
import com.ld.igds.models.Depot;
import com.ld.igds.models.DepotConf;
import com.ld.igds.models.DeviceSer;
import com.ld.igds.order.ExeOrderService;
import com.ld.igds.order.data.ExeRequest;
import com.ld.igds.order.data.ExeResponse;
import com.ld.igds.pest.CorePestService;
import com.ld.igds.pest.dto.PestData;
import com.ld.igds.pest.dto.PestParam;
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.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

/**
 * 虫害
 */
@Slf4j
@Component
public class PestManager {

    @Autowired
    private CorePestService pestService;
    @Autowired
    private CoreSerService coreSerService;
    @Autowired
    private CoreCommonService coreCommonService;
    @Autowired
    private ExeOrderService exeOrderService;
    @Autowired
    private RemoteManager remoteManager;

    private RemotePestService remotePestService;

    public PageResponse<List<PestData>> queryListPest(PestParam 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<PestData> list = pestService.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 (PestData data : list) {
            data.setDepotData(depotData);
        }

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

    public PageResponse<Map<String, PestData>> queryCheckDateMap(PestParam 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);
        List<PestData> list = pestService.pageQueryList(param);

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

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

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

        try {

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

                tempResp = this.checkPest(param);

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

                Thread.sleep(3 * 1000);
            }

            if (mapError.isEmpty()) {
                return new PestResponse(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 PestResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                        errorMsg);
            }

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

    public PestResponse checkSelect(PestParam param) {
        log.debug("开始执行气体检测……");
        if (StringUtils.isEmpty(param.getDepotId())) {
            return new PestResponse(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.getGrainSer());

        CheckPestRequest request = new CheckPestRequest();
        request.setDepotId(param.getDepotId());
        request.setCompanyId(param.getCompanyId());
        request.setIp(deviceSer.getIp());
        request.setPort(deviceSer.getPort());
        request.setBizType(BizType.PEST.getCode());
        request.setSerId(deviceSer.getId());
        request.setPestStart(depotConf.getGasStart());
        request.setPestEnd(depotConf.getGasEnd());
        request.setCheckPoints(param.getCheckPoints());

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

        remotePestService = remoteManager.getRemotePestService(deviceSer.getProtocol());

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

        PestResponse result = remotePestService.checkPestByPoint(request);

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

        return result;
    }

    public PestResponse checkPest(PestParam param) {
        log.debug("开始执行气体检测……");
        if (StringUtils.isEmpty(param.getDepotId())) {
            return new PestResponse(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.getGrainSer());
        // 若虫害分机配置不为空，则获取虫害的分机
        if(StringUtils.isNotEmpty(depotConf.getPestSer())){
            deviceSer = coreSerService.getCacheSer(param.getCompanyId(), depotConf.getPestSer());
        }

        CheckPestRequest request = new CheckPestRequest();
        request.setDepotId(param.getDepotId());
        request.setCompanyId(param.getCompanyId());
        request.setIp(deviceSer.getIp());
        request.setPort(deviceSer.getPort());
        request.setBizType(BizType.PEST.getCode());
        request.setSerId(deviceSer.getId());
        request.setPestStart(depotConf.getGasStart());
        request.setPestEnd(depotConf.getGasEnd());

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

        remotePestService = remoteManager.getRemotePestService(deviceSer
                .getProtocol());

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

        PestResponse result = remotePestService.checkPest(request);

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

        return result;
    }

    public PageResponse<PestData> flushData(PestParam 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<PestData> list = pestService.pageQueryList(param);

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

        return new PageResponse<PestData>(RespCodeEnum.CODE_0000, list.get(0));
    }

    public PageResponse<DepotConf> pestConf(PestParam 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);
    }

    /**
     * 获取走势图数据
     *
     * @param param
     * @return
     */
    public PageResponse<ChartLine> queryLineData(PestParam param) {
        if (StringUtils.isEmpty(param.getDepotId())) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "请选择需要查询的仓库");
        }
        if (null == param.getStart() && null == param.getEnd()) {
            param.setStart(DateUtils.addMonths(new Date(), -6));// 默认6个月以前的数据
        }

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

        param.setTagUpdate(false);

        ChartLine result = pestService.queryLineData(param);

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

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