/**
 * SKU定价弹窗 - 右侧物流信息展示区域数据处理
 * 负责右侧结果区域的数据处理，为主文件提供数据
 */

class SkuPricingModalRight {
    constructor() {
        this.calculationResults = [];
        this.shippingResults = [];
        this.summaryData = {};
    }

    /**
     * 初始化计算结果数据
     * @param {Array} results - 计算结果数组
     */
    initCalculationResults(results = []) {
        this.calculationResults = results;
        console.log('计算结果数据初始化完成');
    }

    /**
     * 获取计算结果数据
     * @returns {Array} 计算结果数组
     */
    getCalculationResults() {
        return [...this.calculationResults];
    }

    /**
     * 添加单个计算结果
     * @param {Object} result - 单个计算结果
     */
    addCalculationResult(result) {
        this.calculationResults.push(result);
        console.log('添加计算结果:', result);
    }

    /**
     * 批量添加计算结果
     * @param {Array} results - 计算结果数组
     */
    addCalculationResults(results) {
        let attributes =  results.map(result => Object.values(result.attributes).toString());
        const oldLen = this.calculationResults.length;
        console.log('原始计算结果:', this.calculationResults);
        this.calculationResults = this.calculationResults.filter(result => !attributes.includes(Object.values(result.attributes).toString()));
        console.log('过滤后计算结果:', this.calculationResults);
        const newLen = this.calculationResults.length;
        
        this.calculationResults = [...this.calculationResults, ...results];

        console.log(`覆盖了 ${oldLen - newLen} 条SKU数据，新增 ${results.length - newLen} 条SKU数据`);
        
        // 使用自定义弹窗替代原生 alert
        if (window.AlertUtils) {
            window.AlertUtils.alert(
                `核算完成！共覆盖了 ${oldLen - newLen} 条SKU数据，新增 ${results.length - oldLen + newLen} 条SKU数据`, 
                'success', 
                '核算成功'
            );
        } else {
            alert(`核算完成！共覆盖了 ${oldLen - newLen} 条SKU数据，新增 ${results.length - oldLen + newLen} 条SKU数据`);
        }
        
        console.log(`批量添加 ${results.length} 个计算结果`);
    }

    /**
     * 清空计算结果
     */
    clearCalculationResults() {
        this.calculationResults = [];
        console.log('计算结果已清空');
    }

    /**
     * 初始化物流结果数据
     * @param {Array} results - 物流结果数组
     */
    initShippingResults(results = []) {
        this.shippingResults = results;
        console.log('物流结果数据初始化完成');
    }

    /**
     * 获取物流结果数据
     * @returns {Array} 物流结果数组
     */
    getShippingResults() {
        return [...this.shippingResultsshippingResults];
    }

    /**
     * 添加物流结果
     * @param {Object} result - 物流结果
     */
    addShippingResult(result) {
        this.shippingResults.push(result);
        console.log('添加物流结果:', result);
    }

    /**
     * 初始化汇总数据
     * @param {Object} summary - 汇总数据
     */
    initSummaryData(summary = {}) {
        this.summaryData = summary;
        console.log('汇总数据初始化完成');
    }

    /**
     * 获取汇总数据
     * @returns {Object} 汇总数据
     */
    getSummaryData() {
        return { ...this.summaryData };
    }

    /**
     * 更新汇总数据
     * @param {string} key - 汇总键
     * @param {any} value - 汇总值
     */
    updateSummaryData(key, value) {
        this.summaryData[key] = value;
        console.log(`汇总数据更新: ${key} = ${value}`);
    }

    /**
     * 计算汇总数据
     * @param {Array} results - 计算结果数组
     * @returns {Object} 汇总数据
     */
    calculateSummaryData(results) {
        if (!results || results.length === 0) {
            return {
                totalSKUs: 0,
                totalCost: 0,
                totalRevenue: 0,
                totalProfit: 0,
                averageProfitMargin: 0
            };
        }

        const summary = {
            totalSKUs: results.length,
            totalCost: 0,
            totalRevenue: 0,
            totalProfit: 0,
            averageProfitMargin: 0
        };

        results.forEach(result => {
            summary.totalCost += result.totalCost || 0;
            summary.totalRevenue += result.totalRevenue || 0;
            summary.totalProfit += result.profit || 0;
        });

        if (summary.totalRevenue > 0) {
            summary.averageProfitMargin = (summary.totalProfit / summary.totalRevenue) * 100;
        }

        this.summaryData = summary;
        return summary;
    }

    /**
     * 获取完整的右侧数据
     * @returns {Object} 完整的右侧数据
     */
    getRightData() {
        return [...this.calculationResults];
    }

    /**
     * 格式化价格显示
     * @param {number} price - 价格
     * @param {string} currency - 货币符号
     * @returns {string} 格式化后的价格
     */
    formatPrice(price, currency = '¥') {
        return `${currency}${price.toFixed(2)}`;
    }

    /**
     * 格式化百分比显示
     * @param {number} percentage - 百分比
     * @returns {string} 格式化后的百分比
     */
    formatPercentage(percentage) {
        return `${percentage.toFixed(2)}%`;
    }

