package com.ld.igds.n2.manager;

import com.ld.igds.common.CoreCommonService;
import com.ld.igds.common.CoreSerService;
import com.ld.igds.constant.BizType;
import com.ld.igds.constant.Constant;
import com.ld.igds.io.RemoteControlService;
import com.ld.igds.io.RemoteManager;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.request.DeviceAutoControlRequest;
import com.ld.igds.io.request.DeviceControlRequest;
import com.ld.igds.io.request.ExeDevice;
import com.ld.igds.io.response.DeviceControlResponse;
import com.ld.igds.models.DepotConf;
import com.ld.igds.models.DeviceSer;
import com.ld.igds.models.N2IntelConf;
import com.ld.igds.models.N2IntelTask;
import com.ld.igds.n2.N2Util;
import com.ld.igds.n2.dto.N2AutoData;
import com.ld.igds.n2.dto.N2Param;
import com.ld.igds.n2.service.CoreN2Service;
import com.ld.igds.n2.service.HN2Service;
import com.ld.igds.util.ContextUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.Map;


/**
 * 自动气调执行-针对的是气调动作执行，包括充氮、均氮和相关设备操作
 */
@Slf4j
@Component
public class N2AutoManager {

    @Resource
    private CoreCommonService coreCommonService;
    @Resource
    private RemoteManager remoteManager;
    @Resource
    private CoreSerService coreSerService;
    @Resource
    private CoreN2Service coreN2Service;
    @Resource
    private HN2Service hn2Service;


