/**
 * SKU定价弹窗 - 左侧SKU信息配置区域数据处理
 * 负责左侧配置区域的数据处理，为主文件提供数据
 */
class SkuPricingModalLeft {
    constructor() {
        this.leftModalData = {
            currency: '', // 货币
            logisticsData:{},//物流数据
            // 国家列表[{code: '', name: '', eName: '', data:[{min: '', max: '', deliveryFee: ''，registrationFee:'' }]}]
            listCountry: [], 
            logistics: '', // 物流方式
            logisticsDiscount: 100, // 物流折扣(%)
            sizeLength: 0, // 长度(cm)
            sizeWidth: 0, // 宽度(cm)
            sizeHeight: 0, // 高度(cm)
            sizeResult: 0, // 体积(自动计算)
            weight: 1, // 重量(g)
            baseCountry: '', // 基准国家
            baseLogistics: {}, // 基准物流方式
            baseShippingFee: 0, // 基准国邮费
            storeDiscount: 0, // 店铺折扣(%)
            productCost: 0, // 产品成本
            discount: 0, // 店铺优惠
            platformCommission: 0, // 平台佣金(%)
            affiliateCommission: 0, // 联盟佣金(%)
            transactionFee: 0, // 交易服务费(%)
            goldenMarketing: 0, // 金牌营销费用(%)
            activityDiscount: 0, // 活动折扣(%)
            lossRate: 0, // 损失率(%)
            profitRatio: 2, // 利润率计算方式(1:成本, 2:售价)
            profitMargin: 0, // 目标利润率(%)
            adRatio: 0, // 广告投放比例(%)
            recommendPrice: 0, // 推荐售价
            discountPrice: 0, // 折后价格
            maxDiscount: 0 // 最大折扣(%)
        };
        this.baseUrl = "1111";
        this.logisticList = []; // 物流方式列表
        this.cacheLogisticsData = {}; // 物流数据缓存
        this.listCountry = []; // 国家列表
        this.skuAttributes = []; // 所有可用的SKU属性列表
        this.selectedAttributes = []; // 用户已选择的SKU属性列表
        

        this.api = window.skuPricingApi;// 实例化API类
        this.storageKey = 'sku_pricing'; // 本地存储键名

        this.apiLogistics = window.apiLogistics;// 实例化物流API类
    }

    /**
     * 加载本地存储数据
     * @returns {Object} 存储的数据对象
     */
    loadStoredData() {
        if (window.storageUtils && window.storageUtils.get) {
            const storedData = window.storageUtils.get(this.storageKey);
            if (storedData && typeof storedData === 'object') {
                return storedData;
            }
        }
        return {};
    }

    /**
     * 保存数据到本地存储
     */
    saveStoredData() {
        if (window.storageUtils && window.storageUtils.set) {
            // 只保存需要持久化的字段，排除临时计算字段
            const dataToSave = {
                // 物流相关配置
                logistics: this.leftModalData.logistics, // 物流方式：菜鸟物流、标准物流等
                logisticsDiscount: this.leftModalData.logisticsDiscount, // 物流折扣(%)：0-100之间的折扣比例
                
                // 产品尺寸和重量
                sizeLength: this.leftModalData.sizeLength, // 产品长度(cm)：用于计算体积和运费
                sizeWidth: this.leftModalData.sizeWidth, // 产品宽度(cm)：用于计算体积和运费
                sizeHeight: this.leftModalData.sizeHeight, // 产品高度(cm)：用于计算体积和运费
                weight: this.leftModalData.weight<=1 ? 1 : this.leftModalData.weight, // 产品重量(g)：运费计算的关键参数
                
                // 基准国家配置
                baseCountry: this.leftModalData.baseCountry, // 基准国家代码：运费计算的基准国家
                baseShippingFee: this.leftModalData.baseShippingFee, // 基准国邮费：基准国家的运费金额
                
                // 成本相关配置
                productCost: this.leftModalData.productCost, // 产品成本：产品采购或生产成本
                storeDiscount: this.leftModalData.storeDiscount, // 店铺折扣(%)：店铺级别的折扣比例
                discount: this.leftModalData.discount, // 店铺优惠：具体的优惠金额
                
                // 平台费用配置
                platformCommission: this.leftModalData.platformCommission, // 平台佣金(%)：平台收取的佣金比例
                affiliateCommission: this.leftModalData.affiliateCommission, // 联盟佣金(%)：联盟营销佣金比例
                transactionFee: this.leftModalData.transactionFee, // 交易服务费(%)：交易处理费用比例
                goldenMarketing: this.leftModalData.goldenMarketing, // 金牌营销费用(%)：营销活动费用比例
                activityDiscount: this.leftModalData.activityDiscount, // 活动折扣(%)：促销活动折扣比例
                
                // 利润和损失配置
                lossRate: this.leftModalData.lossRate, // 损失率(%)：预计的损失或退货率
                profitRatio: this.leftModalData.profitRatio, // 利润率计算方式：1=基于成本, 2=基于售价
                profitMargin: this.leftModalData.profitMargin, // 目标利润率(%)：期望的利润率
                
                // 广告和营销配置
                adRatio: this.leftModalData.adRatio, // 广告投放比例(%)：广告预算占销售额的比例
                
                // 价格计算结果
                recommendPrice: this.leftModalData.recommendPrice, // 推荐售价：系统计算出的建议销售价格
                discountPrice: this.leftModalData.discountPrice, // 展示价格（折后价格）：考虑所有折扣后的实际售价
                maxDiscount: this.leftModalData.maxDiscount // 最大折扣(%)：可提供的最大折扣比例
            };
            
            window.storageUtils.set(this.storageKey, dataToSave);
        } else {
            console.warn('storageUtils工具类未找到，无法保存数据');
        }
    }

