package com.ld.igds.warn.service;

import com.bstek.bdf2.core.model.DefaultUser;
import com.ld.igds.constant.BizType;
import com.ld.igds.constant.Constant;
import com.ld.igds.constant.NoticeType;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.models.MWarnConf;
import com.ld.igds.warn.WarnUtils;
import com.ld.igds.warn.data.WarnData;
import com.ld.igds.websocket.WebSocketPacket;
import com.ld.igds.websocket.WebSocketServer;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;

/**
 * @Desc: 新增警告和通知作为异步处理方式
 * @author: andy.jia
 * @update-time: 2023/2/10 17:54
 */
@Slf4j
public class WarnNoticeTask implements Callable<String> {

    private CoreWarnServiceImpl coreWarnService;

    private WarnData warnData;

    private WarnUtils warnUtils;

    private String warnTag;

    private String interfaceId;

    public WarnNoticeTask() {
        super();
    }

    public WarnNoticeTask(CoreWarnServiceImpl coreWarnService, WarnData warnData, String interfaceId, String warnTag, WarnUtils warnUtils) {
        super();
        this.coreWarnService = coreWarnService;
        this.warnData = warnData;
        this.interfaceId = interfaceId;
        this.warnTag = warnTag;
        this.warnUtils = warnUtils;
    }

    @Override
    public String call() {

        //获取通知配置信息
        MWarnConf conf = coreWarnService.getCacheWarnConf(warnData.getCompanyId(), warnData.getDeptId());
        warnData.setNoticeResult("推送失败");
        try {

            if (null == conf) {
                log.info("未获取到通知配置，不推送");
                warnData.setRemark("未获取到通知配置");
                coreWarnService.addWarn(warnData);
                return "SUCCESS";
            }

            if (Constant.YN_N.equals(conf.getVal())) {
                log.info("警告通知未启用，不推送");
                warnData.setRemark("警告通知未启用");
                coreWarnService.addWarn(warnData);
                return "SUCCESS";
            }

            //判断通知时段
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(new Date());
            int hour = calendar.get(Calendar.HOUR_OF_DAY);
            if (hour < conf.getStart() || conf.getEnd() < hour) {
                log.info("当前警告时间不在警告通知时段内，告警时段为：{}时，通知时段为：{}时~{}时", hour, conf.getStart(), conf.getEnd());
                warnData.setRemark("当前警告时间不在警告通知时段内，告警时段为：" + hour + "时，通知时段为：" + conf.getStart() + "时~" + conf.getEnd() + "时");
                coreWarnService.addWarn(warnData);
                return "SUCCESS";
            }

            //系统模块警告开启
            if (StringUtils.isNotEmpty(warnTag) && Constant.MODEL_SYS.equals(warnTag) && Constant.YN_Y.equals(conf.getSystemTag())) {
                warnData = noticeWarn(warnData, interfaceId, conf);
                coreWarnService.addWarn(warnData);
                return "SUCCESS";
            }

            //粮情模块警告开启
            if (StringUtils.isNotEmpty(warnTag) && Constant.MODEL_GRAIN.equals(warnTag) && Constant.YN_Y.equals(conf.getGrainTag())) {
                warnData = noticeWarn(warnData, interfaceId, conf);
                coreWarnService.addWarn(warnData);
                return "SUCCESS";
            }

            //出入库模块警告开启
            if (StringUtils.isNotEmpty(warnTag) && Constant.MODEL_INOUT.equals(warnTag) && Constant.YN_Y.equals(conf.getInoutTag())) {
                warnData = noticeWarn(warnData, interfaceId, conf);
                coreWarnService.addWarn(warnData);
                return "SUCCESS";
            }

            //安防模块警告开启
            if (StringUtils.isNotEmpty(warnTag) && Constant.MODEL_SECURITY.equals(warnTag) && Constant.YN_Y.equals(conf.getSecurityTag())) {
                warnData = noticeWarn(warnData, interfaceId, conf);
                coreWarnService.addWarn(warnData);
                return "SUCCESS";
            }

            //数量监测模块警告开启
            if (StringUtils.isNotEmpty(warnTag) && Constant.MODEL_QUANTITY.equals(warnTag) && Constant.YN_Y.equals(conf.getQuantityTag())) {
                warnData = noticeWarn(warnData, interfaceId, conf);
                coreWarnService.addWarn(warnData);
                return "SUCCESS";
            }
            log.info("业务模块通知未启用，不推送");
            warnData.setRemark("业务模块通知未启用");
            coreWarnService.addWarn(warnData);
            return "SUCCESS";
        } catch (Exception e) {
            log.error("-----推送异常-----，原因={}", e.toString());
            //保存警告信息
            coreWarnService.addWarn(warnData);
            return "SUCCESS";
        }
    }

    /**
     * 不同方式通知警告
     *
     * @param warnData
     * @param interfaceId
     * @param warnConf
     * @return
     */
    private WarnData noticeWarn(WarnData warnData, String interfaceId, MWarnConf warnConf) {

        //默认系统推送
        WebSocketPacket packet = new WebSocketPacket();
        packet.setDeptId(warnData.getDeptId());
        packet.setCompanyId(warnData.getCompanyId());
        packet.setBizType(BizType.SYS.getCode());
        packet.setBizTag("common");
        packet.setOrderResp(OrderRespEnum.MSG_ERROR.getCode());
        packet.setData(warnData.getInfo());
        WebSocketServer.sendByPocket(packet);


        //微信通知
        if (NoticeType.WECHAT.getCode().equals(warnConf.getNoticeType())) {
            List<DefaultUser> listUsers = warnUtils.getWarnUserByWarnConf(warnConf, warnData.getDepotId());
            warnData = warnUtils.setPhoneByWeChat(warnData, listUsers);
            String msg = coreWarnService.sendByWeChat(warnData, interfaceId, warnData.getCompanyId());

            if ("SUCCESS".equals(msg)) {
                log.error("-----微信推送成功-----，推送信息={}", warnData);
                warnData.setNoticeResult("推送成功");
            } else {
                warnData.setNoticeResult(warnData.getNoticeResult() + "，原因：" + msg);
            }
        }


        return warnData;
    }
}