package com.mes.job;

import cn.hutool.json.JSONObject;
import cn.smallbun.screw.core.util.CollectionUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.mes.common.config.Const;
import com.mes.common.utils.RedisUtil;
import com.mes.downglassinfo.entity.DownGlassInfo;
import com.mes.downglassinfo.entity.DownGlassTask;
import com.mes.downglassinfo.entity.request.DownGlassInfoRequest;
import com.mes.downglassinfo.service.DownGlassInfoService;
import com.mes.downglassinfo.service.DownGlassTaskService;
import com.mes.downstorage.service.DownStorageCageService;
import com.mes.downworkstation.entity.DownWorkstation;
import com.mes.downworkstation.service.DownWorkstationService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.tools.DateUtil;
import com.mes.tools.WebSocketServer;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;
import java.util.stream.Collectors;

@Slf4j
@Component
public class Downpush {

    @Autowired
    private DownWorkstationService downWorkstationService;
    @Autowired
    private DownStorageCageService downStorageCageService;
    @Autowired
    private DownGlassInfoService downGlassInfoService;
    @Autowired
    private DownGlassTaskService downGlassTaskService;
    @Autowired
    private GlassInfoService glassInfoService;
    private final ExecutorService scanCodeThreadPool = new ThreadPoolExecutor(
            10, // core pool size
            20, // maximum pool size
            60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>()
    );
    private final ExecutorService isRunThreadPool = Executors.newFixedThreadPool(5);

    @Value("${mes.scan.ip}")
    private String scanIp;

    @Value("${mes.scan.port}")
    private Integer scanPort;

    @Autowired
    private RedisUtil redisUtil;

    @Scheduled(fixedDelay = 2000)
    public void sendDownWorkstations() {
        log.info("发送工位玻璃信息");
        JSONObject jsonObject = new JSONObject();

        List<DownWorkstation> data = downWorkstationService.list();
        jsonObject.append("params", data);
        log.info(jsonObject.toString());
        ArrayList<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("unloadglass");
        if (sendwServer != null) {
            for (WebSocketServer webserver : sendwServer) {
                if (webserver != null && webserver.session.isOpen()) {
                    log.info("已发送");
                    webserver.sendMessage(jsonObject.toString());
                }
            }
        }
    }

    @Scheduled(fixedDelay = 1000)
    public void sendGlassInfoData() {
        log.info("发送工位显示图信息1");
        JSONObject jsonObject2 = new JSONObject();
        List<Map<String, Object>> glassinfodata = downWorkstationService.getTotalGlassDimensionsByWorkstation(1, 3);
        jsonObject2.append("glassinfo", glassinfodata);
        log.info(jsonObject2.toString());
        ArrayList<WebSocketServer> sendwServer2 = WebSocketServer.sessionMap.get("unloadglass2");
        if (sendwServer2 != null) {
            for (WebSocketServer webserver : sendwServer2) {
                if (webserver != null && webserver.session.isOpen()) {
                    webserver.sendMessage(jsonObject2.toString());
                }
            }
        }
    }

    @Scheduled(fixedDelay = 1000)
    public void sendGlassInfoData2() {
        log.info("发送工位显示图信息2");
        JSONObject jsonObject3 = new JSONObject();
        List<Map<String, Object>> glassinfodata2 = downWorkstationService.getTotalGlassDimensionsByWorkstation(4, 6);
        jsonObject3.append("glassinfo2", glassinfodata2);
        log.info(jsonObject3.toString());
        ArrayList<WebSocketServer> sendwServer3 = WebSocketServer.sessionMap.get("unloadglass3");
        if (sendwServer3 != null) {
            for (WebSocketServer webserver : sendwServer3) {
                if (webserver != null && webserver.session.isOpen()) {
                    webserver.sendMessage(jsonObject3.toString());
                }
            }
        }
    }

    @Scheduled(fixedDelay = 2000)
    public void sendDownStorageCages() {
        log.info("发送缓存玻璃信息");
        JSONObject jsonObject4 = new JSONObject();
        List<Map<String, Object>> list = downStorageCageService.selectDownStorageCages();
        jsonObject4.append("params2", list);
        log.info(jsonObject4.toString());
        ArrayList<WebSocketServer> sendwServer4 = WebSocketServer.sessionMap.get("downcache");
        if (sendwServer4 != null) {
            for (WebSocketServer webserver : sendwServer4) {
                if (webserver != null && webserver.session.isOpen()) {
                    webserver.sendMessage(jsonObject4.toString());
                }
            }
        }
    }

