package com.ld.igds.temp.manager;

import com.ld.igds.common.CoreCommonService;
import com.ld.igds.common.CoreDeviceService;
import com.ld.igds.common.CoreSerService;
import com.ld.igds.common.dto.DepotSerData;
import com.ld.igds.constant.*;
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.request.TempControlRequest;
import com.ld.igds.io.response.DeviceControlResponse;
import com.ld.igds.common.DepotStatusService;
import com.ld.igds.models.Depot;
import com.ld.igds.models.Device;
import com.ld.igds.models.DeviceSer;
import com.ld.igds.order.ExeOrderService;
import com.ld.igds.order.data.ExeRequest;
import com.ld.igds.temp.dto.TempParam;
import com.ld.igds.util.ContextUtil;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 温控控制层
 */
@Slf4j
@Component
public class TempControlManager {

    @Autowired
    private CoreCommonService coreCommonService;
    @Autowired
    private CoreDeviceService coreDeviceService;
    @Autowired
    private ExeOrderService exeOrderService;
    @Autowired
    private RemoteManager remoteManager;
    @Autowired
    private CoreSerService coreSerService;

    @Autowired
    private DepotStatusService authCheckService;

    private RemoteControlService remoteControlService;

    /**
     * 获取手动通风仓库的设备列表
     *
     * @param param
     * @return
     */
    public PageResponse<List<Device>> listDeviceManual(TempParam param) {
        List<String> depotIds;
        if (param.isOnlyCurDepot()) {
            depotIds = new ArrayList<>();
            depotIds.add(param.getDepotId());
        } else {
            // 根据仓库缓存获取相同建筑物下的仓库集合
            List<Depot> depotList = coreCommonService.getCacheCommonBuildingDepot(
                    param.getCompanyId(), param.getDepotId());

            // 获取ID信息
            depotIds = depotList.stream().map(Depot::getId).collect(Collectors.toList());
        }

        // 根据仓库多个ID获取仓库与分机的关系数据
        List<DepotSerData> depotSerDataList = coreCommonService.getCacheDepotSerByDepots(param.getCompanyId(), depotIds);

        if (null == depotSerDataList) {
            log.error("没有获取到当前仓库{}的相关分机，执行失败。", param.getDepotId());
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "没有获取到当前仓的分机信息，执行被拒绝！");
        }

        List<Device> listAll = new ArrayList<>();// 分机的所有设备
        List<Device> tempList;
        for (DepotSerData depotSerData : depotSerDataList) {
            tempList = coreDeviceService.getCacheDeviceBySerId(param.getCompanyId(), depotSerData.getSerId());
            listAll.addAll(tempList);
        }

