package com.whyc.webSocket;

import com.whyc.config.WebSocketConfig;
import com.whyc.dto.Real.TopDto;
import com.whyc.dto.RealTimeDto;
import com.whyc.dto.Response;
import com.whyc.factory.BattCapFactory;
import com.whyc.pojo.db_batt_testdata.BatttestdataInf;
import com.whyc.pojo.db_ram_db.BattRtstate;
import com.whyc.pojo.db_ram_db.DeviceState;
import com.whyc.pojo.db_ram_db.PwrdevAcdcdata;
import com.whyc.pojo.db_station.BattInf;
import com.whyc.pojo.db_station.PowerInf;
import com.whyc.pojo.db_station.StationInf;
import com.whyc.pojo.db_user.User;
import com.whyc.service.*;
import com.whyc.util.ActionUtil;
import com.whyc.util.ThreadLocalUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpSession;
import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.util.HashMap;
import java.util.Map;

@Component
@ServerEndpoint(value = "/real",encoders = WebSocketEncoder.class,configurator = WebSocketConfig.class)
public class RealTimeSocket {
    private Session session;

    private Thread thread;
    //实时数据
    private static BattRtstateService battRtstateService;

    private static DeviceStateService  deviceStateService;

    private static PwrdevAcdcdataService  pwrdevAcdcdataService;

    //实时告警
    private static BattalarmDataService  battalarmDataService;

    private static DevalarmDataService devalarmDataService;

    private static PwrdevAlarmService  pwrdevAlarmService;

    //放电记录
    private static BatttestdataInfService batttestdataInfService;

    //电池组信息
    private static BattInfService battInfService;

    //机房信息
    private static StationInfService stationInfService;

    //电源信息
    private static PowerInfService powerInfService;


    private volatile boolean runFlag = true;

    private static HttpSession httpSession;

    private volatile Map<String, Thread> threadMap = new HashMap<>();

    private volatile Map<Long,Boolean> threadFlagMap = new HashMap<>();

    @Autowired
    public void setBattRtstateService(BattRtstateService battRtstateService) {
        RealTimeSocket.battRtstateService = battRtstateService;
    }

    @Autowired
    public void setDeviceStateService(DeviceStateService deviceStateService) {
        RealTimeSocket.deviceStateService = deviceStateService;
    }

    @Autowired
    public void setPwrdevAcdcdataService(PwrdevAcdcdataService pwrdevAcdcdataService) {
        RealTimeSocket.pwrdevAcdcdataService = pwrdevAcdcdataService;
    }

    @Autowired
    public void setBattalarmDataService(BattalarmDataService battalarmDataService) {
        RealTimeSocket.battalarmDataService = battalarmDataService;
    }

    @Autowired
    public void setDevalarmDataService(DevalarmDataService devalarmDataService) {
        RealTimeSocket.devalarmDataService = devalarmDataService;
    }

    @Autowired
    public void setPwrdevAlarmService(PwrdevAlarmService pwrdevAlarmService) {
        RealTimeSocket.pwrdevAlarmService = pwrdevAlarmService;
    }

    @Autowired
    public void setBatttestdataInfService(BatttestdataInfService batttestdataInfService) {
        RealTimeSocket.batttestdataInfService = batttestdataInfService;
    }

    @Autowired
    public void setBattInfService(BattInfService battInfService) {
        RealTimeSocket.battInfService = battInfService;
    }

    @Autowired
    public void setStationInfService(StationInfService stationInfService) {
        RealTimeSocket.stationInfService = stationInfService;
    }

    @Autowired
    public void setPowerInfService(PowerInfService powerInfService) {
        RealTimeSocket.powerInfService = powerInfService;
    }