    /**
     * 初始化左侧配置数据
     * @param {Object} initialData - 初始数据
     */
    async initLeftData() {
        
        // 1. 首先读取本地存储数据
        const storedData = this.loadStoredData();
        
        let data = {
            value:storedData.logistics || "eco_global",
        }
        await this.getLogisticList();


        await this.handleChangeLogistics(data);

        // 2. 合并初始数据和本地存储数据，本地存储数据优先级更高
        this.leftModalData = { ...this.leftModalData, ...storedData };
        
        this.calculateBaseShippingFee();
        console.log('初始化左侧配置数据', this.leftModalData);

        const defaultAttributes = window.skuUtils.arrSku;
        this.initSkuAttributes(defaultAttributes);
    }

    /**
     * 获取物流方式列表
     * 使用缓存机制避免重复请求，提高性能
     * 
     * @async
     * @returns {Promise<Array>} 物流方式列表的副本（防止外部修改内部数据）
     * @example
     * // 使用示例
     * const logisticList = await skuPricingModalLeft.getLogisticList();
     * // 输出: [{id: 'standard', name: '标准物流'}, ...]
     */
    async getLogisticList() {
        // 如果已有缓存数据，直接返回
        if (this.logisticList && this.logisticList.length > 0) {
            return [...this.logisticList];
        }
        
        this.logisticList = await this.api.getLogisticList();

        
        // 返回物流列表的浅拷贝，防止外部代码修改内部数据
        // 使用扩展运算符创建新数组，确保数据隔离性
        return [...this.logisticList];
    }

        /**
     * 更新配置数据
     * @param {string} key - 配置键
     * @param {any} value - 配置值
     */
    async updateLeftData(key, value) {
        if (key in this.leftModalData) {
            this.leftModalData[key] = value;
            
            // 如果是尺寸数据，自动计算体积
            if (key === 'sizeLength' || key === 'sizeWidth' || key === 'sizeHeight') {
                this.calculateSizeVolume();
            }
            // 如果是重量数据，自动计算基准国邮费
            if(key === 'weight'){
                this.handleChangeWeight(value);
            }

            // 如果是物流数据，自动更新物流数据
            if(key === 'logistics'){
                await this.handleChangeLogistics({value: value});
                window.skuPricingModal.renderCountrySelect();
            }
            // 如果是基准国家数据，自动更新基准国家
            if(key === 'baseCountry'){
                this.handleChangeCountry(value);
            }

            if(key === 'logisticsDiscount'){
                this.handleChangeLogisticsDiscount(value);
            }
            
            // 当菜鸟物流、物流折扣、产品重量、基准国家发生改变时，重新计算基准国邮费
            if (key === 'logistics' || key === 'logisticsDiscount' || key === 'weight' || key === 'baseCountry') {
                this.calculateBaseShippingFee();
            }
            
            // 保存数据到本地存储
            this.saveStoredData();
            
            this.calculateRecommendPrice();
            
        }
    }

