package com.ld.igds.verb.manager;

import com.bstek.bdf2.core.business.IUser;
import com.ld.igds.common.CoreSerService;
import com.ld.igds.common.DepotStatusService;
import com.ld.igds.constant.BizType;
import com.ld.igds.constant.Constant;
import com.ld.igds.constant.RespCodeEnum;
import com.ld.igds.data.PageResponse;
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.DeviceControlRequest;
import com.ld.igds.io.request.ExeDevice;
import com.ld.igds.io.response.DeviceControlResponse;
import com.ld.igds.models.DeviceSer;
import com.ld.igds.order.ExeOrderService;
import com.ld.igds.order.data.ExeRequest;
import com.ld.igds.util.ContextUtil;
import com.ld.igds.verb.AreationConst;
import com.ld.igds.verb.dto.VerbAutoData;
import com.ld.igds.verb.dto.VerbParam;
import com.ld.igds.verb.service.CoreAreationService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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


/**
 * 通风模块-自动通风相关业务逻辑控制
 */
@Component
public class VerbAutoManager {

    @Autowired
    private ExeOrderService exeOrderService;
    @Autowired
    private RemoteManager remoteManager;
    @Autowired
    private CoreSerService coreSerService;
    @Autowired
    private CoreAreationService areationService;
    @Autowired
    private DepotStatusService depotCheckService;

    public PageResponse<List<VerbAutoData>> listAuto(VerbParam param) {

        if (null == param.getCompanyId()) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        List<VerbAutoData> list = areationService.listAutoData(param);

        if (null == list || list.isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "根据条件没有获取到数据信息，请重试");
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000, list);
    }

    public PageResponse<List<ExeDevice>> listAutoConf(VerbParam param) {
        if (null == param.getCompanyId()) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }
        if (null == param.getAutoId()) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "没有获取到当前仓的手动模式信息，执行被拒绝！");
        }
        List<ExeDevice> list = areationService.listAutoConfData(param);
        if (null == list || list.isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "根据条件没有获取到数据信息，请重试");
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000, list);
    }

    public DeviceControlResponse runAuto(VerbParam param) {
        if (null == param.getCompanyId()) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        VerbAutoData areationAuto = areationService.queryAutoDataById(param);

        if (null == areationAuto) {
            return new DeviceControlResponse(
                    OrderRespEnum.ORDER_ERROR.getCode(), "系统没有获取自动执行模式信息，执行失败");
        }

        if (AreationConst.EXE_MODE_01.equals(areationAuto.getExeMode())) {
            return exeAutoBySys(param, areationAuto);
        }

        if (AreationConst.EXE_MODE_02.equals(areationAuto.getExeMode())) {
            return exeAutoBySer(param, areationAuto);
        }

        return new DeviceControlResponse(
                OrderRespEnum.ORDER_ERROR.getCode(), "系统不支持当前执行方式");
    }

    /**
     * 控制柜执行模式
     *
     * @param param
     * @param autoData
     * @return
     */
    private DeviceControlResponse exeAutoBySer(VerbParam param, VerbAutoData autoData) {
        return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                "抱歉，控制柜执行模式暂未开启");
    }

    /**
     * 系统执行自动通风-方案
     *
     * @param param
     * @param areationAuto
     * @return
     */
    private DeviceControlResponse exeAutoBySys(VerbParam param, VerbAutoData areationAuto) {

        if (null == areationAuto.getListConf()) {
            return new DeviceControlResponse(
                    OrderRespEnum.ORDER_ERROR.getCode(),
                    "没有获取到需要被执行的设备信息，请重新选择执行");
        }

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

        // 添加仓库逻辑验证
        String msg = depotCheckService.checkDepotStatus(param.getCompanyId(), param.getDepotId(), areationAuto.getListConf());
        if (null != msg) {
            return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(), msg);
        }

        msg = "";
        DeviceSer ser;
        RemoteControlService remoteControlService;
        DeviceControlResponse deviceControlResponse;
        int tagSuccessNum = deviceMap.size();

        for (String serId : deviceMap.keySet()) {
            ser = coreSerService.getCacheSer(param.getCompanyId(), serId);
            if (null == ser || Constant.YN_N.equals(ser.getStatus())) {
                msg += ser.getName() + "-不在线，无法执行";
                tagSuccessNum--;
                continue;
            }
            remoteControlService = remoteManager.getRemoteControlService(ser.getProtocol());
            if (null == remoteControlService) {
                msg += "控制柜=" + ser.getName() + " 协议未实现，无法执行！";
                tagSuccessNum--;
                continue;
            }

            DeviceControlRequest request = new DeviceControlRequest();
            request.setDepotId(param.getDepotId());
            request.setCompanyId(param.getCompanyId());
            request.setBizType(BizType.AREATION.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())) {
                msg += ser.getName() + "-命令发送失败：" + deviceControlResponse.getMsg();
                tagSuccessNum--;
                continue;
            } else {
                exeOrderService.addControlCacheAndLog(new ExeRequest(request, true));
            }
        }

        if (tagSuccessNum <= 0) {
            return new DeviceControlResponse(
                    OrderRespEnum.ORDER_ERROR.getCode(),
                    "执行失败：" + msg);
        } else {
            if ("".equals(msg)) {
                return new DeviceControlResponse(
                        OrderRespEnum.ORDER_SUCCESS.getCode(),
                        "命令发送成功，等待执行结果");
            }
            return new DeviceControlResponse(
                    OrderRespEnum.ORDER_SUCCESS.getCode(),
                    "命令发送完成，部分执行失败：" + msg);
        }
    }

    public DeviceControlResponse stopAuto(VerbParam param) {
        if (null == param.getCompanyId()) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        VerbAutoData areationAuto = areationService.queryAutoDataById(param);

        if (null == areationAuto) {
            return new DeviceControlResponse(
                    OrderRespEnum.ORDER_ERROR.getCode(), "系统没有获取自动执行模式信息，执行失败");
        }

        if (AreationConst.EXE_MODE_01.equals(areationAuto.getExeMode())) {
            return exeAutoBySys(param, areationAuto);
        }

        if (AreationConst.EXE_MODE_02.equals(areationAuto.getExeMode())) {
            return exeAutoBySer(param, areationAuto);
        }

        return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(), "系统不支持当前执行方式");
    }

    public PageResponse<String> updateAuto(VerbAutoData data) {
        if (StringUtils.isEmpty(data.getCompanyId())) {
            IUser user = ContextUtil.getLoginUser();
            data.setCompanyId(user.getCompanyId());
            data.setDeptId(ContextUtil.subDeptId(user));
        }

        if (StringUtils.isEmpty(data.getExeMode())) {
            data.setExeMode(AreationConst.EXE_MODE_01);
        }

        data.setUpdateTime(new Date());
        data.setUpdateUser(ContextUtil.getLoginUserCName());

        String msg = areationService.updateAuto(data);
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), msg);
    }

    /**
     * @param param
     * @return
     */
    public PageResponse<String> updateAutoConf(VerbParam param) {
        if (StringUtils.isEmpty(param.getAutoId())) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "没有获取需要被更新的手动模式参数，执行失败！");
        }
        if (null == param.getDeviceList() || param.getDeviceList().isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "没有获取到设备配置信息，执行失败！");
        }

        String msg = areationService.updateAutoConf(param.getAutoId(),
                param.getDeviceList());

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