package com.walker.pay;

import com.walker.infrastructure.arguments.Variable;
import com.walker.infrastructure.utils.StringUtils;
import com.walker.pay.exception.NotifyException;
import com.walker.pay.exception.OrderException;
import com.walker.pay.response.OrderStatusResponsePay;
import com.walker.pay.util.PayDefinitionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public abstract class AbstractPayEngineManager implements PayEngineManager{

    protected final transient Logger logger = LoggerFactory.getLogger(this.getClass());

    private final Map<String, PayDefinition> payDefinitionMap = new HashMap<>();

    private final Map<String, PayEngineProvider> payEngineProviderMap = new HashMap<>();

    private Map<String, Variable> configuration = null;

    public Map<String, Variable> getConfiguration() {
        return configuration;
    }

    public void setConfiguration(Map<String, Variable> configuration){
        if(configuration == null || configuration.size() == 0){
            logger.warn("支付引擎配置参数为空，请确认是否不需要参数。");
        }
        this.configuration = configuration;
        logger.info("setConfiguration:{}", this.configuration);
    }

    @Override
    public void loadPayDefinitionList() {
        List<PayDefinition> list = this.acquirePayDefinitionList();
        if(StringUtils.isEmptyList(list)){
            logger.warn("未加载到任何'支付定义'集合, 无法使用支付功能!");
            return;
        }
        PayEngineProvider payEngineProvider = null;
        for(PayDefinition pd : list){
            try {
                if(!pd.getEnabled()){
                    logger.warn("支付定义被禁用，无法使用:" + pd.getName());
                    continue;
                }
                payEngineProvider = this.acquirePayEngineProvider(pd);
                if(payEngineProvider == null){
                    logger.error("acquirePayEngineProvider()得到空的引擎对象!");
                    continue;
                }
                this.payEngineProviderMap.put(pd.getId(), payEngineProvider);
                this.payDefinitionMap.put(pd.getId(), pd);
                logger.info("加载了一个'PayEngineProvider': " + pd.getName() + ", id=" + pd.getId());

            } catch (PayEngineNotFoundException e) {
                logger.error("获取支付引擎错误，未找到需要的对象: " + pd.getId());
                throw new RuntimeException(e);
            }
        }
    }

    @Override
    public PayDefinition getPayDefinition(String payDefinitionId) {
        PayDefinition pd = this.payDefinitionMap.get(payDefinitionId);
        if(pd == null){
            logger.warn("未找到支付定义对象, id=" + payDefinitionId);
        }
        return pd;
    }

    @Override
    public List<PayEngineProvider> getPayEngineProviderList() {
        if(this.payEngineProviderMap.size() == 0){
            return null;
        }
        List<PayEngineProvider> resultList = new ArrayList<>(8);
        for(PayEngineProvider payEngineProvider : this.payEngineProviderMap.values()){
            resultList.add(payEngineProvider);
        }
        return resultList;
    }

    @Override
    public PayEngineProvider getPayEngineProvider(String payDefinitionId) {
        PayEngineProvider payEngineProvider = this.payEngineProviderMap.get(payDefinitionId);
        if(payEngineProvider == null){
            logger.warn("未找到支付引擎对象, id=" + payDefinitionId);
        }
        return payEngineProvider;
    }

    @Override
    public PayEngineProvider getPayEngineProvider(ServiceProvider serviceProvider, String version, PayType payType) {
        String payDefinitionId = PayDefinitionUtils.getPayDefinitionId(serviceProvider, version);
        PayEngineProvider payEngineProvider = this.payEngineProviderMap.get(payDefinitionId);
        if(payEngineProvider == null){
            logger.warn("未找到支付引擎对象, id=" + payDefinitionId + ", provider=" + serviceProvider.getName() + ", version=" + version);
        }
        return payEngineProvider;
    }

    @Override
    public List<PayEngineProvider> getPayEngineProviderList(ServiceProvider serviceProvider){
        if(serviceProvider == null){
            throw new IllegalArgumentException("serviceProvider 参数必须提供");
        }
        if(this.payEngineProviderMap.size() == 0){
            return null;
        }
        List<PayEngineProvider> resultList = new ArrayList<>(2);
        for(PayEngineProvider payEngineProvider : this.payEngineProviderMap.values()){
            if(payEngineProvider.getServiceProvider() == serviceProvider){
                resultList.add(payEngineProvider);
            }
        }
        return resultList;
    }

    @Override
    public ResponsePay generatePrepareOrder(Order platformOrder) throws OrderException {
        if(platformOrder == null){
            throw new IllegalArgumentException("platformOrder is required!");
        }

        if(platformOrder.getServiceProvider() == null){
            throw new IllegalArgumentException("提供商不能为空: serviceProvider is required!");
        }
        if(platformOrder.getPayType() == null){
            throw new IllegalArgumentException("支付类型不能为空: payType is required!");
        }

        PayEngineProvider payEngineProvider = null;

        if(StringUtils.isEmpty(platformOrder.getVersion())){
            logger.warn("订单未传入'version'属性, 需要根据'ServiceProvider'查询是否存在多个提供者:" + platformOrder.getServiceProvider());
            List<PayEngineProvider> payEngineProviders = this.getPayEngineProviderList(platformOrder.getServiceProvider());
            if(StringUtils.isEmptyList(payEngineProviders)){
                logger.error("根据'serviceProvider'没有找到任何支付引擎提供者:" + platformOrder.getServiceProvider());
            } else if(payEngineProviders.size() == 1){
                if(logger.isDebugEnabled()){
                    logger.debug("该'serviceProvider'下只存在一个提供者:" + platformOrder.getServiceProvider());
                }
                payEngineProvider = payEngineProviders.get(0);
            } else {
                throw new IllegalArgumentException("订单没有提供版本号，而且该提供者存在多个，请传入版本号，serviceProvider=" + platformOrder.getServiceProvider());
            }
        } else {
            payEngineProvider = this.getPayEngineProvider(platformOrder.getServiceProvider()
                    , platformOrder.getVersion(), platformOrder.getPayType());
        }
        if(payEngineProvider == null){
            throw new IllegalArgumentException("PayEngineProvider not found:" + platformOrder.getServiceProvider() + ", " + platformOrder.getVersion());
        }
        return payEngineProvider.generatePrepareOrder(platformOrder);
    }

    @Override
    public String notifyOrder(String payDefinitionId, Object notifyData) throws NotifyException{
        if(StringUtils.isEmpty(payDefinitionId)){
//            throw new NotifyException("", "payDefinitionId 为空!", null);
            return "payDefinitionId 为空!";
        }

        PayEngineProvider payEngineProvider = this.getPayEngineProvider(payDefinitionId);
        if(payEngineProvider == null){
//            throw new IllegalArgumentException("未找到支付引擎，payDefinition:" + payDefinitionId);
            return "未找到支付引擎，payDefinition:" + payDefinitionId;
        }

//        payEngineProvider.notifyOrder(notifyData, orderCallBack);
        payEngineProvider.notifyOrder(notifyData);

        // 成功返回空对象。
        return null;
    }

    @Override
    public String generateNotifyResponse(String payDefinitionId, boolean success){
        if(StringUtils.isEmpty(payDefinitionId)){
            throw new IllegalArgumentException("payDefinitionId is acquired!");
        }
        PayEngineProvider payEngineProvider = this.getPayEngineProvider(payDefinitionId);
        if(payEngineProvider == null){
            throw new IllegalArgumentException("未找到支付引擎，payDefinition:" + payDefinitionId);
        }
        return payEngineProvider.generateNotifyResponse(success);
    }

    @Override
    public OrderStatusResponsePay searchOrderStatus(String orderId){
        if(StringUtils.isEmpty(orderId)){
            throw new IllegalArgumentException("请输入订单编号");
        }
        Order order = this.acquireOrder(orderId);
        if(order == null){
            logger.error("系统订单不存在，orderId={}", orderId);
            return null;
        }
        String payDefinitionId = order.getPayDefinitionId();
        if(StringUtils.isEmpty(payDefinitionId)){
            throw new IllegalStateException("该订单未关联任何支付引擎，无法继续查询订单状态: payDefinitionId 为空，orderId=" + orderId);
        }
        PayEngineProvider payEngineProvider = this.getPayEngineProvider(payDefinitionId);
        if(payEngineProvider == null){
            throw new IllegalArgumentException("未找到支付引擎，payDefinition:" + payDefinitionId);
        }
        return payEngineProvider.searchOrderStatus(order);
    }

    /**
     * 由子类实现加载支付定义数据。
     * @return
     */
    protected abstract List<PayDefinition> acquirePayDefinitionList();

    /**
     * 根据支付定义，获取支付引擎提供者对象。
     * @param payDefinition
     * @return
     */
    protected abstract PayEngineProvider acquirePayEngineProvider(PayDefinition payDefinition) throws PayEngineNotFoundException;

    /**
     * 从平台查询数据库，找出订单基本信息。
     * @param orderId 平台订单ID，数字
     * @return
     * @date 2023-02-23
     */
    protected abstract Order acquireOrder(String orderId);
}