package com.ycwl.basic.pricing.service.impl;

import com.ycwl.basic.pricing.dto.DiscountDetectionContext;
import com.ycwl.basic.pricing.dto.DiscountInfo;
import com.ycwl.basic.pricing.dto.DiscountResult;
import com.ycwl.basic.pricing.dto.OnePriceInfo;
import com.ycwl.basic.pricing.dto.ProductItem;
import com.ycwl.basic.pricing.entity.PriceProductConfig;
import com.ycwl.basic.pricing.service.IDiscountProvider;
import com.ycwl.basic.pricing.service.IOnePricePurchaseService;
import com.ycwl.basic.pricing.service.IProductConfigService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * 一口价购买优惠提供者
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class OnePricePurchaseDiscountProvider implements IDiscountProvider {

    private final IOnePricePurchaseService onePricePurchaseService;
    private final IProductConfigService productConfigService;
    
    @Override
    public String getProviderType() {
        return "ONE_PRICE_PURCHASE";
    }
    
    @Override
    public int getPriority() {
        return 120; // 最高优先级，一口价优先应用
    }
    
    @Override
    public List<DiscountInfo> detectAvailableDiscounts(DiscountDetectionContext context) {
        List<DiscountInfo> discounts = new ArrayList<>();
        
        try {
            if (context.getScenicId() == null || context.getCurrentAmount() == null) {
                log.debug("一口价检测失败: 景区ID或当前金额为空");
                return discounts;
            }
            
            // 检查是否适用一口价
            if (!onePricePurchaseService.isOnePriceApplicable(context.getScenicId())) {
                log.debug("景区 {} 不适用一口价", context.getScenicId());
                return discounts;
            }

            // 检查商品是否支持一口价优惠（使用景区维度配置）
            if (!areAllProductsSupportOnePrice(context.getProducts(), context.getScenicId())) {
                log.debug("存在不支持一口价优惠的商品，跳过一口价检测");
                return discounts;
            }
            
            // 获取一口价信息
            OnePriceInfo onePriceInfo = onePricePurchaseService.getOnePriceInfo(
                    context.getScenicId(), context.getCurrentAmount());
            
            if (onePriceInfo == null) {
                log.debug("景区 {} 未找到一口价配置", context.getScenicId());
                return discounts;
            }
            
            // 只有当一口价小于当前金额时才算优惠
            if (onePriceInfo.getOnePrice().compareTo(context.getCurrentAmount()) >= 0) {
                log.debug("景区 {} 一口价 {} 不小于当前金额 {}", 
                        context.getScenicId(), onePriceInfo.getOnePrice(), context.getCurrentAmount());
                return discounts;
            }
            
            // 创建优惠信息
            DiscountInfo discountInfo = new DiscountInfo();
            discountInfo.setProviderType(getProviderType());
            discountInfo.setDiscountName("一口价购买优惠");
            discountInfo.setDiscountAmount(onePriceInfo.getActualDiscountAmount());
            discountInfo.setDiscountDescription("景区一口价购买，价格更优惠");
            discountInfo.setOnePriceInfo(onePriceInfo);
            discountInfo.setPriority(getPriority());
            
            discounts.add(discountInfo);
            
            log.info("检测到一口价优惠: 景区={}, 一口价={}, 优惠金额={}", 
                    context.getScenicId(), onePriceInfo.getOnePrice(), 
                    onePriceInfo.getActualDiscountAmount());
            
        } catch (Exception e) {
            log.error("一口价优惠检测失败", e);
        }
        
        return discounts;
    }
    
    @Override
    public DiscountResult applyDiscount(DiscountInfo discountInfo, DiscountDetectionContext context) {
        DiscountResult result = new DiscountResult();
        result.setDiscountInfo(discountInfo);
        result.setSuccess(false);
        
        try {
            if (!getProviderType().equals(discountInfo.getProviderType())) {
                result.setFailureReason("优惠类型不匹配");
                return result;
            }
            
            OnePriceInfo onePriceInfo = discountInfo.getOnePriceInfo();
            if (onePriceInfo == null) {
                result.setFailureReason("一口价信息为空");
                return result;
            }
            
            // 检查优惠的叠加限制
            boolean canUseWithOtherDiscounts = checkDiscountCombinationRules(onePriceInfo, context);
            if (!canUseWithOtherDiscounts) {
                result.setFailureReason("一口价不可与其他优惠叠加使用");
                return result;
            }
            
            // 应用一口价优惠
            BigDecimal discountAmount = onePriceInfo.getActualDiscountAmount();
            BigDecimal finalAmount = context.getCurrentAmount().subtract(discountAmount);
            
            // 如果使用一口价，则最终金额就是一口价金额
            finalAmount = onePriceInfo.getOnePrice();
            discountAmount = context.getCurrentAmount().subtract(finalAmount);
            
            result.setSuccess(true);
            result.setActualDiscountAmount(discountAmount);
            result.setFinalAmount(finalAmount);
            result.setFailureReason("一口价购买优惠已应用");
            
            log.info("一口价优惠应用成功: 优惠金额={}, 最终金额={}", discountAmount, finalAmount);
            
        } catch (Exception e) {
            log.error("一口价优惠应用失败", e);
            result.setFailureReason("一口价优惠应用失败: " + e.getMessage());
        }
        
        return result;
    }
    
    @Override
    public boolean canApply(DiscountInfo discountInfo, DiscountDetectionContext context) {
        try {
            if (!getProviderType().equals(discountInfo.getProviderType())) {
                return false;
            }
            
            OnePriceInfo onePriceInfo = discountInfo.getOnePriceInfo();
            if (onePriceInfo == null) {
                return false;
            }
            
            // 检查一口价是否仍然有效（时间范围等）
            return onePricePurchaseService.isOnePriceApplicable(context.getScenicId());
            
        } catch (Exception e) {
            log.error("检查一口价可用性失败", e);
            return false;
        }
    }
    
    @Override
    public BigDecimal getMaxPossibleDiscount(DiscountInfo discountInfo, DiscountDetectionContext context) {
        try {
            OnePriceInfo onePriceInfo = discountInfo.getOnePriceInfo();
            if (onePriceInfo != null && onePriceInfo.getActualDiscountAmount() != null) {
                return onePriceInfo.getActualDiscountAmount();
            }
        } catch (Exception e) {
            log.error("获取一口价最大优惠金额失败", e);
        }
        
        return BigDecimal.ZERO;
    }
    
    /**
     * 检查购物车中的所有商品是否都支持一口价优惠（使用景区维度配置）
     */
    private boolean areAllProductsSupportOnePrice(List<ProductItem> products, Long scenicId) {
        if (products == null || products.isEmpty()) {
            return true; // 空购物车时默认支持
        }

        for (ProductItem product : products) {
            try {
                // 查询商品配置（使用景区维度）
                PriceProductConfig productConfig = productConfigService.getProductConfig(
                        product.getProductType().getCode(), product.getProductId(), scenicId);

                if (productConfig != null) {
                    // 检查商品是否支持一口价优惠
                    if (Boolean.FALSE.equals(productConfig.getCanUseOnePrice())) {
                        log.debug("商品 {}({}) 在景区 {} 不支持一口价优惠",
                                product.getProductType().getCode(), product.getProductId(), scenicId);
                        return false;
                    }
                } else {
                    // 如果找不到具体商品配置，尝试查询 default 配置
                    PriceProductConfig defaultConfig = productConfigService.getProductConfig(
                            product.getProductType().getCode(), "default", scenicId);

                    if (defaultConfig != null) {
                        if (Boolean.FALSE.equals(defaultConfig.getCanUseOnePrice())) {
                            log.debug("商品类型 {} 在景区 {} 的默认配置不支持一口价优惠",
                                    product.getProductType().getCode(), scenicId);
                            return false;
                        }
                    } else {
                        // 如果既没有具体配置也没有默认配置，默认支持（保持向后兼容）
                        log.debug("商品 {}({}) 在景区 {} 未找到价格配置，默认支持一口价优惠",
                                product.getProductType().getCode(), product.getProductId(), scenicId);
                        // 改为默认支持，避免配置缺失导致一口价功能不可用
                    }
                }
            } catch (Exception e) {
                log.warn("检查商品 {}({}) 在景区 {} 一口价优惠支持情况时发生异常，默认支持",
                        product.getProductType().getCode(), product.getProductId(), scenicId, e);
                // 异常情况下默认支持，确保业务流程不受影响
            }
        }

        return true;
    }

    /**
     * 检查优惠叠加规则
     */
    private boolean checkDiscountCombinationRules(OnePriceInfo onePriceInfo, DiscountDetectionContext context) {
        // 根据配置检查是否可以与优惠券、券码叠加使用
        // 这里可以根据业务需求实现具体的叠加规则
        
        // 如果配置了不可与优惠券叠加，且请求中要使用优惠券，则返回false
        if (Boolean.FALSE.equals(onePriceInfo.getCanUseCoupon()) && 
            Boolean.TRUE.equals(context.getAutoUseCoupon())) {
            log.debug("一口价配置不允许与优惠券叠加使用");
            return false;
        }
        
        // 如果配置了不可与券码叠加，且请求中要使用券码，则返回false
        if (Boolean.FALSE.equals(onePriceInfo.getCanUseVoucher()) && 
            (Boolean.TRUE.equals(context.getAutoUseVoucher()) || 
             context.getVoucherCode() != null)) {
            log.debug("一口价配置不允许与券码叠加使用");
            return false;
        }
        
        return true;
    }
}