    @Scheduled(fixedDelay = 2000)
    public void sendDownGlassInfo() {
        DownGlassInfoRequest request = redisUtil.getCacheObject("downGlassRequest");
        if (null == request) {
            request = new DownGlassInfoRequest();
        }
        if (request.getBeginDate() == null) {
            request.setBeginDate(DateUtil.getBeginDate());
            request.setEndDate(DateUtil.getEndDate());
        }
        log.info("发送当前正在执行工程已落架的玻璃信息");
        LambdaQueryWrapper<DownGlassInfo> wrapper = new LambdaQueryWrapper<DownGlassInfo>()
                .between(null != request.getBeginDate(), DownGlassInfo::getGmtCreate, request.getBeginDate(), request.getEndDate())
                .eq(StringUtils.isNotBlank(request.getEngineerId()), DownGlassInfo::getEngineerId, request.getEngineerId());
        if (null == request.getWorkStationId() || 0 == request.getWorkStationId()) {
            wrapper.in(DownGlassInfo::getWorkStationId, Const.WORK_STATION_ALL);
        } else {
            wrapper.eq(DownGlassInfo::getWorkStationId, request.getWorkStationId());
        }
        List<DownGlassInfo> downGlassInfos = downGlassInfoService.list(wrapper);
//        Map<Integer, List<DownGlassInfo>> listMap = downGlassInfos.stream().collect(Collectors.groupingBy(DownGlassInfo::getWorkStationId));
        List<Object> engineerIdListTemp = downGlassInfoService.listObjs(new QueryWrapper<DownGlassInfo>().select("distinct engineer_id"));
        List<String> engineerIdList = engineerIdListTemp.stream().map(String::valueOf).collect(Collectors.toList());
        JSONObject jsonObject4 = new JSONObject();
        jsonObject4.append("downGlassInfos", downGlassInfos);
        jsonObject4.append("engineerIdList", engineerIdList);

        //钢化开关
        boolean autoPrint = false;
        if (redisUtil.getCacheObject("autoPrint") == null) {
            redisUtil.setCacheObject("autoPrint", false);
        } else {
            autoPrint = redisUtil.getCacheObject("autoPrint");
        }
        jsonObject4.append("autoPrint", autoPrint);
        //人工下片位置最后一片
        DownGlassTask takeGlass = downGlassTaskService.getOne(
                new QueryWrapper<DownGlassTask>()
                        .select("Top 1 *")
                        .eq("end_cell", Const.G13_WORK_STATION)
                        .lt("task_status", Const.UNLOAD_GLASS_DOWN)
                        .orderByDesc("id")
        );
        jsonObject4.append("takeGlass", takeGlass);


        ArrayList<WebSocketServer> sendwServer4 = WebSocketServer.sessionMap.get("unloadglass");
        if (sendwServer4 != null) {
            for (WebSocketServer webserver : sendwServer4) {
                if (webserver != null && webserver.session.isOpen()) {
                    webserver.sendMessage(jsonObject4.toString());
                }
            }
        }
    }

    @Scheduled(fixedDelay = 1000)
    public void isRun() {
        isRunThreadPool.execute(() -> {
            JSONObject jsonObject = new JSONObject();
            //正在进行的任务
            List<DownWorkstation> downWorkstation = downWorkstationService.getoneDownWorkstations(1, 6);
            jsonObject.append("downWorkstation", downWorkstation);
            List<DownGlassTask> downGlassTask = downGlassTaskService.selectOutTaskCache();
            jsonObject.append("downGlassTask", downGlassTask);
            ArrayList<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("unLoadGlassIsRun");
            if (sendwServer != null) {
                for (WebSocketServer webserver : sendwServer) {
                    if (webserver != null) {
                        webserver.sendMessage(jsonObject.toString());
                    } else {
                        log.info("unLoadGlassIsRun is closed");
                    }
                }
            }
        });

    }

    @Async
    @Scheduled(fixedDelay = Long.MAX_VALUE)
    public void scanCodeTask() {
        JSONObject jsonObject = new JSONObject();
        log.info("扫描任务已启动");
        while (true) {
            try (Socket socket = new Socket(scanIp, scanPort);
                 BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
                // 接收服务器响应
//                socket.setSoTimeout(1000);
                log.info("等待扫码中......");
                    String glassId = in.readLine();
                    log.info("扫描到的玻璃id：{}", glassId);
                    List<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("unloadglass");
                    if (CollectionUtils.isNotEmpty(sendwServer)) {
                        //按照玻璃id获取玻璃信息返回给前端界面，具体需要哪些数据待确认
                        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
                                .eq(GlassInfo::getGlassId, glassId).last("limit 1"));
                        if (null == glassInfo) {
                            log.info("按照玻璃id：{}，无法找到玻璃信息", glassId);
                        } else {
                            jsonObject.append("scanGlass",glassInfo);
                            sendwServer.get(0).sendMessage(jsonObject.toString());
                        }
                    }
            } catch (Exception exception) {
                log.info("读取异常，原因为{}", exception.getMessage());
            }
        }
    }

    @Scheduled(fixedDelay = Long.MAX_VALUE)
    public void scanCodeTaskCopy()
    {
        log.info("扫描任务已启动");
        try {
            BarcodeReadThread brt=new BarcodeReadThread(scanIp,scanPort,this);
            brt.start();

        }catch (Exception exception) {
            log.info("扫描任务启动异常，原因为{}", exception.getMessage());
        }

    }
    //socket读取到消息后会调用这个函数
    public void barcodeCheckin(String response)
    {
        log.info("扫描到的玻璃id：{}", response);
        List<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("scanCode");
        if (CollectionUtils.isNotEmpty(sendwServer)) {
            //按照玻璃id获取玻璃信息返回给前端界面，具体需要哪些数据待确认
            GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
                    .eq(GlassInfo::getGlassId, response).last("limit 1"));
            if (null == glassInfo) {
                log.info("按照玻璃id：{}，无法找到玻璃信息", response);
            } else {
                sendwServer.get(0).sendMessage(glassInfo.toString());
            }
        }
    }
}