package com.ruoyi.cai.pay;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alipay.api.AlipayApiException;
import com.alipay.api.domain.AlipayTradeQueryModel;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ijpay.alipay.AliPayApi;
import com.ijpay.alipay.AliPayApiConfig;
import com.ijpay.alipay.AliPayApiConfigKit;
import com.ijpay.core.enums.SignType;
import com.ijpay.core.kit.WxPayKit;
import com.ijpay.wxpay.WxPayApi;
import com.ijpay.wxpay.model.OrderQueryModel;
import com.ruoyi.cai.domain.*;
import com.ruoyi.cai.dto.ConsumeResp;
import com.ruoyi.cai.dto.app.vo.pay.OrderPayStatusResp;
import com.ruoyi.cai.dto.commom.consumer.RechargeConsumerResp;
import com.ruoyi.cai.enums.SystemConfigEnum;
import com.ruoyi.cai.manager.AwardManager;
import com.ruoyi.cai.manager.ConsumerManager;
import com.ruoyi.cai.manager.SystemConfigManager;
import com.ruoyi.cai.pay.model.PayQueryModel;
import com.ruoyi.cai.service.*;
import com.ruoyi.cai.trdpay.TrdPayTypeEnum;
import com.ruoyi.common.exception.ServiceException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.util.List;
import java.util.Map;

@Component
@Slf4j
public class PayManager {

    @Autowired
    private VipOrderService vipOrderService;
    @Autowired
    private ConsumerManager consumerManager;
    @Autowired
    private RechargeOrderService rechargeOrderService;
    @Autowired
    private AwardManager awardManager;
    @Autowired
    private PayTotalService payTotalService;
    @Autowired
    private PayConfigService payConfigService;
    @Autowired
    private PayConfigManager payConfigManager;
    @Autowired
    private GoodsService goodsService;
    @Autowired
    private SystemConfigManager systemConfigManager;


    public String getNotifyDomain(String notifyUrl) {
        if(!StringUtils.isBlank(notifyUrl)){
            return notifyUrl;
        }else{
            String baseNotifyUrl = systemConfigManager.getSystemConfig(SystemConfigEnum.PAY_NOTIFY_URL);
            return baseNotifyUrl;
        }
    }

    public String getNotifyUrl(PayTrdConfig config, TrdPayTypeEnum type,boolean wx) {
        if(!StringUtils.isBlank(config.getNotifyUrl())){
            return type.getNotifyUrl(config.getNotifyUrl(),wx);
        }else{
            String notifyUrl = systemConfigManager.getSystemConfig(SystemConfigEnum.PAY_NOTIFY_URL);
            return type.getNotifyUrl(notifyUrl,wx);
        }
    }

    public PayQueryModel queryOrder(PayConfig payConfig,String orderNo,String appid) throws AlipayApiException {
        if(PayTypeEnum.ALI.getCode().equals(payConfig.getPayType())){
            boolean bool = payConfigManager.initAliPayConfig(payConfig);
            if(!bool){
                log.error("订单查询 初始化支付宝失败 payConfig={}",JSON.toJSONString(payConfig));
                return PayQueryModel.fail();
            }
            AlipayTradeQueryModel model = new AlipayTradeQueryModel();
            model.setOutTradeNo(orderNo);
            String body = AliPayApi.tradeQueryToResponse(model).getBody();
            log.info("订单查询 body={}",body);
            JSONObject jsonObject = JSON.parseObject(body);
            JSONObject response = jsonObject.getJSONObject("alipay_trade_query_response");
            String code = response.getString("code");
            String tradeStatus = response.getString("trade_status");
            if(!"10000".equals(code)){
                log.error("订单查询- 异常 resultBody={}",body);
                return PayQueryModel.fail();
            }
            if("TRADE_SUCCESS".equals(tradeStatus)){
                log.error("订单查询- 成功-已支付 resultBody={}",body);
                return PayQueryModel.ok(null,payConfig.getAppid(),PayTypeEnum.ALI);
            }
        }else if(PayTypeEnum.WX.getCode().equals(payConfig.getPayType())){
            Map<String, String> params = OrderQueryModel.builder()
                    .appid(appid)
                    .mch_id(payConfig.getWxMcid())
                    .out_trade_no(orderNo)
                    .nonce_str(WxPayKit.generateStr())
                    .build()
                    .createSign(payConfig.getWxKey(), SignType.MD5);
            String query = WxPayApi.orderQuery(params);
            Map<String, String> result = WxPayKit.xmlToMap(query);
            log.info("订单查询 query={}",query);
            String state = result.get("trade_state");
            String returnCode = result.get("return_code");
            String returnMsg = result.get("return_msg");
            String resultCode = result.get("result_code");
            if (!WxPayKit.codeIsOk(returnCode)) {
                log.error("订单查询- 异常 returnMsg={}",returnMsg);
                return PayQueryModel.fail();
            }
            if (!"SUCCESS".equals(resultCode)) {
                log.error("订单查询- 异常 query={}",query);
                return PayQueryModel.fail();
            }
            if("SUCCESS".equals(state)){
                log.error("订单查询- 成功-已支付 query={}",query);
                return PayQueryModel.ok(params, appid,PayTypeEnum.WX);
            }
        }
        return PayQueryModel.fail();
    }

