package com.fzzy.igds.io.order;

import com.fzzy.igds.constant.Constant;
import com.fzzy.igds.constant.RedisConst;
import com.fzzy.igds.domain.LogOperation;
import com.fzzy.igds.request.ExeBaseRequest;
import com.fzzy.igds.request.ReqStatus;
import com.fzzy.igds.request.ThReqData;
import com.fzzy.igds.service.LogOperationService;
import com.fzzy.igds.utils.ContextUtil;
import com.ruoyi.common.core.redis.RedisCache;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @Description 命令执行校验等信息接口
 * @Author CZT
 * @Date 2025/12/9 10:19
 */
@Service
public class ExeOrderService {

    @Resource
    private RedisCache redisCache;
    @Resource
    private LogOperationService logService;

    /**
     *
     * @param baseRequest
     */
    public void addCache(ExeBaseRequest baseRequest) {
        // 添加缓存
        this.addReqCache(baseRequest);
    }

    /**
     *
     * @param request
     */
    public void addLog(ExeBaseRequest request) {
        // 添加日志
        this.addLogByExeReq(request);
    }

    /**
     *
     * @param baseRequest
     */
    public void addLogAndCache(ExeBaseRequest baseRequest) {

        // 添加缓存
        this.addReqCache(baseRequest);

        // 添加日志
        this.addLogByExeReq(baseRequest);
    }

    /**
     * 存放温湿度命令缓存
     * @param request
     */
    public void addThCache(ExeBaseRequest request) {

        ThReqData reqData = (ThReqData) request.getReqData();

        if (null == reqData) return;

        String key = this.buildExeOrderKey(request.getBizType(),
                request.getDeptId(), request.getSerId() + "_" + reqData.getThConf(), request.getRequestId());

        redisCache.setCacheObject(key, request, 8 * 60, TimeUnit.MINUTES);
    }

    /**
     *
     * @param companyId
     * @param serId
     * @return
     */
    public ExeBaseRequest getControlCache(String companyId, String serId) {
        String key = Constant.APP_NAME + ":" + companyId + ":DEVICE_CTRL:" + serId;
        return (ExeBaseRequest) redisCache.getCacheObject(key);
    }

    /**
     *
     * @param bizType
     * @param type
     * @param id
     * @return
     */
    public List<ExeBaseRequest> getInProgressOrderById(String bizType, String type, String id) {
        if (StringUtils.isEmpty(bizType)){
            return null;
        }
        if (StringUtils.isEmpty(type)){
            return null;
        }
        if (StringUtils.isEmpty(id)){
            return null;
        }

        bizType = ":" + bizType;
        type = ":" + type + ":";
        id = ":" + id + ":";

        String pattern = Constant.APP_NAME + ":" + RedisConst.KEY_ORDER_PRE + bizType + type + "*";

        Collection<String> keys = redisCache.keys(pattern);

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

        List<ExeBaseRequest> result = new ArrayList<>();
        ExeBaseRequest exeRequest;
        for (String key : keys) {
            if (key.indexOf(id) > 0) {
                exeRequest = (ExeBaseRequest) redisCache.getCacheObject(key);
                if (null == exeRequest){
                    continue;
                }
                result.add(exeRequest);
//                if (ReqStatus.IN_PROGRESS.getCode().equals(
//                        exeRequest.getStatus())) {
//                    result.add(exeRequest);
//                }
            }
        }

        return result;
    }

    /**
     *
     * @param bizType
     * @param type
     * @param deptId
     * @param timout
     * @return
     */
    public List<ExeBaseRequest> getAllOrderByDeptId(String bizType,String type, String deptId, int timout) {
        if (StringUtils.isEmpty(bizType))
            return null;
        if (StringUtils.isEmpty(deptId))
            return null;
        bizType = ":" + bizType;
        type = ":" + type;

        String pattern = Constant.APP_NAME + ":" + RedisConst.KEY_ORDER_PRE + bizType + type + "*";

        Collection<String> keys = redisCache.keys(pattern);

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

        List<ExeBaseRequest> result = new ArrayList<>();
        ExeBaseRequest exeRequest;
        for (String key : keys) {
            exeRequest = redisCache.getCacheObject(key);
            if (null == exeRequest){
                continue;
            }
            if(exeRequest.getDeptId().equals(deptId)){
                if (ReqStatus.IN_PROGRESS.getCode().equals(exeRequest.getStatus()) && timout > 0) {
                    if (System.currentTimeMillis() - exeRequest.getExeTime().getTime() > (timout * 1000)) {
                        exeRequest.setExeMsg("等待超过" + timout + "秒后终端没有反馈");
                        exeRequest.setStatus(ReqStatus.TIMEOUT_ERROR.getCode());
                    }
                }

                result.add(exeRequest);
            }
        }
        return result;
    }

