package com.iplatform.pay;

import com.iplatform.base.WechatConstants;
import com.iplatform.model.po.S_pay_definition;
import com.iplatform.model.po.S_pay_order;
import com.iplatform.pay.config.PayProperties;
import com.iplatform.pay.service.PayDefinitionServiceImpl;
import com.iplatform.pay.service.PlatformOrderServiceImpl;
import com.iplatform.pay.support.AllinpayCloudOrderCallback;
import com.iplatform.pay.support.DefaultWechatV2OrderCallback;
import com.iplatform.pay.support.PayUnkPlatformOrderCallback;
import com.iplatform.pay.util.PayDefinitionUtils;
import com.walker.infrastructure.arguments.ArgumentsManager;
import com.walker.infrastructure.arguments.Variable;
import com.walker.infrastructure.utils.ClassUtils;
import com.walker.infrastructure.utils.StringUtils;
import com.walker.pay.AbstractPayEngineManager;
import com.walker.pay.AbstractPayEngineProvider;
import com.walker.pay.Order;
import com.walker.pay.PayDefinition;
import com.walker.pay.PayEngineNotFoundException;
import com.walker.pay.PayEngineProvider;
import com.walker.pay.PayStatus;
import com.walker.pay.PayType;
import com.walker.pay.ServiceProvider;
import com.walker.pay.support.DefaultOrder;
import com.walker.pay.support.DefaultPayDefinition;
import org.springframework.web.client.RestTemplate;

import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 支付平台默认'支付引擎'管理器实现。<p></p>
 * 它负责管理多种支付实现提供者的对接与维护，所有通用支付操作都要从该管理器为入口。
 * @author 时克英
 * @date 2023-02-25
 */
public class DefaultEngineManager extends AbstractPayEngineManager {

    @Override
    protected List<PayDefinition> acquirePayDefinitionList() {
        // 暂时把加载【支付配置】相关参数，加载时机放在这里。2023-02-25
        logger.warn("================== 加载支付配置信息，这里暂时只有测试用的'通商云'");
//        this.setConfiguration(MockUtils.getTestConfiguration());
        this.setConfiguration(this.doAcquireConfiguration());

        logger.warn("================== 从数据库加载支付定义列表，这里暂时只有测试用的'通商云'");
//        return MockUtils.getTestPayDefinitionList(this.getConfiguration());
        return this.doAcquireDefinitionList();
    }

    @Override
    protected PayEngineProvider acquirePayEngineProvider(PayDefinition payDefinition) throws PayEngineNotFoundException {
        boolean exist = ClassUtils.isPresent(payDefinition.getPayEngineProviderClass(), this.getClass().getClassLoader());
        if(!exist){
            throw new PayEngineNotFoundException(payDefinition.getId(), "PayEngineProviderClass不存在:" + payDefinition.getPayEngineProviderClass(), null);
        }
        try {
            logger.info("PayEngineProviderClass = " + payDefinition.getPayEngineProviderClass());
            Class<?> payEngineProviderClass = ClassUtils.forName(payDefinition.getPayEngineProviderClass(), this.getClass().getClassLoader());
            Constructor<AbstractPayEngineProvider> constructor = (Constructor<AbstractPayEngineProvider>)payEngineProviderClass.getConstructor(RestTemplate.class);

            AbstractPayEngineProvider payEngineProvider = constructor.newInstance(this.restTemplate);
            payEngineProvider.setConfiguration(this.getConfiguration());
            payEngineProvider.setPayDefinition(payDefinition);
            // 设置通知数据转换器，暂时还没有实现。
            payEngineProvider.setOrderNotifyConvertor(payDefinition.getOrderNotifyConvertor());
            // 设置定义的订单回调业务实现。
            payEngineProvider.setOrderCallback(payDefinition.getOrderCallback());
            return payEngineProvider;

        } catch (Exception ex){
            throw new PayEngineNotFoundException(payDefinition.getId(), "创建'PayEngineProvider'失败:" + ex.getMessage(), ex);
        }
    }