    /**
     * 处理物流折扣改变事件 物流折扣不能大于100也不能低于0
     * @param {*} value 物流折扣
     */
    handleChangeLogisticsDiscount(value) {
        if(value >= 100 || value < 0){
            if (window.AlertUtils) {
                window.AlertUtils.alert('物流折扣不能大于100也不能低于0', 'error');
            } else {
                window.alert('物流折扣不能大于100也不能低于0');
            }
            return;
        }
        this.leftModalData.logisticsDiscount = value;
    }

    /**
     * 获取物流数据信息
     * @param {Object} data.value - 物流数据名称
     * @returns 
     */
    async handleChangeLogistics(data) {
        // 如果已有缓存数据，直接返回
        if (!this.cacheLogisticsData[data.value]) {
            let routeId = 1;
             this.logisticList.forEach((item) =>{
                if(item.routeCode === data.value){
                    routeId = item.routeId;
                }
            });

            this.cacheLogisticsData[data.value] = await this.apiLogistics.listByRouteId({routeId});


        }

        

        this.leftModalData.logisticsData = this.cacheLogisticsData[data.value];
        this.leftModalData.listCountry = this.leftModalData.logisticsData.countries;
        let deliveredCountries = this.leftModalData.listCountry.map(country => country.code);


        // 判断当前基准国家是否在当前物流的运达国家内。
        // 如果基准国家不在已发货国家列表中，默认选择第一个国家
        if(!deliveredCountries.includes(this.leftModalData.baseCountry)){
            this.leftModalData.baseCountry = this.leftModalData.logisticsData.countries[0].code;
        }

        this.leftModalData.listCountry.find((country) =>{
            if(country.code === this.leftModalData.baseCountry){
                this.leftModalData.baseLogistics = country;

            }
        } );
        


        this.leftModalData.logistics = data.value;
        //设置该物流的结算币种 
        this.leftModalData.currency = this.leftModalData.logisticsData.currency;


        return {...this.leftModalData};
    }

    /**
     * 处理重量选择改变事件
     * @param {*} value 
     */
    handleChangeWeight(value) {
        if(value == 0 || value == null){
            return;
        }
        // 重量发生改变，需要重新计算基准国邮费
        let flag = false;
        this.leftModalData.baseLogistics.data.find((item) =>{
            if(item.min <= value && item.max >= value){
                flag = true;
            }
        });

        if(!flag){
            this.leftModalData.weight = 1;
            if (window.AlertUtils) {
                window.AlertUtils.alert('当前重量不在该物流的运达重量范围内，请重新输入重量', 'error');
            } else {
                window.alert('当前重量不在该物流的运达重量范围内，请重新输入重量');
            }
        }


        this.leftModalData.weight = value;
    } 

    /**
     * 处理基准国家选择改变事件
     * @param {string} value - 选中的国家代码
     */
    handleChangeCountry(value) {
        // 国家发生改变，需要更新国家列表
        this.leftModalData.baseCountry = value;
        this.leftModalData.baseLogistics = this.leftModalData.listCountry.find(country => country.code === value);
        
    }



    /**
     * 计算尺寸体积
     */
    calculateSizeVolume() {
        const { sizeLength, sizeWidth, sizeHeight } = this.leftModalData;
        this.leftModalData.sizeResult = sizeLength * sizeWidth * sizeHeight;
        
        // 尺寸改变时，重新计算基准国邮费
        this.calculateBaseShippingFee();
    }

