package com.ld.igds.order.impl;

import com.ld.igds.constant.BizType;
import com.ld.igds.constant.Constant;
import com.ld.igds.constant.RedisConst;
import com.ld.igds.io.notify.NotifyWebInvoker;
import com.ld.igds.io.request.BaseRequest;
import com.ld.igds.log.service.LogOperationService;
import com.ld.igds.order.ExeOrderService;
import com.ld.igds.order.OrderUtil;
import com.ld.igds.order.constant.ExeStatus;
import com.ld.igds.order.data.ExeRequest;
import com.ld.igds.order.data.ExeResponse;
import com.ld.igds.order.data.OrderProgress;
import com.ld.igds.util.ContextUtil;
import com.ld.igds.util.RedisUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

/**
 * 执行接口
 *
 * @author jiazx
 */
@Component
public class ExeOrderServiceImpl implements ExeOrderService {

    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private LogOperationService logService;
    @Autowired
    private NotifyWebInvoker notifyWebInvoker;

    @Override
    public ExeResponse checkExecute(ExeRequest request) {
        // 添加操作人
        if (null == request.getExeUser())
            request.setExeUser(ContextUtil.getLoginUserCName());

        // 如果允许重复执行，不核验直接添加日志信息
        if (request.isRepeatTag()) {// 运行重复执行
            return new ExeResponse(ExeResponse.CHECK_SUCCESS, "验证信息通过！");
        }

        // 严重是否有正在执行的命令
        boolean isExe = this.isExe(request.getBizType(), request.getDeptId(), request.getSerId(), request.getDepotId());

        if (isExe) {
            return new ExeResponse(ExeResponse.CHECK_ERROR,
                    "系统说明：当前控制柜命令正在执行，不能重复发送请求！");
        }
        return new ExeResponse(ExeResponse.CHECK_SUCCESS, "验证信息通过！");
    }

    /**
     * 存放温湿度命令缓存
     */
    @Override
    public void addThCache(ExeRequest request) {
        String key = this.buildExeOrderKey(request.getBizType(),
                request.getDeptId(), request.getSerId() + "_" + request.getThConf(), request.getOrderId());
        redisUtil.set(key, request, 8 * 60 * 60);
    }

    /**
     * 添加执行缓存，缓存时间为默认8个小时
     *
     * @param request
     */
    @Override
    public void addCache(ExeRequest request) {
        String key = this.buildExeOrderKey(request.getBizType(), request.getDeptId(), request.getSerId(), request.getOrderId());
        redisUtil.set(key, request, 8 * 60 * 60);
    }

    /**
     * 添加执行缓存，缓存时间为默认8个小时，不要bizTYpe
     *
     * @param request
     */
    @Override
    public void addControlCacheAndLog(ExeRequest request) {

        addControlCache(request);

        logService.addLogByExeReq(request);
    }

    @Override
    public void addErrorCache(String companyId, String bizType, String deptId,
                              String depotName, String msg) {
        ExeRequest exeRequest = new ExeRequest();
        exeRequest.setOrderId(ContextUtil.buildExeOrderId(companyId, "0",
                bizType));
        exeRequest.setMsg(msg);
        exeRequest.setStatus(ExeStatus.SEND_ERROR.getCode());
        exeRequest.setCompanyId(companyId);
        // exeRequest.setDepotId(depotId);
        exeRequest.setDepotName(depotName);
        exeRequest.setBizType(bizType);
        exeRequest.setExeUser(ContextUtil.getLoginUserCName());
        exeRequest.setSerId("0");
        exeRequest.setDeptId(deptId);

        addCache(exeRequest);
    }

    @Override
    public void addErrorCache(BaseRequest request, String msg) {
        ExeRequest exeRequest = new ExeRequest();
        exeRequest.setOrderId(ContextUtil.buildExeOrderId(request.getCompanyId(), "0", request.getBizType()));
        exeRequest.setMsg(msg);
        exeRequest.setStatus(ExeStatus.SEND_ERROR.getCode());
        exeRequest.setCompanyId(request.getCompanyId());
        exeRequest.setDepotId(request.getDepotId());
        exeRequest.setDepotName(request.getDepotName());
        exeRequest.setBizType(request.getBizType());
        exeRequest.setExeUser(ContextUtil.getLoginUserCName());
        exeRequest.setSerId("0");
        exeRequest.setDeptId(request.getDeptId());
        addCache(exeRequest);
    }

    /**
     * 命令缓存生成规则：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 = BizType.SYS.getCode();
        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;
    }

    /**
     * 命令缓存生成规则：appName:KEY_KEY_ORDER:bizType:deptId:serId:orderId
     *
     * @param deptId  库区编码
     * @param serId   分机编码
     * @param orderId
     * @return
    
    private String buildControlExeOrderKey(String deptId, String serId, String orderId) {
        String bizType = BizType.AREATION.getCode();
        return buildExeOrderKey(bizType, deptId, serId, orderId);
    }
     */