    public PayQueryModel checkOrderPayStatus(String orderNo, String appid) {
        List<PayConfig> list = payConfigService.list(Wrappers.lambdaQuery(PayConfig.class).eq(PayConfig::getEnableStatus, 1));
        for (PayConfig payConfig : list) {
            try {
                PayQueryModel paySuccess = this.queryOrder(payConfig, orderNo, appid);
                if(paySuccess.isPayStatus()){
                    return paySuccess;
                }
            }catch (Exception e){
                log.error("订单查询 -异常",e);
            }
        }
        return PayQueryModel.fail();
    }

    public void queryAndUpdateCallbackPayStatus(String orderNo, String appId) {
        OrderTypeEnum orderTypeEnum = OrderNoUtil.getType(orderNo);
        if (orderTypeEnum == null) {
            log.error("订单查询 订单类型有误！orderNo={}", orderNo);
            throw new ServiceException("订单类型有误，请检查订单号");
        }
        switch (orderTypeEnum) {
            case VIP_ORDER_SUB:
                VipOrder vipOrder = vipOrderService.getByOrderNo(orderNo);
                if (vipOrder == null) {
                    throw new ServiceException("订单不存在，请检查订单状态");
                }
                if (!PayStatusEnum.READY_PAY.getCode().equals(vipOrder.getPayStatus())) {
                    throw new ServiceException("订单状态有误，请检查订单状态");
                }
                PayQueryModel vipPayStatus = checkOrderPayStatus(orderNo, appId);
                if(!vipPayStatus.isPayStatus()){
                    log.info("订单查询 VIP支付失败orderNo={}",orderNo);
                    break;
                }
                this.callBack(orderNo,null,vipPayStatus.getParams(),vipPayStatus.getAppId(),vipPayStatus.getPayTypeEnum());
            case RECHARGE_ORDER_SUB:
                RechargeOrder rechargeOrder = rechargeOrderService.getByOrderNo(orderNo);
                if (rechargeOrder == null) {
                    throw new ServiceException("订单查询 订单不存在，请重新下单支付");
                }
                if (!PayStatusEnum.READY_PAY.getCode().equals(rechargeOrder.getPayStatus())) {
                    throw new ServiceException("订单查询 订单状态有误，请重新下单支付");
                }
                PayQueryModel rechargePayStatus = checkOrderPayStatus(orderNo, appId);
                if(!rechargePayStatus.isPayStatus()){
                    log.info("订单查询 充值支付失败orderNo={}",orderNo);
                    break;
                }
                this.callBack(orderNo,null,rechargePayStatus.getParams(),rechargePayStatus.getAppId(),rechargePayStatus.getPayTypeEnum());
            default:
                break;
        }
    }

    public PayOrderInfoDTO getOrderInfo(String orderNo,boolean wx){
        OrderTypeEnum orderTypeEnum = OrderNoUtil.getType(orderNo);
        if(orderTypeEnum == null){
            log.error("订单类型有误！orderNo={}",orderNo);
            throw new ServiceException("支付失败，请检查订单号");
        }
        PayOrderInfoDTO dto = null;
        switch (orderTypeEnum) {
            case VIP_ORDER_SUB:
                VipOrder vipOrder = vipOrderService.getByOrderNo(orderNo);
                if(vipOrder == null){
                    throw new ServiceException("订单不存在，请重新下单支付");
                }
                if(!PayStatusEnum.READY_PAY.getCode().equals(vipOrder.getPayStatus())){
                    throw new ServiceException("订单状态有误，请重新下单支付");
                }
                dto = new PayOrderInfoDTO();
                dto.setBody(vipOrder.getVipName());
                dto.setSubject(vipOrder.getVipName());
                dto.setPrice(vipOrder.getPrice());
                dto.setOrderNo(vipOrder.getOrderNo());
                dto.setAppid(vipOrder.getAppid());
                dto.setPlatformType(vipOrder.getPlatformType());
                dto.setSubjectId(vipOrder.getVipId()+"");
                break;
            case RECHARGE_ORDER_SUB:
                RechargeOrder rechargeOrder = rechargeOrderService.getByOrderNo(orderNo);
                if(rechargeOrder == null){
                    throw new ServiceException("订单不存在，请重新下单支付");
                }
                if(!PayStatusEnum.READY_PAY.getCode().equals(rechargeOrder.getPayStatus())){
                    throw new ServiceException("订单状态有误，请重新下单支付");
                }
                if(wx){
                    if(rechargeOrder.getRechargeId() != null){
                        Goods goods = goodsService.getById(rechargeOrder.getRechargeId());
                        if(goods != null){
                            rechargeOrderService.update(Wrappers.lambdaUpdate(RechargeOrder.class)
                                    .eq(RechargeOrder::getId, rechargeOrder.getId())
                                    .set(RechargeOrder::getRechargeCoin, goods.getWxAmount()));
                        }
                    }
                }
                dto = new PayOrderInfoDTO();
                dto.setBody(rechargeOrder.getRechargeName());
                dto.setSubject(rechargeOrder.getRechargeName());
                dto.setPrice(rechargeOrder.getPrice());
                dto.setOrderNo(rechargeOrder.getOrderNo());
                dto.setAppid(rechargeOrder.getAppid());
                dto.setPlatformType(rechargeOrder.getPlatformType());
                dto.setSubjectId(rechargeOrder.getRechargeId()+"");
                break;
            default:
                break;
        }
        return dto;
    }