    @OnOpen
    public void onOpen(Session session, EndpointConfig config) {
        this.session = session;
        this.httpSession = (HttpSession) config.getUserProperties().get("httpSession");
    }
    @OnMessage
    public void onMessage(Session session, String message) {
        RealTimeDto realDto= ActionUtil.getGson().fromJson(message,RealTimeDto.class);
        if(httpSession!=null){
            User user = (User) httpSession.getAttribute("user");
            realDto.setUid(user.getId());
        }else{
            realDto.setUid(99);
        }
        thread = new Thread("Thread_realTimeSocket") {
            @Override
            public void run() {
                while (runFlag && !isInterrupted()) {
                    Thread thread = currentThread();
                    threadFlagMap.put(thread.getId(), true);
                    try {
                        Map<String, Object> map=new HashMap<>();
                        //获取头部信息
                        Response topRes=getTop(realDto);
                        map.put("topRes",topRes);
                        //根据pageType获取返回界面
                        Response realRes=getRes(realDto);
                        map.put("realRes",realRes);
                        if (session.isOpen()) {
                            //推送信息
                            synchronized (session) {
                                session.getBasicRemote().sendObject(new Response<>().setII(1,true,map,"实时页面数据推送"));
                            }
                            threadFlagMap.put(thread.getId(), false);
                        }
                        sleep(4000);
                    } catch (Exception e) {
                        interrupt();
                    }
                }
            }
        };
        thread.start();
        threadFlagMap.put(thread.getId(),true);
        //停止老的socket线程
        Thread threadBefore = threadMap.get(session.getId());
        if(threadBefore !=null && threadBefore.isAlive()){
            while (threadFlagMap.get(threadBefore.getId())){
            }
            threadBefore.interrupt();
        }
        //将线程存储,便于调用定位
        threadMap.put(session.getId(), this.thread);
    }
    //获取头部信息
    private Response getTop(RealTimeDto realDto) {
        TopDto topDto = new TopDto();
        try {
            //实时获取电池组信息
            BattRtstate battRtstate = battRtstateService.getBattRealInfo(realDto.getBattgroupId());
            if (battRtstate != null) {
                topDto.setBattState(battRtstate.getBattState());
                topDto.setVbusVol(battRtstate.getVbusVol());
                topDto.setOnlineVol(battRtstate.getOnlineVol());
                topDto.setRecordtime(ThreadLocalUtil.format(battRtstate.getRecDatetime(),1));
            }
            //实时获取电池组信息
            BattInf binf=battInfService.getBinfByBattgroupId(realDto.getBattgroupId());
            if(binf!=null){
                topDto.setBattGroupName(binf.getBattgroupName());
                topDto.setDevName(binf.getDevName());
            }
            //获取机房信息
            StationInf stationInf = stationInfService.getStationInfById(binf.getStationId());
            if(stationInf!=null){
                topDto.setStationName(stationInf.getStationName());
                topDto.setProvice(stationInf.getProvice());
                topDto.setCity(stationInf.getCity());
                topDto.setCounty(stationInf.getCountry());
                topDto.setFullName(stationInf.getFullName());
            }
            //获取电源信息
            PowerInf powerInf = powerInfService.getPowerInfById(binf.getPowerId());
            if(powerInf!=null){
                topDto.setPowerName(powerInf.getPowerName());
            }
            //实时获取设备信息
            DeviceState deviceState = deviceStateService.getDevRealInfo(realDto.getDevId());
            if (deviceState != null) {
                topDto.setDevState(deviceState.getDevWorkstate());
                if (deviceState.getDevWorkstate() == 1) {//核容放电
                    topDto.setCaptestGroupvol(deviceState.getDevCaptestGroupvol());
                    topDto.setCaptestCurr(deviceState.getDevCaptestCurr());
                    topDto.setCaptestTimelong(deviceState.getDevCaptestTimelong());
                    topDto.setCaptestCap(deviceState.getDevCaptestCap());
                    //剩余容量和剩余时间计算
                    Float restCap = batttestdataInfService.getLastTestDataRestCap(realDto.getBattgroupId());
                    topDto.setRestCap(restCap);
                    //实时组端电流，剩余容量，标称容量
                    if(battRtstate!=null){
                        Float restTime= BattCapFactory.getTheoryTime(battRtstate.getGroupCurr(), restCap, binf.getMoncapstd());
                        topDto.setRestTime(restTime);
                    }
                }

                //获取一级未处理实时告警数
                Integer battALmNum = battalarmDataService.getBattAlmNum(realDto.getBattgroupId());
                topDto.setBattALmNum(battALmNum);

                Integer devALmNum = devalarmDataService.getDevAlmNum(realDto.getDevId());
                topDto.setDevALmNum(devALmNum);

                Integer pwrALmNum = pwrdevAlarmService.getPwrAlmNum(realDto.getPowerId());
                topDto.setPwrALmNum(pwrALmNum);

                //实时获取电源信息(是否存在电源告警信息)
                //PwrdevAcdcdata pwrdevAcdcdata = pwrdevAcdcdataService.getPwrRealInfo(realDto.getPowerId());
                topDto.setPwrState((pwrALmNum > 0 ? 1 : 0));

                Integer allALmNum = battALmNum + devALmNum + pwrALmNum;
                topDto.setAllALmNum(allALmNum);
                topDto.setSystemState((allALmNum > 0 ? 1 : 0));
            }
            return new Response().setII(1, true, topDto, "实时页面头部数据推送");
        } catch (Exception e) {
            return new Response().set(1, false, "实时页面头部数据推送");
        }
    }