    //核算当前重量当前路线各个国家的邮费
    calculateAllCountriesShippingFee() {
        // 国家列表[{code: '', name: '', eName: '', data:[{min: '', max: '', deliveryFee: ''，registrationFee:'' }]}]
        //获取当前路线运达国家数据
        let deliveredCountries = this.leftModalData.listCountry;
        let rate = this.leftModalData.currency === 'RMB' ? 1 : 7;

        let results = deliveredCountries.map((country) =>{

            let costData = country.data.find((item) => item.min <= this.leftModalData.weight && item.max >= this.leftModalData.weight);
            //判断是大包还是小包
            let type = this.logisticList.find((item) => item.routeCode === this.leftModalData.logistics).type;
            return {
                name: country.name,
                weight: this.leftModalData.weight,
                deliveryFee: costData.deliveryFee,
                registrationFee: costData.registrationFee,
                shippingFee: type == "bigpack" 
                ? parseFloat((costData.deliveryFee/1000*Math.ceil(this.leftModalData.weight / 100) + costData.registrationFee * rate*this.leftModalData.logisticsDiscount / 100).toFixed(2))
                : parseFloat(((costData.deliveryFee / 1000 * this.leftModalData.weight + costData.registrationFee ) * rate * this.leftModalData.logisticsDiscount / 100).toFixed(2))
            };
        });

        // 输出Excel格式到控制台
        //console.log('国家\t重量(g)\t派送服务费\t挂号费\t邮费');
        // results.forEach(item => {
        //     console.log(`${item.name}\t${item.weight}\t${item.deliveryFee}\t${item.registrationFee}\t${item.shippingFee}`);
        // });
        // console.log(results);

        // // 同时输出表格格式便于查看
        //console.table(results);
    }