    @Override
    protected Order acquireOrder(String orderId) {
        // 从数据库加载订单信息，目前主要用于查询订单状态时，获取支付定义ID
        long id = Long.parseLong(orderId);
        S_pay_order platformOrder = this.platformOrderService.get(new S_pay_order(id));
        DefaultOrder order = new DefaultOrder();
        order.setId(id);
        order.setBuyerId(platformOrder.getBuyer_id());
        order.setVersion(platformOrder.getVersion());
        order.setTitle(platformOrder.getTitle());
        order.setAttach(platformOrder.getAttach());
        order.setNonce(platformOrder.getNonce());
        order.setReceiverId(platformOrder.getReceiver_id());
        order.setPayDefinitionId(platformOrder.getPay_definition_id());
        order.setServiceProvider(ServiceProvider.getType(platformOrder.getService_provider()));
//        order.setNotifyUrl(platformOrder.getn);
        order.setTotalMoney(platformOrder.getTotal_money());
        order.setPayType(PayType.getType(platformOrder.getPay_type()));
        order.setIp(platformOrder.getIp());
        order.setCreateTime(platformOrder.getCreate_time());
        order.setDeviceInfo(platformOrder.getDevice_info());
        order.setFee(platformOrder.getFee());
        order.setPayStatus(PayStatus.getType(platformOrder.getPay_status()));
        order.setTradeNo(platformOrder.getTrade_no());
        return order;
    }

    private List<PayDefinition> doAcquireDefinitionList(){
        List<S_pay_definition> payDefinitionDatabase = this.payDefinitionService.queryAvailablePayDefinitionList();
        if(StringUtils.isEmptyList(payDefinitionDatabase)){
            return null;
        }
        List<PayDefinition> resultList = new ArrayList<>(8);
        DefaultPayDefinition payDefinition = null;

        for(S_pay_definition s_pay_definition : payDefinitionDatabase){
            payDefinition = PayDefinitionUtils.toPayDefinition(s_pay_definition, this.getConfiguration());

            // 因为每个第三方支付模块不一定会配置，这里要检测类是否存在，如果没有加载模块则日志提示
            boolean exist = ClassUtils.isPresent(payDefinition.getPayEngineProviderClass(), this.getClass().getClassLoader());
            if(!exist){
                logger.warn("支付定义不存在，可能是未引入模块，providerClass: {}", payDefinition.getPayEngineProviderClass());
                continue;
            }
            if(StringUtils.isEmpty(payDefinition.getOrderNotifyConvertorClass())){
                logger.warn("支付定义未设置'OrderNotifyConvertor'类定义，可能会出现支付通知问题，请关注模块实现是否完整! id={}", payDefinition.getId());
            } else {
                payDefinition.setOrderNotifyConvertor(PayDefinitionUtils.createNotifyConvertorInstance(payDefinition.getOrderNotifyConvertorClass(), this.getClass().getClassLoader()));
            }

            // 这里设置支付定义中的：格式转换器和回调等。2023-02-28
            if(payDefinition.getId().equals(Constants.PAY_DEFINITION_ID_ALLINPAY_CLOUD)){
                AllinpayCloudOrderCallback orderCallback = new AllinpayCloudOrderCallback();
                orderCallback.setOrderService(this.platformOrderService);
                payDefinition.setOrderCallback(orderCallback);
//                payDefinition.setOrderNotifyConvertor(new NotifyOrderConvertor());

            } else if(payDefinition.getId().equals(Constants.PAY_DEFINITION_ID_WECHAT_V2)){
//                DefaultWechatV2OrderCallback orderCallback = new DefaultWechatV2OrderCallback();
                DefaultWechatV2OrderCallback orderCallback = PayDefinitionUtils
                        .acquireWechatV2CallbackInstance(this.payProperties.getWechatTwoOrderCallback(), this.getClass().getClassLoader());
                orderCallback.setOrderService(this.platformOrderService);
                payDefinition.setOrderCallback(orderCallback);

            } else if(payDefinition.getId().equals(Constants.PAY_DEFINITION_ID_PAYUNK)){
                // 2023-10-30 畅联支付相关
                PayUnkPlatformOrderCallback orderCallback = new PayUnkPlatformOrderCallback();
                orderCallback.setOrderService(this.platformOrderService);
                payDefinition.setOrderCallback(orderCallback);

            } else {
                throw new UnsupportedOperationException("代码未实现!");
            }
            resultList.add(payDefinition);
        }
        return resultList;
    }

