package com.ld.igds.common.impl;

import java.util.*;

import com.ld.igds.common.CoreDeviceService;
import com.ld.igds.common.dto.DepotSerData;
import com.ld.igds.common.mapper.DeviceMapper;
import com.ld.igds.constant.Constant;
import com.ld.igds.constant.DeviceStatus;
import com.ld.igds.constant.DeviceType;

import com.ld.igds.models.Depot;
import lombok.extern.slf4j.Slf4j;

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

import com.ld.igds.constant.RedisConst;
import com.ld.igds.models.Device;
import com.ld.igds.temp.dto.TempParam;
import com.ld.igds.util.ContextUtil;
import com.ld.igds.util.RedisUtil;

@Slf4j
@Component
public class CoreDeviceServiceImpl implements CoreDeviceService {

    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private DeviceMapper deviceMapper;


    @SuppressWarnings({ "unchecked", "rawtypes" })
	@Override
    public void setCacheAllDevice(List<Device> listAll, String companyId) {

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

        //按照分机分类
        Map<String, List<Device>> mapSer = new HashMap<>();

        //仓库-设备-分机对象分类
        Map<String, DepotSerData> mapDepot = new HashMap<>();


        //把设备按照分机进行分组，同事吧设备添加到缓存列表中
        String deviceKey, depotDataKey;
        for (Device device : listAll) {

            //封装仓库-设备-分机对象关系
            depotDataKey = companyId + "-" + device.getDepotId() + "-" + device.getSerId();
            if (mapDepot.get(depotDataKey) == null) {
                mapDepot.put(depotDataKey, new DepotSerData(companyId, device.getDepotId(), device.getSerId()));
            }


            //单个设备进行缓存
            deviceKey = RedisConst.buildKey(companyId, RedisConst.KEY_DEVICE, device.getId());
            redisUtil.set(deviceKey, device);

            //按照分机分类
            if (null == mapSer.get(device.getSerId())) mapSer.put(device.getSerId(), new ArrayList<Device>());
            mapSer.get(device.getSerId()).add(device);

        }

        //以分机为单位缓存设备
        for (String serId : mapSer.keySet()) {
            updateCacheDeviceBySerId(mapSer.get(serId), companyId, serId);
        }


        redisUtil.set(RedisConst.buildKey(companyId, RedisConst.KEY_DEPOT_SER_LIST), new ArrayList(mapDepot.values()));
    }


//    private void setCacheDepotDeviceSer(List<Device> listAll, String companyId) {
//        // 处理仓库与分机的关系缓存
//        Map<String, DepotSerData> tempMap = new HashMap<>();
//        String key;
//        for (Device item : listAll) {
//            key = companyId + "-" + item.getDepotId() + "-" + item.getSerId();
//            if (tempMap.get(key) == null) {
//                tempMap.put(key, new DepotSerData(companyId, item.getDepotId(), item.getSerId()));
//            }
//        }
//
//        redisUtil.set(RedisConst.buildKey(companyId, RedisConst.KEY_DEPOT_SER_LIST), new ArrayList(tempMap.values()));
//    }