    /**
     * 根据自动模式配置执行气调，通过创建气调任务信息进行操作
     *
     * @param autoData
     * @param param
     * @return
     */
    public DeviceControlResponse exeAuto(N2AutoData autoData, N2Param param) {
        String result;
        if (N2Util.EXE_MODE_02.equals(autoData.getExeMode())) {
            result = exeAutoActionBySer(autoData, param);
        } else {
            //result = exeAutoActionBySys(autoData, param);
            //TODO 系统暂停系统执行模式
            result = "注意：系统暂停系统端执行气调功能，请联系管理员调整为控制柜端执行";
        }
        if (null == result) {
            return new DeviceControlResponse(OrderRespEnum.ORDER_SUCCESS.getCode(), "命令发送成功");
        }
        return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(), result);
    }


    /**
     * 控制柜执行
     *
     * @param autoData
     * @param param
     * @return
     */
    public String exeAutoActionBySer(N2AutoData autoData, N2Param param) {
        try {
            DepotConf depotConf = coreCommonService.getCacheDepotConf(param.getCompanyId(), param.getDepotId());
            if (null == depotConf) {
                return "当前仓库没有获取到控制柜配置信息，无法执行，请联系管理员";
            }
            //获取粮情分机的主控信息
            DeviceSer ser = coreSerService.getCacheSer(param.getCompanyId(), depotConf.getGrainSer());
//            if (null == ser || Constant.YN_N.equals(ser.getStatus())) {
//                return "当前仓库控制柜未配置或者不在线，无法执行，请联系管理员";
//            }

            DeviceAutoControlRequest request = new DeviceAutoControlRequest();
            request.setDepotId(param.getDepotId());
            request.setCompanyId(param.getCompanyId());
            request.setBizType(BizType.N2.getCode());
            request.setModeTag(autoData.getModeTag());
            request.setSerId(ser.getId());
            request.setSerName(ser.getName());
            request.setModeClose(param.getModeClose());
            request.setIp(ser.getIp());
            request.setPort(ser.getPort());
            request.setDepotName(depotConf.getDepotName());
            request.setProtocol(ser.getProtocol());

            RemoteControlService remoteControlService = remoteManager.getRemoteControlService(ser.getProtocol());

            if (null == remoteControlService) {
                return "当前仓库控制分机协议没有实现，系统无法执行，请联系管理员！";
            }
            DeviceControlResponse response = remoteControlService.n2AutoControl(request);
            if (!OrderRespEnum.ORDER_SUCCESS.getCode().equals(response.getCode())) {
                return "-" + response.getMsg();
            } else {
                this.addIntelTask(autoData, request);
            }
        } catch (Exception e) {
            log.error(e.getMessage());
            return "后台执行出错：" + e.getMessage();
        }

        return null;
    }

    /**
     * 新增任务信息，同时添加到缓存中
     *
     * @param autoData
     * @param request
     */
    private void addIntelTask(N2AutoData autoData, DeviceAutoControlRequest request) {

        //增加执行任务信息
        N2IntelTask task = new N2IntelTask();
        task.setId(ContextUtil.getUUID());
        task.setStart(new Date());
        task.setAutoName(autoData.getName());
        task.setAutoId(autoData.getId());
        task.setOrderId(request.getOrderId());
        task.setCompanyId(autoData.getCompanyId());
        task.setDepotId(request.getDepotId());
        task.setDeptId(autoData.getDeptId());
        task.setExeMode(autoData.getExeMode());
        task.setModeTag(autoData.getModeTag());
        task.setUpdateUser(ContextUtil.getLoginUserCName());

        hn2Service.saveIntelTask(task);


        //添加到缓存
        task.setAutoControlRequest(request);
        coreN2Service.addIntelTaskCache(task);
    }

    /**
     * 新增任务信息，同时添加到缓存中
     *
     * @param autoData
     * @param request
     */
    private void addIntelTask(N2AutoData autoData, DeviceControlRequest request) {

        //增加执行任务信息
        N2IntelTask task = new N2IntelTask();
        task.setId(ContextUtil.getUUID());
        task.setStart(new Date());
        task.setAutoName(autoData.getName());
        task.setAutoId(autoData.getId());
        task.setOrderId(request.getOrderId());
        task.setCompanyId(autoData.getCompanyId());
        task.setDepotId(request.getDepotId());
        task.setDeptId(autoData.getDeptId());
        task.setExeMode(autoData.getExeMode());
        task.setModeTag(autoData.getModeTag());
        task.setUpdateUser(ContextUtil.getLoginUserCName());

        hn2Service.saveIntelTask(task);

        //添加到缓存
        task.setDeviceControlRequest(request);
        coreN2Service.addIntelTaskCache(task);
    }


    /**
     * 只要有一个控制柜存在无法执行则取消执行，针对系统执行需要判断是否配置气调参数。
     *
     * @param autoData
     * @param param
     * @return
     */
    public String exeAutoActionBySys(N2AutoData autoData, N2Param param) {
        try {
            N2IntelConf intelConf = hn2Service.getN2IntelConf(param);

            if (null == intelConf) {
                return "当前仓库未配置气调相关参数，取消执行";
            }

            if (null == autoData.getListConf() || autoData.getListConf().isEmpty()) {
                return "当前方案未配置执行设备配置，无法执行";
            }

            //设备进行分组，KEY= 分机编码
            Map<String, List<ExeDevice>> deviceMap = coreN2Service.getExeDeviceByAutoConf(autoData.getListConf(), param.getModeClose());
            if (null == deviceMap) {
                return "当前方案未配置执行设备配置，无法执行";
            }

            DeviceSer ser;
            RemoteControlService remoteControlService;
            DeviceControlResponse deviceControlResponse;
            for (String serId : deviceMap.keySet()) {
                ser = coreSerService.getCacheSer(param.getCompanyId(), serId);
                if (null == ser || Constant.YN_N.equals(ser.getStatus())) {
                    return "设备关联控制柜不在线，无法执行";
                }

                // 分机协议
                remoteControlService = remoteManager.getRemoteControlService(ser.getProtocol());
                if (null == remoteControlService) {
                    return "当前控制柜=" + ser.getName() + " 协议未实现，请联系管理员！";
                }

                DeviceControlRequest request = new DeviceControlRequest();
                request.setDepotId(param.getDepotId());
                request.setCompanyId(param.getCompanyId());
                request.setBizType(BizType.N2.getCode());
                request.setDepotName(param.getDepotId());
                request.setSerId(ser.getId());
                request.setSerName(ser.getName());
                request.setIp(ser.getIp());
                request.setPort(ser.getPort());
                request.setDeviceList(deviceMap.get(serId));
                request.setProtocol(ser.getProtocol());

                //业务逻辑调整忽略设备双通道问题，直接执行，不同控制柜协议单独区分
                deviceControlResponse = remoteControlService.deviceControl(request);
                if (OrderRespEnum.ORDER_SUCCESS.getCode().equals(deviceControlResponse.getCode())) {
                    return "命令发送失败：" + deviceControlResponse.getMsg();
                } else {
                    this.addIntelTask(autoData, request);
                }
            }
        } catch (Exception e) {
            log.error(e.getMessage());
            return "后台执行出错：" + e.getMessage();
        }
        return null;
    }
}