    private Map<String, Variable> doAcquireConfiguration(){
        Map<String, Variable> configuration = new HashMap<>();
//        configuration.put(com.walker.pay.allinpaycloud.Constants.CONFIG_KEY_URL, this.argumentsManager.getVariable(com.walker.pay.allinpaycloud.Constants.CONFIG_KEY_URL));
//        configuration.put(com.walker.pay.allinpaycloud.Constants.CONFIG_KEY_APP_ID, this.argumentsManager.getVariable(com.walker.pay.allinpaycloud.Constants.CONFIG_KEY_APP_ID));
//        configuration.put(com.walker.pay.allinpaycloud.Constants.CONFIG_KEY_SECRET_KEY, this.argumentsManager.getVariable(com.walker.pay.allinpaycloud.Constants.CONFIG_KEY_SECRET_KEY));
//        configuration.put(com.walker.pay.allinpaycloud.Constants.CONFIG_KEY_PRIVATE_KEY_PATH, this.argumentsManager.getVariable(com.walker.pay.allinpaycloud.Constants.CONFIG_KEY_PRIVATE_KEY_PATH));
//        configuration.put(com.walker.pay.allinpaycloud.Constants.CONFIG_KEY_PWD, this.argumentsManager.getVariable(com.walker.pay.allinpaycloud.Constants.CONFIG_KEY_PWD));
//        configuration.put(com.walker.pay.allinpaycloud.Constants.CONFIG_KEY_PUBLIC_KEY, this.argumentsManager.getVariable(com.walker.pay.allinpaycloud.Constants.CONFIG_KEY_PUBLIC_KEY));
        List<Variable> payVariableList = this.argumentsManager.getVariableList(String.valueOf(Constants.VARIABLE_FORM_PAY));
        for(Variable v : payVariableList){
            configuration.put(v.getId(), v);
        }

        // 2023-09-15，微信小程序相关配置
        Variable miniAppId = this.argumentsManager.getVariable(WechatConstants.WECHAT_MINI_APPID);
        Variable miniPaySecret = this.argumentsManager.getVariable(WechatConstants.WECHAT_PAY_MINI_KEY);
        Variable miniMchId = this.argumentsManager.getVariable(WechatConstants.WECHAT_PAY_MINI_MCHID);
        configuration.put(miniAppId.getId(), miniAppId);
        configuration.put(miniPaySecret.getId(), miniPaySecret);
        configuration.put(miniMchId.getId(), miniMchId);

        return configuration;
    }

    public void setArgumentsManager(ArgumentsManager argumentsManager) {
        this.argumentsManager = argumentsManager;
    }

    public void setPayDefinitionService(PayDefinitionServiceImpl payDefinitionService) {
        this.payDefinitionService = payDefinitionService;
    }

    public void setRestTemplate(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public void setPayProperties(PayProperties payProperties) {
        this.payProperties = payProperties;
    }

    public void setPlatformOrderService(PlatformOrderServiceImpl platformOrderService) {
        this.platformOrderService = platformOrderService;
    }
    private PayProperties payProperties;

    private RestTemplate restTemplate;

    private PlatformOrderServiceImpl platformOrderService;
    private PayDefinitionServiceImpl payDefinitionService = null;
    private ArgumentsManager argumentsManager = null;
}