    @Override
    public void updateCacheDeviceBySerId(List<Device> listBySer, String companyId, String serId) {

        String key = RedisConst.buildDeviceKey(companyId, RedisConst.KEY_DEVICE_LIST, serId);

        log.debug("分机-设备-KEY={}", key);

        redisUtil.set(key, listBySer);
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<Device> getCacheDeviceBySerId(String companyId, String serId) {
        String key = RedisConst.buildDeviceKey(companyId, RedisConst.KEY_DEVICE_LIST, serId);

        List<Device> list = (List<Device>) redisUtil.get(key);
        if (null == list || list.isEmpty()) {
            log.error("字典信息：没有获取到缓存信息，KEY={}", key);
            return null;
        }
        return list;
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<Device> getCacheDeviceByDepotId(String companyId, String depotId) {
        String patten = RedisConst.buildKey(companyId, RedisConst.KEY_DEVICE_LIST);

        Set<String> keys = redisUtil.keys(patten);
        if (null == keys) return null;

        List<Device> result = new ArrayList<>();
        List<Device> list = new ArrayList<>();
        for (String key : keys) {
            list.addAll((List<Device>) redisUtil.get(key));
        }

        if (list.isEmpty()) {
            return null;
        }

        for (Device device : list) {
            if(depotId.equals(device.getDepotId())){
                result.add(device);
            }
        }
        return result;
    }

    @Override
    public Device getCacheDeviceById(String companyId, String id) {
        String key = RedisConst.buildDeviceKey(companyId, RedisConst.KEY_DEVICE, id);
        return (Device) redisUtil.get(key);
    }

    @Override
    public void refreshCache(String companyId) {
        // 获取所有的设备信息
        List<Device> listAll = deviceMapper.queryAll(companyId);
        if (null != listAll) {
            this.setCacheAllDevice(listAll, companyId);
        }
    }


    /**
     * @param companyId
     * @param serId
     * @param statusMap key = serId + "_STATUS_" + passCode; value = status
     */
    @Override
    public void updateStatus(String companyId, String serId, Map<String, String> statusMap) {
        List<Device> listCache = getCacheDeviceBySerId(companyId, serId);

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

        Device curDevice;
        String key, minStatus, linkStatus;
        for (int i = 0; i < listCache.size(); i++) {

            curDevice = listCache.get(i);
            key = ContextUtil.buildDeviceStatusKey(companyId, serId, curDevice.getPassCode());

            minStatus = statusMap.get(key);

            key = ContextUtil.buildDeviceStatusKey(companyId, serId, curDevice.getLink());
            linkStatus = statusMap.get(key);

            if (null == minStatus) continue;

            //如果是轴流风窗 或者 混流风口
            if (DeviceType.TYPE_02.getCode().equals(curDevice.getType()) || DeviceType.TYPE_0C.getCode().equals(curDevice.getType())) {

                if (null == linkStatus) linkStatus = "";
                //调整状态
                if (DeviceStatus.OPEN.getCode().equals(linkStatus)) linkStatus = DeviceStatus.F_OPEN.getCode();
                if (DeviceStatus.CLOSE.getCode().equals(linkStatus)) linkStatus = DeviceStatus.F_CLOSE.getCode();

                if (DeviceStatus.OPEN.getCode().equals(minStatus)) minStatus = DeviceStatus.W_OPEN.getCode();
                if (DeviceStatus.CLOSE.getCode().equals(minStatus)) minStatus = DeviceStatus.W_CLOSE.getCode();

                //如果口开，风机关
                if (DeviceStatus.W_OPEN.getCode().equals(minStatus) && DeviceStatus.F_CLOSE.getCode().equals(linkStatus)) {
                    curDevice.setStatus(DeviceStatus.W_OPEN.getCode());
                    listCache.set(i, curDevice);
                }

                //如果口开，风机开
                if (DeviceStatus.W_OPEN.getCode().equals(minStatus) && DeviceStatus.F_OPEN.getCode().equals(linkStatus)) {
                    curDevice.setStatus(DeviceStatus.F_OPEN.getCode());
                    listCache.set(i, curDevice);
                }

                //如果口开，风机开
                if (DeviceStatus.W_OPEN.getCode().equals(minStatus) && DeviceStatus.F_OPEN_F.getCode().equals(linkStatus)) {
                    curDevice.setStatus(DeviceStatus.F_OPEN_F.getCode());
                    listCache.set(i, curDevice);
                }

                //如果口关，风机关
                if (DeviceStatus.W_CLOSE.getCode().equals(minStatus) && DeviceStatus.F_CLOSE.getCode().equals(linkStatus)) {
                    curDevice.setStatus(DeviceStatus.W_CLOSE.getCode());
                    listCache.set(i, curDevice);
                }

                //如果口关，风机开
                if (DeviceStatus.W_CLOSE.getCode().equals(minStatus) && DeviceStatus.F_OPEN.getCode().equals(linkStatus)) {
                    curDevice.setStatus(DeviceStatus.ERROR.getCode());
                    listCache.set(i, curDevice);
                }
                //如果口关，风机开
                if (DeviceStatus.W_CLOSE.getCode().equals(minStatus) && DeviceStatus.F_OPEN_F.getCode().equals(linkStatus)) {
                    curDevice.setStatus(DeviceStatus.ERROR.getCode());
                    listCache.set(i, curDevice);
                }
            } else {
                curDevice.setStatus(minStatus);
                listCache.set(i, curDevice);
            }
            log.debug("解析设备状态--主通道={}---关联通道={}--解析后状态={}", curDevice.getPassCode(), curDevice.getLink(), curDevice.getStatus());
        }

        // 更新缓存
        this.updateCacheDeviceBySerId(listCache, companyId, serId);
    }

    /**
     * 2021年5月12日 19:48:05 暂停使用
     *
     * @param companyId
     * @param serId
     * @param statusMap key = serId + "_STATUS_" + passCode; value = status
     */
    public void updateStatus2(String companyId, String serId, Map<String, String> statusMap) {
        List<Device> listCache = getCacheDeviceBySerId(companyId, serId);

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

        List<Device> newListCache = new ArrayList<>(listCache.size());
        String key;
        String linkStatus = null, status;

        for (Device device : listCache) {
            if (StringUtils.isNotEmpty(device.getLink()) && "NULL".equalsIgnoreCase(device.getLink())) {
                device.setLink(null);
            }
            key = ContextUtil.buildDeviceStatusKey(companyId, serId, device.getPassCode());
            status = statusMap.get(key);

            // 如果当前状态=空，则使用设备原来状态
            if (Constant.EMPTY.equals(status)) {
                status = device.getStatus();
            }
            if (StringUtils.isNotEmpty(device.getLink())) {
                key = ContextUtil.buildDeviceStatusKey(companyId, serId, device.getLink());
                linkStatus = statusMap.get(key);
                if (Constant.EMPTY.equals(status)) {
                    linkStatus = this.getLinkDeviceStatus(listCache, device.getLink());
                }
            }
            status = DeviceStatus.getStatus(status, linkStatus, device.getType());

            device.setStatus(status);
            device.setStatusName(DeviceStatus.getDeviceStatus(device.getStatus()));

            //log.debug("更新到缓存状态--通道={}---关联={}--当前状态{}",device.getPassCode(),device.getLink(),device.getStatus());
            newListCache.add(device);
        }
        // 更新缓存
        this.updateCacheDeviceBySerId(newListCache, companyId, serId);
    }

    @Override
    public void updateDeviceNoId(Device device, boolean flushCache) {
        int result = deviceMapper.updateDeviceNoId(device);
        if (0 == result) {
            device.setId(ContextUtil.buildDeviceId(device.getCompanyId(), device.getDepotId(), device.getSerId(), device.getPassCode()));
            deviceMapper.addDevice(device);
        }
        if (flushCache) {
            refreshCache(device.getCompanyId());
        }
    }

    @Override
    public void updatePos(String deviceId, Double posX, Double posY) {
        deviceMapper.updatePos(deviceId, posX, posY);
    }

    private String getLinkDeviceStatus(List<Device> listCache, String passCode) {
        for (Device device : listCache) {
            if (passCode.equals(device.getPassCode())) {
                return device.getStatus();
            }
        }
        return null;
    }

    @Override
    public void updateTempControlInfo(TempParam param) {
        deviceMapper.updateTempControlInfo(param);


        String serId = param.getDeviceList().get(0).getSerId();
        // 调整缓存
        List<Device> listCache = getCacheDeviceBySerId(param.getCompanyId(), serId);
        if (null == listCache || listCache.isEmpty())
            return;

        // 更新缓存
        Device temp;
        for (int i = 0; i < listCache.size(); i++) {
            temp = listCache.get(i);
            if (param.getId().equals(temp.getId())) {
                temp.setTargetStatus(param.getTargetStatus());
                temp.setExt1(param.getTargetTemp());
                temp.setExt2(param.getTargetModel());
                temp.setStatus(param.getTargetStatus());
                listCache.set(i, temp);
                break;
            }
        }

        this.updateCacheDeviceBySerId(listCache, param.getCompanyId(), serId);
    }

    @Override
    public List<Device> getDeviceByTimId(String companyId, String timId) {
        return deviceMapper.queryByTimId(companyId, timId);
    }
}