package com.zanxiang.sdk.task;

import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.zanxiang.common.enums.ExpireTimeEnum;
import com.zanxiang.common.enums.OrderStateEnum;
import com.zanxiang.common.utils.SpringUtils;
import com.zanxiang.mybatis.entity.Order;
import com.zanxiang.sdk.constant.RedisKeyConstant;
import com.zanxiang.sdk.domain.dto.PlatformOrderDTO;
import com.zanxiang.sdk.enums.PayTypeEnum;
import com.zanxiang.sdk.service.IOrderService;
import com.zanxiang.sdk.service.IPayApplicationService;
import com.zanxiang.sdk.service.pay.PayBaseService;
import com.zanxiang.sdk.util.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Objects;
import java.util.Set;

/**
 * @author : lingfeng
 * @time : 2023-01-17
 * @description : 订单过期定时器
 */
@Slf4j
@Component
@RefreshScope
public class OrderExpireTask {

    @Autowired
    private RedisUtil<String> redisUtil;

    @Autowired
    private IOrderService orderService;

    @Autowired
    private IPayApplicationService payApplicationService;

    /**
     * 订单过期每分钟检测
     */
    @Scheduled(cron = "0 0/1 * * * ?")
    public void orderExpireCheck() {
        double min = 0.0;
        double max = System.currentTimeMillis();
        //获取缓存订单
        Set<String> paramList = redisUtil.getZSetByScore(RedisKeyConstant.ORDER_EXPIRE, min, max);
        //不存在过期订单
        if (CollectionUtils.isEmpty(paramList)) {
            return;
        }
        //循环处理
        paramList.forEach(param -> {
            //缓存锁
            String lock = RedisKeyConstant.ORDER_EXPIRE_LOCK + param;
            //判断订单是否在执行, 设置执行锁 1 分钟
            boolean ifAbsent = redisUtil.setIfAbsent(lock, param, ExpireTimeEnum.ONE_MIN.getTime());
            if (!ifAbsent) {
                return;
            }
            //小程序商城的订单取消
            if (param.contains("_")) {
                payApplicationService.appletStoreCancel(param);
            } else {
                this.orderExpire(param);
            }
            //删除订单列表缓存
            redisUtil.delZSetValue(RedisKeyConstant.ORDER_EXPIRE, param);
            //删除执行缓存锁
            redisUtil.deleteCache(lock);
        });
    }

    private void orderExpire(String orderId) {
        //查询订单信息
        PlatformOrderDTO platformOrderDTO = orderService.getByOrderId(orderId);
        //订单不存在
        if (platformOrderDTO == null) {
            return;
        }
        //已支付订单或者已取消订单不处理
        if (Objects.equals(OrderStateEnum.SUCCESS_PAY.getCode(), platformOrderDTO.getStatus())
                || Objects.equals(OrderStateEnum.CANCEL_PAY.getCode(), platformOrderDTO.getStatus())) {
            return;
        }
        //关闭商户订单
        PayTypeEnum payTypeEnum = PayTypeEnum.getByPayType(platformOrderDTO.getPayWayId().intValue());
        PayBaseService service = SpringUtils.getBean(payTypeEnum.getClazz());
        service.closeOrder(platformOrderDTO);
        //订单状态变更
        orderService.update(new LambdaUpdateWrapper<Order>()
                .set(Order::getStatus, OrderStateEnum.CANCEL_PAY.getCode())
                .eq(Order::getOrderId, orderId));
    }
}