    //根据pageType获取返回界面
    private Response getRes(RealTimeDto realDto) {
        Response res=new Response();
        switch (realDto.getPageType()){
            case "system":res=getSystemPage(realDto);break;
            case "power":res=getPowerPage(realDto);break;
            case "vol":res=getVolPage(realDto);break;
            case "res":res=getResPage(realDto);break;
            case "tmp":res=getTmpPage(realDto);break;
            case "img":res=getImgPage(realDto);break;
            case "3D":res=get3DPage(realDto);break;
            case "self":res=getSelfPage(realDto);break;
            case "manage":res=getManagePage(realDto);break;
            default:res=new Response().set(1);
        }
        return res;
    }
    //获取管理界面信息
    private Response getManagePage(RealTimeDto realDto) {
        return new Response().set(1);
    }
    //获取自愈能力界面信息
    private Response getSelfPage(RealTimeDto realDto) {
        return new Response().set(1);
    }
    //获取3D界面信息
    private Response get3DPage(RealTimeDto realDto) {
        return new Response().set(1);
    }
    //获取图片界面信息
    private Response getImgPage(RealTimeDto realDto) {
        return new Response().set(1);
    }
    //获取温度界面信息
    private Response getTmpPage(RealTimeDto realDto) {
        return new Response().set(1);
    }
    //获取内阻界面信息
    private Response getResPage(RealTimeDto realDto) {
        return new Response().set(1);
    }
    //获取电压界面信息
    private Response getVolPage(RealTimeDto realDto) {
        return new Response().set(1);
    }
    //获取电源界面信息
    private Response getPowerPage(RealTimeDto realDto) {
        Map<String, Object> map=new HashMap<>();
        try {
            //实时获取电源信息
            PwrdevAcdcdata pwrdevAcdcdata = pwrdevAcdcdataService.getPwrRealInfo(realDto.getPowerId());
            map.put("pwrdevAcdcdata",pwrdevAcdcdata);
            return new Response().setII(1,true,map,"电源界面信息推送");
        }catch (Exception e){
            return new Response().set(1,false,"电源界面信息推送");
        }
    }
    //获取系统概述界面信息
    private Response getSystemPage(RealTimeDto realDto) {
        Map<String, Object> map=new HashMap<>();
        try {
            //实时获取电池组信息
            BattRtstate battRtstate = battRtstateService.getBattRealInfo(realDto.getBattgroupId());
            map.put("battRtstate",battRtstate);
            //实时获取设备信息
            DeviceState deviceState = deviceStateService.getDevRealInfo(realDto.getDevId());
            map.put("deviceState",deviceState);
            //获取上一次标准核容信息
            BatttestdataInf tinfData= batttestdataInfService.getLastStandardTestData(realDto.getBattgroupId());
            map.put("tinfData",tinfData);
            //获取近半小时电源数据
            //获取近半小时整流器数据
            //获取近半小时核容设备数据
            return new Response().setII(1,true,map,"系统概述推送");
        }catch (Exception e) {
            e.printStackTrace();
        }
        return new Response().set(1,false,"系统概述推送");
    }

    @OnClose
    public void onClose(CloseReason closeReason){
        System.err.println("closeReason = " + closeReason);
        runFlag = false;
        if (thread != null && thread.isAlive()) {
            thread.interrupt();
        }
        threadMap.remove(session.getId());
    }

    @OnError
    public void onError(Throwable error) {
        error.printStackTrace();
        if (thread != null && thread.isAlive()) {
            thread.interrupt();
        }
        threadMap.remove(session.getId());
    }
}