    /**
     * 计算基准国邮费
     * 当菜鸟物流、物流折扣、尺寸、产品重量、基准国家发生改变时调用
     */
    calculateBaseShippingFee() {
        this.calculateAllCountriesShippingFee();
            this.leftModalData.baseCountry,this.leftModalData.weight,
            this.leftModalData.logisticsDiscount;

        let rate = this.leftModalData.currency === 'RMB' ? 1 : 7;
        // 检查必要数据是否完整
        if (!this.leftModalData.logistics || !this.leftModalData.baseCountry || this.leftModalData.weight <= 1 ) {
            this.leftModalData.baseShippingFee = 0;
            this.updateBaseShippingFeeDisplay();
            return;
        }
        let type = this.logisticList.find((item) => item.routeCode === this.leftModalData.logistics).type;


        // 小包裹物流
        if(type == "smallpack"){
            let tempdata = this.leftModalData.baseLogistics.data.find((item) =>{
                if(item.min <= this.leftModalData.weight && item.max >= this.leftModalData.weight){
                    return item;
                }
            })
            console.log("tempdata",tempdata);

            this.leftModalData.baseShippingFee = 
            parseFloat(
            ((tempdata.deliveryFee / 1000 * this.leftModalData.weight + tempdata.registrationFee ) 
            * rate
            *this.leftModalData.logisticsDiscount / 100).toFixed(2)
            );
        // 大包裹物流
        }else if(type == "bigpack"){

            let bigpackData = this.leftModalData.logisticsData.data;
            this.leftModalData.baseShippingFee = 
            parseFloat(
                (bigpackData[0].deliveryFee/1000*Math.ceil(this.leftModalData.weight / 100) + bigpackData[0].registrationFee 
                * rate
                *this.leftModalData.logisticsDiscount / 100).toFixed(2)
            );
        }else{
            if (window.AlertUtils) {
                window.AlertUtils.alert('当前物流计算方式有误，请联系管理员，VX：AJiu000527', 'error');
            } else {
                window.alert('当前物流计算方式有误，请联系管理员，VX：AJiu000527');
            }
        }
        
        this.updateBaseShippingFeeDisplay();

    }

    
    /**
     * 计算推荐价格
     * 给推荐售价/展示价格/最大折扣  进行赋值
     * 利润比方式：
     * 1. 利润成本比
     * 成本 = (基准国邮费 + 产品成本 * (1 + 利润成本比 / 100)) + (产品成本 + 基准国邮费) * 折损率 / 100
     * 平台佣金比例 = (平台佣金 + 联盟佣金 + 交易服务费 + 金币营销 + 广告投放比例 ) / 100
     * 订单金额 = 成本 / (1 - 平台佣金) + 店铺优惠
     * 活动折扣前价格 = 订单金额 / (1 - 活动折扣/100 )
     * 推荐售价 = 活动折扣前价格 / (1 - 店铺折扣/100)
     * 2. 利润售价比
     * 折损金额 = (成本 + 邮费)* 折损率/100 
     * 成本 = 折损金额 + 成本 + 邮费 + 毛利率 * 店铺优惠)
     * 订单金额 = (成本 / (1-(平台佣金 + 联盟佣金 + 服务费 + 金币营销 + 广告投放比例 + 毛利/100) + 店铺优惠
     * 活动折扣前价格 = 订单金额 / (1 - 活动折扣/100 )
     * 推荐售价 = 活动折扣前价格 / (1 - 店铺折扣/100)
     */
    calculateRecommendPrice(){

        let orderPrice = 0;

        let cost = 0;
        if(this.leftModalData.profitRatio == 1){
            //计算成本 
            cost = parseFloat((this.leftModalData.baseShippingFee + this.leftModalData.productCost * (1 + this.leftModalData.profitMargin / 100)) 
            + (this.leftModalData.productCost + this.leftModalData.baseShippingFee) * this.leftModalData.lossRate / 100).toFixed(3);

            // 计算平台佣金比例
            let platformCommissionRatio = parseFloat((
                this.leftModalData.platformCommission + this.leftModalData.affiliateCommission 
                + this.leftModalData.transactionFee + this.leftModalData.goldenMarketing
                + this.leftModalData.adRatio
            ) / 100).toFixed(3);

            // 计算订单价格
            orderPrice = parseFloat((cost / (1 - platformCommissionRatio) + this.leftModalData.discount).toFixed(2));
            

        
        }else if(this.leftModalData.profitRatio == 2){

            //订单金额：((成本 + 邮费)* 折损率/100 + 成本 + 邮费 + 毛利率 * 店铺优惠)/(1-(平台佣金 + 联盟佣金 + 服务费 + 金币营销 + 广告投放比例 + 毛利)/100) + 店铺优惠


            //折损金额 = (成本 + 邮费)* 折损率/100 
            let lossAmount = parseFloat(((this.leftModalData.productCost + this.leftModalData.baseShippingFee) * this.leftModalData.lossRate / 100).toFixed(2));
            
            //成本 = 折损金额 + 成本 + 邮费 + 毛利率 * 店铺优惠)
            cost = parseFloat(
                parseFloat(lossAmount + this.leftModalData.productCost + this.leftModalData.baseShippingFee + this.leftModalData.profitMargin / 100 * this.leftModalData.discount).toFixed(2)
            );

            // 计算平台佣金比例
            let platformCommissionRatio = parseFloat(
                parseFloat((
                this.leftModalData.platformCommission + this.leftModalData.affiliateCommission 
                + this.leftModalData.transactionFee + this.leftModalData.goldenMarketing
                + this.leftModalData.adRatio + this.leftModalData.profitMargin
            ) / 100)
            .toFixed(2));
            

            // 计算订单价格
            orderPrice = parseFloat(
                parseFloat(cost / (1 - platformCommissionRatio) + this.leftModalData.discount).toFixed(2)
        );

        

        }

         //展示价格/活动折扣后价格 
         this.leftModalData.discountPrice = orderPrice;

         // 活动折扣前价格 = 订单金额 / (1 - 活动折扣/100 )
        let discountPrice = parseFloat((orderPrice / (1 - this.leftModalData.activityDiscount / 100)).toFixed(2));

        // 推荐售价 = 活动折扣前价格 / (1 - 店铺折扣/100)
        this.leftModalData.recommendPrice = parseFloat((discountPrice / (1 - this.leftModalData.storeDiscount / 100)).toFixed(2));
        //最大折扣(%) = (推荐售价 - 成本)/推荐售价
        this.leftModalData.maxDiscount = parseFloat(((this.leftModalData.recommendPrice - cost) / this.leftModalData.recommendPrice * 100).toFixed(2));
        window.skuPricingModal.renderInputElements([
            {id: 'recommendPrice', value: this.leftModalData.recommendPrice},
            {id: 'discountPrice', value: this.leftModalData.discountPrice},
            {id: 'maxDiscount', value: this.leftModalData.maxDiscount},
        ]);

    }