    public void callBack(String orderNo){
        callBack(orderNo,null,null,null,null);
    }

    public void callBack(String orderNo, String transId, Map<String,String> params, String appId,PayTypeEnum payTypeEnum){
        OrderTypeEnum orderTypeEnum = OrderNoUtil.getType(orderNo);
        if(orderTypeEnum == null){
            log.error("订单类型有误！orderNo={}",orderNo);
            return;
        }
        switch (orderTypeEnum){
            case VIP_ORDER_SUB:
                ConsumeResp vipResp = vipOrderService.orderSuccess(orderNo,params,appId,payTypeEnum);
                if(vipResp.isSuccess()){
                    if(appId != null){
                        payTotalService.incsPrice(payTypeEnum,appId,vipResp.getPrice());
                    }
                }
                break;
            case RECHARGE_ORDER_SUB:
                RechargeConsumerResp resp = consumerManager.rechargeOrderSuccess(orderNo,params,appId,payTypeEnum);
                if(resp.isSuccess()){
                    // 领取首充奖励
                    awardManager.giveFastPayAsync(resp);
                    if(appId != null){
                        payTotalService.incsPrice(payTypeEnum,appId,resp.getPrice());
                    }
                }
                break;
            default:
                break;
        }
    }

    public OrderPayStatusResp getOrderPayStatus(String orderNo) {
        OrderTypeEnum orderTypeEnum = OrderNoUtil.getType(orderNo);
        if(orderTypeEnum == null){
            log.error("订单类型有误！orderNo={}",orderNo);
            return null;
        }
        OrderPayStatusResp resp = null;
        switch (orderTypeEnum) {
            case VIP_ORDER_SUB:
                VipOrder vipOrder = vipOrderService.getByOrderNo(orderNo);
                if(vipOrder != null){
                    resp = new OrderPayStatusResp();
                    resp.setOrderNo(vipOrder.getOrderNo());
                    resp.setAmount(vipOrder.getPrice());
                    resp.setPayStatus(vipOrder.getPayStatus());
                }
                break;
            case RECHARGE_ORDER_SUB:
                RechargeOrder rechargeOrder = rechargeOrderService.getByOrderNo(orderNo);
                if(rechargeOrder != null){
                    resp = new OrderPayStatusResp();
                    resp.setOrderNo(rechargeOrder.getOrderNo());
                    resp.setAmount(rechargeOrder.getPrice());
                    resp.setPayStatus(rechargeOrder.getPayStatus());
                }
                break;
            default:
                break;
        }
        return resp;
    }

    public void updatePayType(String orderNo, String type,PlatformTypeEnum typeEnum) {
        OrderTypeEnum orderTypeEnum = OrderNoUtil.getType(orderNo);
        if(orderTypeEnum == null){
            log.error("订单类型有误！orderNo={}",orderNo);
            return;
        }
        switch (orderTypeEnum) {
            case VIP_ORDER_SUB:
                vipOrderService.update(Wrappers.lambdaUpdate(VipOrder.class)
                        .eq(VipOrder::getOrderNo, orderNo)
                        .set(VipOrder::getPlatformType, typeEnum == null ? null : typeEnum.getCode())
                        .set(VipOrder::getAppid, type));
                break;
            case RECHARGE_ORDER_SUB:
                rechargeOrderService.update(Wrappers.lambdaUpdate(RechargeOrder.class)
                        .eq(RechargeOrder::getOrderNo, orderNo)
                        .set(RechargeOrder::getPlatformType, typeEnum == null ? null : typeEnum.getCode())
                        .set(RechargeOrder::getAppid, type));
                break;
            default:
                break;
        }
    }
}