        if (listAll.isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "当前仓库没有获取到设备配置信息，请联管理员！！");
        }
        //过滤只获取温控设备：05-空调
        List<Device> listResult = new ArrayList<>();
        for (Device item : listAll) {
            if (null == item.getType()) continue;

            if (param.isOnlyCurDepot() && !param.getDepotId().equals(item.getDepotId())) continue;

            if (item.getType().equals(DeviceType.TYPE_05.getCode()))
                listResult.add(item);
            if (item.getType().equals(DeviceType.TYPE_04.getCode()))
                listResult.add(item);
            //浅圆仓加上其他设备
            if (DepotType.TYPE_02.getCode().equals(param.getDepotType())) {
                if (item.getType().equals(DeviceType.TYPE_01.getCode()))
                    listResult.add(item);
                if (item.getType().equals(DeviceType.TYPE_02.getCode()))
                    listResult.add(item);
                if (item.getType().equals(DeviceType.TYPE_03.getCode()))
                    listResult.add(item);
                if (item.getType().equals(DeviceType.TYPE_07.getCode()))
                    listResult.add(item);
                if (item.getType().equals(DeviceType.TYPE_0B.getCode()))
                    listResult.add(item);
                if (item.getType().equals(DeviceType.TYPE_0C.getCode()))
                    listResult.add(item);
            }
        }

        if (listResult.isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "当前仓库没有获取到温控设备信息，请联系管理员！！");
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000,
                listResult);
    }

    public DeviceControlResponse tempControl(TempParam param) {
        if (null == param.getCompanyId()) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        List<ExeDevice> deviceList = param.getDeviceList();

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

        ExeDevice exeDevice = deviceList.get(0);
        if (DeviceType.TYPE_05.getCode().equals(exeDevice.getType())) {
            return tempControl2(param, exeDevice);
        } else {

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

            // 如果是单个设备
            if (deviceList.size() == 1) {
                return tempControl3(param);
            }

            // 如果多个设备，需要对设备按分机进行分组
            Map<String, List<ExeDevice>> deviceMap = deviceList.stream().collect(Collectors.groupingBy(ExeDevice::getSerId));

            String temp = "";
            DeviceControlResponse tempResp;
            for (String key : deviceMap.keySet()) {
                param.setDeviceList(deviceMap.get(key));
                tempResp = tempControl3(param);
                if (OrderRespEnum.ORDER_ERROR.getCode().equals(tempResp.getCode())) {
                    temp += tempResp.getMsg();
                }
            }

            if ("".equals(temp)) {
                return new DeviceControlResponse(OrderRespEnum.ORDER_SUCCESS);
            }

            return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "发送存在异常：" + temp);
        }
    }

    /**
     * 空调设备执行
     *
     * @param param
     * @param exeDevice
     * @return
     */
    private DeviceControlResponse tempControl2(TempParam param, ExeDevice exeDevice) {

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

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

//        if (!Constant.YN_Y.equals(deviceSer.getStatus())) {
//            return new DeviceControlResponse(
//                    OrderRespEnum.ORDER_ERROR.getCode(),
//                    "当前设备所在控制柜【" + deviceSer.getName() + "】不在线，无法执行");
//        }

        TempControlRequest request = new TempControlRequest();
        request.setDepotId(param.getDepotId());
        request.setCompanyId(param.getCompanyId());
        exeDevice.setTargetStatus(param.getTargetStatus());
        request.setExeDevice(exeDevice);
        request.setBizType(BizType.TEMPCONTROL.getCode());
        request.setIp(deviceSer.getIp());
        request.setPort(deviceSer.getPort());
        request.setSerId(exeDevice.getSerId());
        request.setSerName(deviceSer.getName());
        request.setTargetModel(param.getTargetModel());
        request.setTargetTemp(param.getTargetTemp());
        request.setControlModel(deviceSer.getControlModel());
        request.setDeptId(param.getDeptId());
        request.setDepotName(request.getDepotName() == null ? request.getDepotId() : request.getDepotName());
        request.setSerName(deviceSer.getName());

        remoteControlService = remoteManager.getRemoteControlService(deviceSer.getProtocol());

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

        // 更新下设备信息到数据库中
        param.setId(exeDevice.getId());

        coreDeviceService.updateTempControlInfo(param);

        //添加操作记录
        exeOrderService.addControlCacheAndLog(new ExeRequest(request, true));

        return remoteControlService.tempControl(request);
    }


    /**
     * 非空调设备操作
     *
     * @param param
     * @return
     */
    public DeviceControlResponse tempControl3(TempParam param) {
        List<ExeDevice> deviceList = param.getDeviceList();
        String serId = deviceList.get(0).getSerId();
        // 获取分机信息
        DeviceSer deviceSer = coreSerService.getCacheSer(param.getCompanyId(), serId);

        if (Constant.YN_N.equals(deviceSer.getStatus())) {
            return new DeviceControlResponse(
                    OrderRespEnum.ORDER_ERROR.getCode(),
                    "当前设备所属控制柜[" + deviceSer.getName() + "]不在线，执行失败。");
        }

        DeviceControlRequest request = new DeviceControlRequest();
        request.setDepotId(param.getDepotId());
        request.setCompanyId(param.getCompanyId());
        request.setDeviceList(deviceList);
        request.setBizType(BizType.TEMPCONTROL.getCode());
        request.setIp(deviceSer.getIp());
        request.setPort(deviceSer.getPort());
        request.setSerId(serId);
        request.setControlModel(deviceSer.getControlModel());
        request.setRealNum(deviceList.size());
        request.setDeptId(param.getDeptId());
        request.setSerName(deviceSer.getName());
        request.setDepotName(request.getDepotName() == null ? request.getDepotId() : request.getDepotName());

        remoteControlService = remoteManager.getRemoteControlService(deviceSer.getProtocol());

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

        DeviceControlResponse response = remoteControlService.deviceControl(request);

        if (OrderRespEnum.ORDER_SUCCESS.getCode().equals(response.getCode())) {
            exeOrderService.addControlCacheAndLog(new ExeRequest(request, true));
        }

        return response;
    }

    public DeviceControlResponse queryDeviceStatus(TempParam param) {
        if (null == param.getCompanyId()) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }
        if (null == param.getDepotId()) {
            return new DeviceControlResponse(
                    OrderRespEnum.ORDER_ERROR.getCode(), "系统没有获取到仓库参数，执行被拒绝。");
        }
        // 根据仓库多个ID获取仓库与分机的关系数据
        List<String> depotIds = new ArrayList<String>();
        depotIds.add(param.getDepotId());
        List<DepotSerData> depotSerDataList = coreCommonService
                .getCacheDepotSerByDepots(param.getCompanyId(), depotIds);

        if (null == depotSerDataList) {
            return new DeviceControlResponse(
                    OrderRespEnum.ORDER_ERROR.getCode(),
                    "当前仓库没有匹配的控制柜信息，执行被拒绝。");
        }

        DeviceControlResponse response = new DeviceControlResponse(
                OrderRespEnum.ORDER_SUCCESS.getCode(), "命令发送成功！");

        DeviceSer deviceSer;
        DeviceControlRequest request;
        for (DepotSerData depotSerData : depotSerDataList) {
            deviceSer = coreSerService.getCacheSer(param.getCompanyId(),
                    depotSerData.getSerId());

            if (null == deviceSer) {
                log.info("根据仓库{}获取设备状态，分机编码{}的分机不存在，取消执行。", param.getDepotId(),
                        depotSerData.getSerId());
                continue;
            }

            request = new DeviceControlRequest();
            request.setDepotId(param.getDepotId());
            request.setCompanyId(param.getCompanyId());
            request.setBizType(BizType.TEMPCONTROL.getCode());
            request.setIp(deviceSer.getIp());
            request.setPort(deviceSer.getPort());
            request.setSerId(deviceSer.getId());
            request.setDeptId(param.getDeptId());
            request.setDepotName(request.getDepotName() == null ? request.getDepotId() : request.getDepotName());
            request.setSerName(deviceSer.getName());

            remoteControlService = remoteManager
                    .getRemoteControlService(deviceSer.getProtocol());

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

            response = remoteControlService.queryStatus(request);

            //添加操作缓存日志
            exeOrderService.addControlCache(new ExeRequest(request));
        }

        return response;
    }

}