    /**
     * 计算前台展示价格
     * 前台展示价格 = 推荐售价 * (1 - 店铺折扣/ 100) * 活动折扣
     */
    calculateDiscountPrice(){
        let discountPrice = this.leftModalData.recommendPrice * (1 - this.leftModalData.storeDiscount / 100) * this.leftModalData.activityDiscount;
        this.leftModalData.discountPrice = parseFloat(discountPrice.toFixed(2));
    }


    

    /**
     * 更新基准国邮费显示
     */
    updateBaseShippingFeeDisplay() {
        // 调用主弹窗的更新显示方法
        const skuPricingModal = window.skuPricingModal;
        if (skuPricingModal && typeof skuPricingModal.updateBaseShippingFeeDisplay === 'function') {
            skuPricingModal.updateBaseShippingFeeDisplay();
        }
    }

    /**
     * 初始化SKU属性数据
     * @param {Array} attributes - SKU属性数组
     */
    initSkuAttributes(attributes) {
        this.skuAttributes = attributes;
        this.selectedAttributes = [];
    }

    /**
     * 获取SKU属性数据
     * @returns {Array} SKU属性数据
     */
    getSkuAttributes() {
        // 安全地返回SKU属性数据，避免this.skuAttributes为undefined的情况
        return Array.isArray(this.skuAttributes) ? [...this.skuAttributes] : [];
    }

    /**
     * 获取选中的SKU属性
     * @returns {Array} 选中的属性
     */
    getSelectedAttributes() {
        return [...this.selectedAttributes];
    }

    /**
     * 更新选中的SKU属性
     * @param {Array} selected - 选中的属性数组
     */
    updateSelectedAttributes(selected) {
        this.selectedAttributes = selected;
    }

    /**
     * 验证配置数据
     * @returns {Object} 验证结果 {isValid: boolean, errors: Array}
     */
    validateLeftData() {
        const errors = [];
        
        if (!this.leftModalData.logistics) {

            errors.push('请选择物流方式');
        }
        
        if (this.leftModalData.weight <= 1) {
            errors.push('产品重量必须大于1');
        }
        
        if (this.leftModalData.productCost <= 0) {
            errors.push('产品成本必须大于0');
        }
        
        if (!this.leftModalData.baseCountry) {
            errors.push('请选择基准国家');
        }
        
        return {
            isValid: errors.length === 0,
            errors: errors
        };
    }

    /**
     * 获取完整的左侧数据
     * @returns {Object} 完整的左侧数据
     */
    getLeftData() {
        return {
            leftModalData: { ...this.leftModalData },
            skuAttributes: this.getSkuAttributes(),
            selectedAttributes: this.getSelectedAttributes(),
            validation: this.validateLeftData()
        };
    }

    /**
     * 重置左侧数据
     */
    resetLeftData() {
        this.leftModalData = {
            logistics: '', // 物流方式
            logisticsDiscount: 0, // 物流折扣(%)
            sizeLength: 0, // 长度(cm)
            sizeWidth: 0, // 宽度(cm)
            sizeHeight: 0, // 高度(cm)
            sizeResult: 0, // 体积(自动计算)
            weight: 0, // 重量(g)
            baseCountry: '', // 基准国家
            baseShippingFee: 0, // 基准国邮费
            storeDiscount: 0, // 店铺折扣(%)
            productCost: 0, // 产品成本
            discount: 0, // 店铺优惠(%)
            platformCommission: 0, // 平台佣金(%)
            affiliateCommission: 0, // 联盟佣金(%)
            transactionFee: 0, // 交易手续费(%)
            goldenMarketing: 0, // 金牌营销费用(%)
            activityDiscount: 0, // 活动折扣(%)
            lossRate: 0, // 损失率(%)
            profitRatio: 2, // 利润率计算方式(1:成本, 2:售价)
            profitMargin: 0, // 目标利润率(%)
            adRatio: 0, // 广告投放比例(%)
            recommendPrice: 0, // 推荐售价
            discountPrice: 0, // 折后价格
            maxDiscount: 0 // 最大折扣(%)
        };
        
        this.skuAttributes = []; // 所有可用的SKU属性列表
        this.selectedAttributes = []; // 用户已选择的SKU属性列表
    }     


}

// 创建全局实例
window.skuPricingModalLeft = new SkuPricingModalLeft();

// 导出类
if (typeof module !== 'undefined' && module.exports) {
    module.exports = SkuPricingModalLeft;
}