    @Override
    public void addLogAndCache(ExeRequest exeRequest) {
        // 添加缓存
        this.addCache(exeRequest);

        // 添加日志
        logService.addLogByExeReq(exeRequest);
    }

    @Override
    public void addControlCache(ExeRequest request) {
        String key = Constant.APP_NAME + ":" + request.getCompanyId() + ":DEVICE_CTRL:" + request.getSerId();
        redisUtil.set(key, request, 5 * 60);
    }

    @Override
    public ExeRequest getControlCache(String companyId, String serId) {
        String key = Constant.APP_NAME + ":" + companyId + ":DEVICE_CTRL:" + serId;
        return (ExeRequest) redisUtil.get(key);
    }


    /**
     * 严重是否有正在执行的命令
     *
     * @param bizType
     * @param depotId
     * @param serId
     * @return
     */
    private boolean isExe(String bizType, String deptId, String serId,
                          String depotId) {
        if (StringUtils.isEmpty(bizType))
            return false;
        if (StringUtils.isEmpty(depotId))
            return false;
        if (StringUtils.isEmpty(serId))
            return false;
        if (StringUtils.isEmpty(deptId))
            return false;

        bizType = ":" + bizType;
        deptId = ":" + deptId;
        serId = ":" + serId;

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

        Set<String> keys = redisUtil.keys(pattern);

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

        ExeRequest exeRequest;
        for (String key : keys) {
            if (key.indexOf(depotId) > 0) {
                exeRequest = (ExeRequest) redisUtil.get(key);
                if (null == exeRequest)
                    continue;
                if (ExeStatus.IN_PROGRESS.getCode().equals(
                        exeRequest.getStatus())) {
                    return true;
                }
            }
        }

        return false;
    }

    @Override
    public ExeRequest getOrderById(String bizType, String orderId) {
        if (StringUtils.isEmpty(bizType))
            return null;
        if (StringUtils.isEmpty(orderId))
            return null;
        bizType = ":" + bizType;
        orderId = ":" + orderId;

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

        Set<String> keys = redisUtil.keys(pattern);

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

        for (String key : keys) {
            if (key.indexOf(orderId) > 0) {
                return (ExeRequest) redisUtil.get(key);
            }
        }

        return null;
    }

    @Override
    public List<ExeRequest> getInProgressOrderBySerId(String bizType,
                                                      String serId) {
        if (StringUtils.isEmpty(bizType))
            return null;
        if (StringUtils.isEmpty(serId))
            return null;

        bizType = ":" + bizType;
        serId = ":" + serId + ":";

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

        Set<String> keys = redisUtil.keys(pattern);

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

        List<ExeRequest> result = new ArrayList<>();
        ExeRequest exeRequest;
        for (String key : keys) {
            //key=igds:KEY_ORDER:grain:5016_001:10:5190
            if (key.indexOf(serId) > 0) {
                exeRequest = (ExeRequest) redisUtil.get(key);
                if (null == exeRequest)
                    continue;

                if (ExeStatus.IN_PROGRESS.getCode().equals(
                        exeRequest.getStatus())) {
                    result.add(exeRequest);
                }
            }
        }

        return result;
    }

    @Override
    public List<ExeRequest> getAllOrderByDeptId(String bizType, String deptId, int timout) {
        if (StringUtils.isEmpty(bizType))
            return null;
        if (StringUtils.isEmpty(deptId))
            return null;
        bizType = ":" + bizType;
        deptId = ":" + deptId;

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

        Set<String> keys = redisUtil.keys(pattern);

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

        List<ExeRequest> result = new ArrayList<>();
        ExeRequest exeRequest;
        for (String key : keys) {
            exeRequest = (ExeRequest) redisUtil.get(key);
            if (null == exeRequest)
                continue;
            // 封装信息没有必要
            exeRequest.setReqData(null);

            if (ExeStatus.IN_PROGRESS.getCode().equals(exeRequest.getStatus()) && timout > 0) {
                if (System.currentTimeMillis() - exeRequest.getExeTime().getTime() > (timout * 1000)) {
                    exeRequest.setMsg("等待超过" + timout + "秒后终端没有反馈");
                    exeRequest.setStatus(ExeStatus.TIMEOUT_ERROR.getCode());
                }
            }

            result.add(exeRequest);
        }

        return result;
    }