    /**
     * 渲染结果表格
     * @param {Array} results - 计算结果数组
     * @param {HTMLElement} tableBody - 表格tbody元素
     */
    renderResultTable(results, tableBody) {
        if (!tableBody) {
            console.error('表格容器未找到');
            return;
        }
        
        // 清空表格内容
        tableBody.innerHTML = '';
        
        if (!results || results.length === 0) {
            // 显示无数据提示
            tableBody.innerHTML = `
                <tr class="sku-table-empty">
                    <td colspan="10" rowspan="10">
                        <span> 暂无数据，请选择SKU属性并点击核算</span><br/>
                        <span>如有疑问请联系VX: AJiu000527</span>
                    </td>
                </tr>
            `;
            return;
        }
        
        let tableHeader = document.querySelector('.sku-table-header');
        let attributeNames = Object.keys(results[0].attributes || {});
        tableHeader.innerHTML = "";

        //处理超过6个属性值的情况
        if(attributeNames.length > 6){
            let tempStr = "";
            attributeNames.forEach((name, index) => {
               tempStr += name + "-";
            });
            //去掉最后一个- 
            tempStr = tempStr.substring(0, tempStr.length - 1);
             tableHeader.innerHTML += `<th>${tempStr || `SKU属性`}</th>`;
        }else{
            attributeNames.forEach((name, index) => {
                tableHeader.innerHTML += `<th>${name || `属性名称${index + 1}`}</th>`;
            });
        }
        tableHeader.innerHTML +=
        `
            <th>基准国</th>
            <th>物流方式</th>
            <th>重量(G)</th>
            <th>基准国邮费</th>
            <th>产品成本</th>
            <th>利润</th>
            <th>推荐售价</th>
            <th>最大折扣</th>
        `
        // 渲染SKU数据行
        results.forEach((result, index) => {
            const row = this.createResultRow(result, index);
            tableBody.appendChild(row);
        });
        
        console.log(`表格渲染完成，共 ${results.length} 个SKU`);
    }
    
    /**
     * 创建结果表格行
     * @param {Object} result - 单个SKU计算结果
     * @param {number} index - 行索引
     * @returns {HTMLElement} 表格行元素
     */
    createResultRow(result, index) {

        const row = document.createElement('tr');
        
        // 设置行样式
        if (index % 2 === 0) {
            row.classList.add('sku-table-row-even');
        } else {
            row.classList.add('sku-table-row-odd');
        }


        // 获取属性值
        const attributes = result.attributes || {};
        const attributeValues = Object.values(attributes);
        // 处理属性值超过6个的情况
        if(attributeValues.length > 6){
            let tempStr = "";
            attributeValues.forEach((value, index) => {
                tempStr += value + "-";
            });
            //去掉最后一个-
            tempStr = tempStr.substring(0, tempStr.length - 1);
            row.innerHTML += `<td>${tempStr || '-'}</td>`;
        }else{
            attributeValues.forEach((value, index) => {
                row.innerHTML += `<td>${value || '-'}</td>`;
            });
        }

        // 填充表格数据
        row.innerHTML += `            
            <td>${result.baseCountry || '-'}</td>
            <td>${result.logistics || '-'}</td>
            <td>${result.weight || '0'}</td>
            <td>${this.formatCurrency(result.baseShippingFee || 0)}</td>
            <td>${this.formatCurrency(result.productCost || 0)}</td>
            <td class="profit-cell">${this.formatCurrency(result.profit || 0)}</td>
            <td class="recommend-price-cell">${this.formatCurrency(result.recommendPrice || 0)}</td>
            <td class="max-discount-cell">${this.formatPercentage(result.maxDiscount || 0)}</td>
        `;
        
        return row;
    }
    
    /**
     * 格式化货币金额
     * @param {number} amount - 金额
     * @returns {string} 格式化后的金额
     */
    formatCurrency(amount) {
        return '¥' + parseFloat(amount).toFixed(2);
    }
    
    /**
     * 格式化百分比
     * @param {number} percentage - 百分比值
     * @returns {string} 格式化后的百分比
     */
    formatPercentage(percentage) {
        return parseFloat(percentage).toFixed(2) + '%';
    }

    /**
     * 导出计算结果
     * @param {string} format - 导出格式 (json, csv, excel)
     * @returns {string} 导出的数据
     */
    exportResults(format = 'json') {
        const data = this.getRightData();
        
        switch (format) {
            case 'json':
                return JSON.stringify(data, null, 2);
            case 'csv':
                return this.convertToCSV(data);
            case 'excel':
                // 这里可以集成Excel导出功能
                return 'Excel导出功能待实现';
            default:
                return JSON.stringify(data, null, 2);
        }
    }

    /**
     * 转换为CSV格式
     * @param {Array} data - 数据数组
     * @returns {string} CSV格式数据
     */
    convertToCSV(data) {
        if (!data || data.length === 0) return '';
        
        const headers = Object.keys(data[0]);
        const csvRows = [];
        
        // 添加表头
        csvRows.push(headers.join(','));
        
        // 添加数据行
        data.forEach(row => {
            const values = headers.map(header => {
                const value = row[header];
                // 处理包含逗号的值
                return typeof value === 'string' && value.includes(',') ? `"${value}"` : value;
            });
            csvRows.push(values.join(','));
        });
        
        return csvRows.join('\n');
    }

    /**
     * 重置右侧数据
     */
    resetRightData() {
        this.calculationResults = [];
        this.shippingResults = [];
        this.summaryData = {};
        console.log('右侧数据已重置');
    }
}

// 创建全局实例
window.skuPricingModalRight = new SkuPricingModalRight();

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