/**
 * 本地存储工具类 - 简化版
 * 使用浏览器本地存储，添加私有前缀，避免异步操作
 */

class StorageUtils {
    constructor() {
        // 私有前缀，不对外公开
        this.prefix = '_ali_pricing_tool_';
    }

    /**
     * 获取带前缀的完整键名
     * @param {string} key - 原始键名
     * @returns {string} 带前缀的完整键名
     */
    _getFullKey(key) {
        return this.prefix + key;
    }

    /**
     * 存储数据到本地存储
     * @param {string} key - 存储键名
     * @param {any} value - 存储的数据
     */
    set(key, value) {
        const fullKey = this._getFullKey(key);
        
        // 如果是对象或数组，转换为JSON字符串
        if (typeof value === 'object' && value !== null) {
            localStorage.setItem(fullKey, JSON.stringify(value));
        } else {
            localStorage.setItem(fullKey, value);
        }
        
        console.log(`存储键 "${key}" 成功`);
    }

    /**
     * 从本地存储获取数据
     * @param {string} key - 存储键名
     * @returns {any} 存储的数据
     */
    get(key) {
        const fullKey = this._getFullKey(key);
        const value = localStorage.getItem(fullKey);
        
        if (value === null) {
            console.log(`存储键 "${key}" 不存在`);
            return null;
        }

        try {
            // 尝试解析JSON
            const parsedValue = JSON.parse(value);
            console.log(`获取存储键 "${key}" 成功`);
            return parsedValue;
        } catch (e) {
            // 如果不是JSON，返回原始值
            console.log(`获取存储键 "${key}" 成功（非JSON数据）`);
            return value;
        }
    }

    /**
     * 删除指定的存储键
     * @param {string} key - 要删除的存储键名
     */
    remove(key) {
        const fullKey = this._getFullKey(key);
        localStorage.removeItem(fullKey);
        console.log(`删除存储键 "${key}" 成功`);
    }

    /**
     * 检查存储键是否存在
     * @param {string} key - 存储键名
     * @returns {boolean} 是否存在
     */
    has(key) {
        const fullKey = this._getFullKey(key);
        const exists = localStorage.getItem(fullKey) !== null;
        console.log(`存储键 "${key}" ${exists ? '存在' : '不存在'}`);
        return exists;
    }

    /**
     * 清空所有带前缀的存储数据
     */
    clear() {
        const keysToRemove = [];
        
        // 遍历所有存储键，找到带前缀的键
        for (let i = 0; i < localStorage.length; i++) {
            const key = localStorage.key(i);
            if (key && key.startsWith(this.prefix)) {
                keysToRemove.push(key);
            }
        }
        
        // 删除所有带前缀的键
        keysToRemove.forEach(key => {
            localStorage.removeItem(key);
        });
        
        console.log(`清空 ${keysToRemove.length} 个存储键成功`);
    }

    /**
     * 获取所有带前缀的存储键名（不含前缀）
     * @returns {Array<string>} 所有存储键名数组
     */
    getAllKeys() {
        const keys = [];
        
        for (let i = 0; i < localStorage.length; i++) {
            const key = localStorage.key(i);
            if (key && key.startsWith(this.prefix)) {
                // 去掉前缀返回
                keys.push(key.substring(this.prefix.length));
            }
        }
        
        console.log(`获取到 ${keys.length} 个存储键`);
        return keys;
    }

    /**
     * 批量设置多个存储键
     * @param {Object} dataObject - 包含多个键值对的对象
     */
    setMultiple(dataObject) {
        for (const [key, value] of Object.entries(dataObject)) {
            this.set(key, value);
        }
        console.log(`批量设置 ${Object.keys(dataObject).length} 个存储键成功`);
    }

    /**
     * 批量获取多个存储键
     * @param {Array<string>} keys - 存储键名数组
     * @returns {Object} 包含所有键值对的对象
     */
    getMultiple(keys) {
        const result = {};
        
        keys.forEach(key => {
            result[key] = this.get(key);
        });
        
        console.log(`批量获取 ${keys.length} 个存储键成功`);
        return result;
    }
}

// 创建全局实例
window.storageUtils = new StorageUtils();

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