    @Override
    public void completeCache(ExeRequest request, boolean isError) {
        String key = buildExeOrderKey(request.getBizType(),
                request.getDeptId(), request.getSerId(), request.getOrderId());
        request.setStatus(ExeStatus.COMPLETE.getCode());
        if (isError) {
            request.setStatus(ExeStatus.ANALYSIS_ERROR.getCode());
        }
        redisUtil.set(key, request);
    }

//    @Override
//    public void notifyProgress(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 + ":" + deptId;
//
//        Set<String> keys = redisUtil.keys(pattern);
//
//        if (null == keys || keys.isEmpty())
//            return;
//
//        OrderProgress orderProgress = new OrderProgress(companyId, deptId);
//
//        ExeRequest exeRequest;
//        for (String key : keys) {
//            exeRequest = (ExeRequest) redisUtil.get(key);
//            if (null == exeRequest)
//                continue;
//
//            orderProgress.setSumNum(orderProgress.getSumNum() + 1);
//
//            if (ExeStatus.COMPLETE.getCode().equals(exeRequest.getStatus())) {
//                orderProgress
//                        .setCompleteNum(orderProgress.getCompleteNum() + 1);
//            }
//            if (ExeStatus.SEND_ERROR.getCode().equals(exeRequest.getStatus())) {
//                orderProgress
//                        .setCompleteNum(orderProgress.getCompleteNum() + 1);
//                orderProgress.setErrorNum(orderProgress.getErrorNum() + 1);
//            }
//            if (ExeStatus.TIMEOUT_ERROR.getCode()
//                    .equals(exeRequest.getStatus())) {
//                orderProgress
//                        .setCompleteNum(orderProgress.getCompleteNum() + 1);
//                orderProgress.setErrorNum(orderProgress.getErrorNum() + 1);
//            }
//            if (ExeStatus.ANALYSIS_ERROR.getCode().equals(
//                    exeRequest.getStatus())) {
//                orderProgress
//                        .setCompleteNum(orderProgress.getCompleteNum() + 1);
//                orderProgress.setErrorNum(orderProgress.getErrorNum() + 1);
//            }
//
//            if (orderProgress.getCompleteNum() == orderProgress.getSumNum()) {
//                orderProgress.setProgress(ExeStatus.COMPLETE.getCode());
//            } else if (orderProgress.getCompleteNum() == 0) {
//                orderProgress.setProgress(ExeStatus.INIT.getCode());
//            } else {
//                orderProgress.setProgress(ExeStatus.IN_PROGRESS.getCode());
//            }
//        }
//
//        notifyWebInvoker.notifyWebOrderProgress(companyId, bizType,
//                orderProgress);
//    }

//    @Override
//    public void notifyProgress(BaseRequest request) {
//        if (StringUtils.isEmpty(request.getBizType()))
//            return;
//        if (StringUtils.isEmpty(request.getDeptId()))
//            return;
//
//		notifyProgress(request.getCompanyId(), request.getBizType(), request.getDeptId());
//    }

    // @Override
    // public void initProgress(String companyId, String bizType, String deptId,
    // String[] depotIds) {
    //
    // if (StringUtils.isEmpty(deptId)) deptId = "0000";
    // String key = companyId + "-" + bizType + "-" + deptId;
    //
    // OrderProgress orderProgress = OrderUtil.contextProgress.get(key);
    // if (null == orderProgress) {
    // orderProgress = new OrderProgress(companyId, deptId);
    // }
    // orderProgress.setSumNum(orderProgress.getSumNum() + depotIds.length);
    //
    // OrderUtil.contextProgress.put(key, orderProgress);
    //
    // notifyWebInvoker.notifyWebOrderProgress(companyId, bizType,
    // orderProgress);
    // }

    @Override
    public void progressError(String companyId, String bizType, String deptId, String msg) {

        if (StringUtils.isEmpty(deptId)) deptId = "0000";

        String key = companyId + "-" + bizType + "-" + deptId;

        OrderProgress orderProgress = OrderUtil.contextProgress.get(key);

        if (null == orderProgress) return;

        orderProgress.setCompleteNum(orderProgress.getCompleteNum() + 1);
        orderProgress.setErrorNum(orderProgress.getErrorNum() + 1);

        if (orderProgress.getCompleteNum() == orderProgress.getSumNum()) {
            orderProgress.setProgress(OrderUtil.PROGRESS_COMPLETE);
        } else {
            orderProgress.setProgress(OrderUtil.PROGRESS_PROGRESS);
        }

        //执行失败的不删除
        notifyWebInvoker.notifyWebOrderProgress(companyId, bizType,
                orderProgress);
    }

    // @Override
    // public void progressSuccess(String companyId, String bizType, String
    // deptId) {
    //
    // if (StringUtils.isEmpty(deptId)) deptId = "0000";
    //
    // String key = companyId + "-" + bizType + "-" + deptId;
    //
    // OrderProgress orderProgress = OrderUtil.contextProgress.get(key);
    //
    // if (null == orderProgress) return;
    //
    // orderProgress.setCompleteNum(orderProgress.getCompleteNum() + 1);
    //
    // if (orderProgress.getCompleteNum() == orderProgress.getSumNum()) {
    // orderProgress.setProgress(OrderUtil.PROGRESS_COMPLETE);
    // } else {
    // orderProgress.setProgress(OrderUtil.PROGRESS_PROGRESS);
    // }
    //
    // //执行失败的不删除
    // notifyWebInvoker.notifyWebOrderProgress(companyId, bizType,
    // orderProgress);
    // }

    @Override
    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 + ":" + deptId;

        Set<String> keys = redisUtil.keys(pattern);

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

        for (String key : keys) {
            redisUtil.del(key);
        }
    }

}