    /**
     *
     * @param request
     * @param isDel
     */
    public void completeCache(ExeBaseRequest request, boolean isDel) {
        request.setStatus(ReqStatus.COMPLETE.getCode());

        if (StringUtils.isNotEmpty(request.getErrorMsg())) {
            request.setStatus(ReqStatus.ANALYSIS_ERROR.getCode());
        }

        if (isDel) {
            delReqCache(request);
        } else {
            addCache(request);
        }
    }

    /**
     *
     * @param companyId
     * @param bizType
     * @param deptId
     */
    public void clean(String companyId, String bizType, String deptId) {
        if (StringUtils.isEmpty(bizType))
            return;
        if (StringUtils.isEmpty(deptId))
            return;

        String pattern = Constant.APP_NAME + ":" + RedisConst.KEY_ORDER_PRE
                + ":" + bizType + ":" + "*";

        Collection<String> keys = redisCache.keys(pattern);

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

        for (String key : keys) {
            redisCache.deleteObject(key);
        }
    }

    /**
     * @param request
     */
    public void addLogByExeReq(ExeBaseRequest request) {
        LogOperation log = new LogOperation();
        log.setCompanyId(request.getCompanyId());
        log.setOperateUser(ContextUtil.getLoginUserName());
        log.setOperateTime(new Date());
        log.setBizType(request.getBizType());
        log.setDeptId(request.getDeptId());
        log.setOperateInfo(request.getExeMsg());
        if (StringUtils.isNotEmpty(request.getErrorMsg())) {
            log.setOperateInfo(request.getExeMsg() + "。" + request.getErrorMsg());
        }

        logService.addLog(log);
    }

    /**
     * 注意：当前存放的是业务执行的命令信息,判断是否存放功能缓存，默认存放
     *
     * @param request
     */
    public void addReqCache(ExeBaseRequest request) {

        //添加业务缓存
        String key = this.buildReqKeyByBiz(request.getBizType(),request.getDepotId(), request.getRequestId());
        redisCache.setCacheObject(key, request, 60, TimeUnit.MINUTES);

        //添加功能缓存
        if(request.isAddCacheTag()){
            key = this.buildReqKeyByFun(request.getBizType(),request.getSerId(), request.getRequestId());
            redisCache.setCacheObject(key, request, 60, TimeUnit.MINUTES);
        }
    }

    /**
     * 注意：当前存放的是业务执行的命令信息
     *
     * @param request
     */
    public void delReqCache(ExeBaseRequest request) {

        //删除业务缓存
        String key = this.buildReqKeyByBiz(request.getBizType(), request.getDepotId(), request.getRequestId());
        redisCache.deleteObject(key);

        //删除功能缓存
        if(request.isAddCacheTag()){
            key = this.buildReqKeyByFun(request.getBizType(),request.getSerId(), request.getRequestId());
            redisCache.deleteObject(key);
        }
    }

    /**
     * 业务缓存key,生成规则：igds:ORDER:bizType:BIZ:serId:orderId
     *
     * @param bizType
     * @param depotId
     * @param orderId
     * @return
     */
    private String buildReqKeyByBiz(String bizType, String depotId, String orderId) {
        if (StringUtils.isEmpty(bizType))
            bizType = "sys";

        if (StringUtils.isEmpty(orderId))
            orderId = ContextUtil.getTimeId(10000, 99999);

        return Constant.APP_NAME + ":" +RedisConst.KEY_ORDER_PRE + ":" + bizType + ":BIZ:" + depotId + ":" + orderId;
    }

    /**
     * 功能缓存key,生成规则：igds:ORDER:bizType:FUN:serId:orderId
     *
     * @param bizType
     * @param serId
     * @param orderId
     * @return
     */
    private String buildReqKeyByFun(String bizType, String serId, String orderId) {
        if (StringUtils.isEmpty(bizType))
            bizType = "sys";

        if (StringUtils.isEmpty(orderId))
            orderId = ContextUtil.getTimeId(10000, 99999);

        return Constant.APP_NAME + ":" +RedisConst.KEY_ORDER_PRE + ":" + bizType  + ":FUN:" + serId + ":" + orderId;
    }

    /**
     * 命令缓存生成规则：appName:KEY_KEY_ORDER:bizType:deptId:serId:orderId
     *
     * @param bizType 业务类型
     * @param deptId  库区编码
     * @param serId   分机编码
     * @param orderId
     * @return
     */
    private String buildExeOrderKey(String bizType, String deptId,
                                    String serId, String orderId) {
        if (StringUtils.isEmpty(bizType))
            bizType = "sys";
        if (StringUtils.isEmpty(deptId))
            deptId = "01";
        if (StringUtils.isEmpty(serId))
            serId = "0001";
        if (StringUtils.isEmpty(orderId))
            orderId = "5000";

        return Constant.APP_NAME + ":" + RedisConst.KEY_ORDER_PRE + ":"
                + bizType + ":" + deptId + ":" + serId + ":" + orderId;
    }
}