package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.whyc.constant.DeviceConstant;
import com.whyc.dto.BattTestData;
import com.whyc.dto.Response;
import com.whyc.dto.paramter.FbsStatePar;
import com.whyc.dto.result.DischargeState;
import com.whyc.mapper.BattInfMapper;
import com.whyc.mapper.BattRtstateMapper;
import com.whyc.mapper.Fbs9100StateMapper;
import com.whyc.pojo.Battinf;
import com.whyc.pojo.Fbs9100State;
import com.whyc.util.ActionUtil;
import com.whyc.util.ThreadLocalUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class Fbs9100StateService {
    @Resource
    private Fbs9100StateMapper mapper;
    @Autowired
    private Fbs9100SetparamService service;

    @Autowired(required = false)
    private BattInfMapper binfMapper;

    @Autowired(required = false)
    private BattRtstateMapper rtstateMapper;
    @Autowired(required = false)

    private Fbs9600StateService fbs9600StateService;
    @Autowired(required = false)

    private Ld9StateService ld9StateService;

    //开关状态
    @Transactional
    public Response serchContactorState(int devId) {
        PageHelper.startPage(1, 1);
        QueryWrapper wrapper = new QueryWrapper();
        wrapper.eq("dev_id", devId);
        Fbs9100State fbs9100State = mapper.selectOne(wrapper);
        if (fbs9100State != null) {
            fbs9100State.setNote(new SimpleDateFormat(ActionUtil.time_yyyyMMddHHmmss).format(new Date()));
            if((devId / 100000 == 6183)||(devId / 100000 == 6184)){
                fbs9100State.setDevLastCaptestStopTypeReason(BattTestData.getStopType_6183_4(fbs9100State.getDevLastCaptestStopType()));
            }else{
                fbs9100State.setDevLastCaptestStopTypeReason(BattTestData.getStopType_9612(fbs9100State.getDevLastCaptestStopType()));
            }
        }
        return new Response().setII(1, fbs9100State == null ? false : true, fbs9100State, "");
    }

    //FBS9100设备通信状态查询
    public Response searchByCondition(int pageNum,int pageSize,int devErrcommcount,int uId){
        PageHelper.startPage(pageNum,pageSize);
        List<Fbs9100State> list = mapper.searchByCondition(devErrcommcount,uId);
        PageInfo<Fbs9100State> pageInfo = new PageInfo<>(list);
        return new Response().set(1,pageInfo,"查询成功");
    }

    public Response<List<Fbs9100State>> getList(Integer deviceId, Integer workState, Long uId) {
        List<Fbs9100State> list = mapper.getList(deviceId, workState, uId);
        return new Response<List<Fbs9100State>>().set(1,list);
    }
    //一体机烟雾报警确认
    public Response update_dev_res_test_state(int devId) {
        UpdateWrapper wrapper=new UpdateWrapper();
        wrapper.set("dev_res_test_state",0);
        wrapper.eq("dev_id",devId);
        int flag=mapper.update((Fbs9100State) ActionUtil.objeNull,wrapper);
        return  new Response().set(1,flag>0?true:false);
    }
    //一体机界面弹出框确认操作
    public Response update_dev_alarmstate(int num, int devId) {
        int dev_alarmstat=0;
        int flag=0;
        boolean bl=false;
        String msg="";
        UpdateWrapper wrapper=new UpdateWrapper();
        if(num==1){//确认操作
            dev_alarmstat=2;
            wrapper.set("dev_alarmstate",dev_alarmstat);
            wrapper.eq("dev_id",devId);
            flag=mapper.update((Fbs9100State) ActionUtil.objeNull,wrapper);
            if(flag>0){
                boolean b=service.sendCmdToFBS9100Dev(35,0, devId);
                if(b){
                    bl=true;
                    msg="修改成功!";
                }else{
                    bl=false;
                    msg="停止失败!";
                }
            } else{
                bl=false;
                msg="修改失败!";
            }
        }else{//取消操作时
            dev_alarmstat=3;
            wrapper.set("dev_alarmstate",dev_alarmstat);
            wrapper.eq("dev_id",devId);
            flag=mapper.update((Fbs9100State) ActionUtil.objeNull,wrapper);
            if(flag>0){
                bl=true;
                msg="修改成功!";
            }else{
                bl=false;
                msg="修改失败!";
            }
        }
        return new Response().set(1,bl,msg);
    }

    public List search6185NuclearCap(int uId){
        List<Fbs9100State> list = mapper.search6185NuclearCap(uId);
        for (Fbs9100State fstate :list) {
            int dev_alarmstate = fstate.getDevAlarmstate();
            String ContactorState = "开关闭合";
            if (dev_alarmstate == 1 ||
                    dev_alarmstate == 2 ||
                    dev_alarmstate == 3 ||
                    dev_alarmstate == 4 ||
                    dev_alarmstate == 6) {
                ContactorState = "开关断开";
            } else {
                ContactorState = "开关闭合";
            }
            fstate.setNote(ContactorState);
        }
        return list;
    }

    /**
     * 这个是按照设备id来统计的,一拖二的设备有两个设备id,被看作两个设备,弃用
     * @param userId
     * @return
     */
    @Deprecated
    public Response getBTSEquipStatus(int userId){

        Response response = new Response();
        try {
            Map<String, Integer> resultMap = new HashMap<>();
            resultMap.put("在线浮充数量", 0);
            resultMap.put("预充电数量", 0);
            resultMap.put("核容测试数量", 0);
            resultMap.put("内阻测试数量", 0);
            resultMap.put("通讯故障数量", 0);
        /*try {
            List<FBS9100State> statusList = fbs9100StateMapper.getStatus(userId);
            for (int i = 0; i < statusList.size(); i++) {
                switch (statusList.get(i).getWorkState()){
                    case DeviceConstant.DEV_ONLINE_CHARGE:
                        resultMap.put("在线浮充",statusList.get(i).getNum());
                        break;
                    case DeviceConstant.DEV_PRE_CHARGE:
                        resultMap.put("预充电",statusList.get(i).getNum());
                        break;
                    case DeviceConstant.DEV_NUCLEAR_CAP:
                        resultMap.put("核容测试",statusList.get(i).getNum());
                        break;
                    case DeviceConstant.DEV_RES_TEST:
                        resultMap.put("内阻测试",statusList.get(i).getNum());
                        break;
                }
            }
            response.setCode(1);
            response.setData(resultMap);
        } catch (Exception e) {
            e.printStackTrace();
            response.setCode(0);
            return response;
        }*/
            /*QueryWrapper<Fbs9100State> wrapper = Wrappers.query();
            wrapper.select("record_datetime", "dev_workstate");
            List<Fbs9100State> fbs9100StateList = mapper.selectList(wrapper);*/
            List<Fbs9100State> fbs9100StateList = mapper.getListWithoutZJDYBTSE2(userId, 1);
            //首先查看是否通讯故障,时间大于1分钟为通讯故障
            for (int i = 0; i < fbs9100StateList.size(); i++) {
                Calendar instance = Calendar.getInstance();
                instance.add(Calendar.MINUTE, -1);
                Date time = instance.getTime();
                //if (time.compareTo(DateUtil.YYYY_MM_DD_HH_MM_SS.parse(fbs9100StateList.get(i).getRecordDatetime())) > 0) {
                if (time.compareTo(ThreadLocalUtil.parse(fbs9100StateList.get(i).getRecordDatetime(),1)) > 0) {
                    resultMap.put("通讯故障数量", resultMap.get("通讯故障数量") + 1);
                } else {
                    switch (fbs9100StateList.get(i).getDevWorkstate()) {
                        case DeviceConstant.DEV_ONLINE_CHARGE:
                            resultMap.put("在线浮充数量", resultMap.get("在线浮充数量") + 1);
                            break;
                        case DeviceConstant.DEV_PRE_CHARGE:
                            resultMap.put("预充电数量", resultMap.get("预充电数量") + 1);
                            break;
                        case DeviceConstant.DEV_NUCLEAR_CAP:
                            resultMap.put("核容测试数量", resultMap.get("核容测试数量") + 1);
                            break;
                        case DeviceConstant.DEV_RES_TEST:
                            resultMap.put("内阻测试数量", resultMap.get("内阻测试数量") + 1);
                            break;
                    }
                }
            }

            return response.setII(1, true, resultMap, "");
        } catch (Exception e) {
            return response.set(1, false, "发生异常:" + e.getCause());
        }
    }

    /**
     * 这个是按照设备ip来统计的.
     * 通讯故障>核容放电>充电>内阻>浮充,
     * 如果一拖二的设备,有两个不同状态,实现状态优先级覆盖
     * @param userId
     * @param type 1-太原排除蓄电池设备一拖二的第二组状态统计
     * @param type 2-统计所有设备ip的状态
     * @return
     */
    public Response getBTSEquipStatus2(int userId,int type){

        Response response = new Response();
        try {
            Map<String, Integer> resultMap = new HashMap<>();
            resultMap.put("直流充电数量", 0);
            resultMap.put("预充电数量", 0);
            resultMap.put("核容测试数量", 0);
            resultMap.put("内阻测试数量", 0);
            resultMap.put("通讯故障数量", 0);

            List<Fbs9100State> fbs9100StateList = mapper.getListWithoutZJDYBTSE2(userId,type);
            //Map<String, List<Fbs9100State>> deviceMap = fbs9100StateList.stream().collect(Collectors.groupingBy(Fbs9100State::getDevIp));
            Map<String, List<Fbs9100State>> deviceMap = fbs9100StateList.stream().collect(Collectors.groupingBy(state ->
                    String.format("%s_%s",state.getDevIp(), state.getDevId())));
            Set<String> deviceSet = deviceMap.keySet();
            Calendar instance = Calendar.getInstance();
            instance.add(Calendar.MINUTE, -1);
            Date time = instance.getTime();
            for (String deviceIp : deviceSet) {
                List<Fbs9100State> fbs9100States = deviceMap.get(deviceIp);
                List<Integer> workStateList = fbs9100States.stream().map(Fbs9100State::getDevWorkstate).collect(Collectors.toList());
                Map<Integer, List<Integer>> workStateMap = workStateList.stream().collect(Collectors.groupingBy(Integer::intValue));
                Set<Integer> workStateSet = workStateMap.keySet();
                boolean commError = false;
                for (Fbs9100State state : fbs9100States) {
                    //if (time.compareTo(DateUtil.YYYY_MM_DD_HH_MM_SS.parse(state.getRecordDatetime())) > 0) {
                    if (time.compareTo(ThreadLocalUtil.parse(state.getRecordDatetime(),1)) > 0) {
                        resultMap.put("通讯故障数量", resultMap.get("通讯故障数量") + 1);
                        commError = true;
                        break;
                    }
                }
                //不存在通讯故障,则需要再判断优先级覆盖
                if(!commError){
                    if(workStateSet.contains(DeviceConstant.DEV_NUCLEAR_CAP)) {
                        resultMap.put("核容测试数量", resultMap.get("核容测试数量") + 1);
                    }
                    else if(workStateSet.contains(DeviceConstant.DEV_PRE_CHARGE)) {
                        resultMap.put("预充电数量", resultMap.get("预充电数量") + 1);
                    }
                    else if(workStateSet.contains(DeviceConstant.DEV_RES_TEST)) {
                        resultMap.put("内阻测试数量", resultMap.get("内阻测试数量") + 1);
                    }
                    else if(workStateSet.contains(DeviceConstant.DEV_ONLINE_CHARGE)) {
                        resultMap.put("直流充电数量", resultMap.get("直流充电数量") + 1);
                    }

                }

            }
            /*//首先查看是否通讯故障,时间大于1分钟为通讯故障
            for (int i = 0; i < fbs9100StateList.size(); i++) {
                Calendar instance = Calendar.getInstance();
                instance.add(Calendar.MINUTE, -1);
                Date time = instance.getTime();
                if (time.compareTo(DateUtil.YYYY_MM_DD_HH_MM_SS.parse(fbs9100StateList.get(i).getRecordDatetime())) > 0) {
                    resultMap.put("通讯故障数量", resultMap.get("通讯故障数量") + 1);
                } else {
                    switch (fbs9100StateList.get(i).getDevWorkstate()) {
                        case DeviceConstant.DEV_ONLINE_CHARGE:
                            resultMap.put("在线浮充数量", resultMap.get("在线浮充数量") + 1);
                            break;
                        case DeviceConstant.DEV_PRE_CHARGE:
                            resultMap.put("预充电数量", resultMap.get("预充电数量") + 1);
                            break;
                        case DeviceConstant.DEV_NUCLEAR_CAP:
                            resultMap.put("核容测试数量", resultMap.get("核容测试数量") + 1);
                            break;
                        case DeviceConstant.DEV_RES_TEST:
                            resultMap.put("内阻测试数量", resultMap.get("内阻测试数量") + 1);
                            break;
                    }
                }
            }*/

            return response.setII(1, true, resultMap, "");
        } catch (Exception e) {
            return response.set(1, false, "发生异常:" + e.getCause());
        }
    }

    //山西晋源特定接口
    public Response getBTSEquipStatus2JY(int type){

        Response response = new Response();
        try {
            Map<String, Integer> resultMap = new HashMap<>();
            resultMap.put("直流充电数量", 0);
            resultMap.put("预充电数量", 0);
            resultMap.put("核容测试数量", 0);
            resultMap.put("内阻测试数量", 0);
            resultMap.put("通讯故障数量", 0);

            List<Fbs9100State> fbs9100StateList = mapper.getListWithoutZJDYBTSE2JY(type);

            //Map<String, List<Fbs9100State>> deviceMap = fbs9100StateList.stream().collect(Collectors.groupingBy(Fbs9100State::getDevIp));
            Map<String, List<Fbs9100State>> deviceMap = fbs9100StateList.stream().collect(Collectors.groupingBy(state ->String.format("%s_%s",state.getDevIp(), state.getDevId())));
            Set<String> deviceSet = deviceMap.keySet();
            Calendar instance = Calendar.getInstance();
            instance.add(Calendar.MINUTE, -1);
            Date time = instance.getTime();
            for (String deviceIp : deviceSet) {
                List<Fbs9100State> fbs9100States = deviceMap.get(deviceIp);
                List<Integer> workStateList = fbs9100States.stream().map(Fbs9100State::getDevWorkstate).collect(Collectors.toList());
                Map<Integer, List<Integer>> workStateMap = workStateList.stream().collect(Collectors.groupingBy(Integer::intValue));
                Set<Integer> workStateSet = workStateMap.keySet();
                boolean commError = false;
                for (Fbs9100State state : fbs9100States) {
                    //if (time.compareTo(DateUtil.YYYY_MM_DD_HH_MM_SS.parse(state.getRecordDatetime())) > 0) {
                    if (time.compareTo(ThreadLocalUtil.parse(state.getRecordDatetime(),1)) > 0) {
                        resultMap.put("通讯故障数量", resultMap.get("通讯故障数量") + 1);
                        commError = true;
                        break;
                    }
                }
                //不存在通讯故障,则需要再判断优先级覆盖
                if(!commError){
                    if(workStateSet.contains(DeviceConstant.DEV_NUCLEAR_CAP)) {
                        resultMap.put("核容测试数量", resultMap.get("核容测试数量") + 1);
                    }
                    else if(workStateSet.contains(DeviceConstant.DEV_PRE_CHARGE)) {
                        resultMap.put("预充电数量", resultMap.get("预充电数量") + 1);
                    }
                    else if(workStateSet.contains(DeviceConstant.DEV_RES_TEST)) {
                        resultMap.put("内阻测试数量", resultMap.get("内阻测试数量") + 1);
                    }
                    else if(workStateSet.contains(DeviceConstant.DEV_ONLINE_CHARGE)) {
                        resultMap.put("直流充电数量", resultMap.get("直流充电数量") + 1);
                    }

                }

            }
            /*//首先查看是否通讯故障,时间大于1分钟为通讯故障
            for (int i = 0; i < fbs9100StateList.size(); i++) {
                Calendar instance = Calendar.getInstance();
                instance.add(Calendar.MINUTE, -1);
                Date time = instance.getTime();
                if (time.compareTo(DateUtil.YYYY_MM_DD_HH_MM_SS.parse(fbs9100StateList.get(i).getRecordDatetime())) > 0) {
                    resultMap.put("通讯故障数量", resultMap.get("通讯故障数量") + 1);
                } else {
                    switch (fbs9100StateList.get(i).getDevWorkstate()) {
                        case DeviceConstant.DEV_ONLINE_CHARGE:
                            resultMap.put("在线浮充数量", resultMap.get("在线浮充数量") + 1);
                            break;
                        case DeviceConstant.DEV_PRE_CHARGE:
                            resultMap.put("预充电数量", resultMap.get("预充电数量") + 1);
                            break;
                        case DeviceConstant.DEV_NUCLEAR_CAP:
                            resultMap.put("核容测试数量", resultMap.get("核容测试数量") + 1);
                            break;
                        case DeviceConstant.DEV_RES_TEST:
                            resultMap.put("内阻测试数量", resultMap.get("内阻测试数量") + 1);
                            break;
                    }
                }
            }*/

            return response.setII(1, true, resultMap, "");
        } catch (Exception e) {
            return response.set(1, false, "发生异常:" + e.getCause());
        }
    }


    public List<Fbs9100State> getStateList(int userId) {
        List<Fbs9100State> list = mapper.getStateList(userId);
        return list;
    }

    //首页上点击停电站
    public List<Battinf> searchPowerOff(String uId) {
        List<Battinf> list = mapper.searchPowerOff(uId);
        return list;
    }

    //首页上点击核容放电站
    public List<Battinf> searchCheckCapDischarge(String uId) {
        List<Battinf> list = mapper.searchCheckCapDischarge(uId);
        return list;
    }

    //今日放电站点统计
    public Response getChargeStaticToday(int userId) {
        try {
            Map<String, Object> map = new HashMap<>();
            List<DischargeState> list = mapper.getChargeStaticToday(userId);
            Map<String, Object> stateMap = new HashMap<>();
            Map<String, Object> stateNumMap = new HashMap<>();
            stateNumMap.put("state2", 0);
            stateNumMap.put("state3", 0);
            stateMap.put("state2", new ArrayList<>());
            stateMap.put("state3", new ArrayList<>());
            Map<Integer, List<DischargeState>> stateDisMap = list.stream().collect(Collectors.groupingBy(DischargeState::getDevWorkstate));
            for (Integer workState : stateDisMap.keySet()) {
                if (workState == 2 || workState == 3) {
                    stateNumMap.put("state" + workState, stateDisMap.get(workState).size());
                    List<DischargeState> worklist = stateDisMap.get(workState);
                    stateMap.put("state" + workState, worklist);
                }
            }
            map.put("stateNumMap", stateNumMap);
            map.put("stateMap", stateMap);
            //map.put("nowTime", ActionUtil.sdf.format(new Date()));
            map.put("nowTime", ThreadLocalUtil.format(new Date(),1));
            return new Response().setII(1, true, map, "今日放电站点统计");
        } catch (Exception e) {
            return new Response().set(1, false, "出现异常" + e.getMessage());
        }
    }

    //实时停电放电
    public int getJcAnalysis(int userId) {
        int jcdisNum = mapper.getJcAnalysis(userId);
        return jcdisNum;
    }

    public Response getFbsState(FbsStatePar fbsStatePar) {
        Map<String, Response> res=new HashMap<>();
        //查询fbs9100信息
        Response f9100stateRes = searchByCondition(fbsStatePar.getPageNum(),fbsStatePar.getPageSize(),fbsStatePar.getDevErrcommcount(),fbsStatePar.getUserId());
        res.put("f9100state",f9100stateRes);

        Response f9600StateRes = fbs9600StateService.searchByCondition(fbsStatePar.getPageNum(),fbsStatePar.getPageSize(),fbsStatePar.getDevErrcommcount(),fbsStatePar.getUserId());
        res.put("f9600state",f9600StateRes);

        Response ld9stateRes = ld9StateService.searchByCondition(fbsStatePar.getPageNum(),fbsStatePar.getPageSize(),fbsStatePar.getDevErrcommcount(),fbsStatePar.getUserId());
        res.put("ld9state",ld9stateRes);
        return new Response().set(1, res);
    }

    public void addOrUpdate(List<Fbs9100State> deviceStateList) {
        List<Long> devIdList = deviceStateList.stream().map(Fbs9100State::getDevId).collect(Collectors.toList());
        QueryWrapper<Fbs9100State> query = Wrappers.query();
        query.in("dev_id",devIdList);
        List<Fbs9100State> fbs9100StateListInDB = mapper.selectList(query);
        List<Long> devIdListInDB = fbs9100StateListInDB.stream().map(Fbs9100State::getDevId).collect(Collectors.toList());

        for (Fbs9100State fbs9100State : deviceStateList) {
            if(devIdListInDB.contains(fbs9100State.getDevId())){ //更新
                UpdateWrapper<Fbs9100State> update = Wrappers.update();
                update.set("dev_workstate",fbs9100State.getDevWorkstate())
                        .set("dev_last_captest_stop_type",fbs9100State.getDevLastCaptestStopType())
                        .set("record_datetime",fbs9100State.getRecordDatetime())
                        .eq("dev_id",fbs9100State.getDevId());
                mapper.update(null,update);
            }else{ //新增
                mapper.insert(fbs9100State);
            }
        }

    }
}