/**
 * 地址数据懒加载器 - 按需加载，大幅减少首次加载时间
 * 优化方案：
 * 1. 首次只加载省份列表（数据量很小，< 1MB）
 * 2. 选择省份后，按需加载该省份的市数据
 * 3. 逐级懒加载，避免一次性加载90M+数据
 */
import IndexedDBHelper from '@/common/IndexedDBHelper.js';

class AddressDataLoaderLazy {
    constructor() {
        this.dbHelper = null;
        this.dbName = 'AddressDataLazyDB';
        this.storeName = 'addressDataLazy';
        this.isInitialized = false;
        
        // 缓存配置
        this.cacheExpireDays = 7;
        
        // 数据源配置
        this.baseUrl = 'http://124.243.245.42/ks_cms';
        this.fullDataUrl = `${this.baseUrl}/address.json`; // 完整地址数据
        this.provinceListUrl = `${this.baseUrl}/address_provinces.json`; // 省份列表（轻量级，可选）
        this.provinceDetailUrl = `${this.baseUrl}/address_province_{code}.json`; // 省份详情（按需加载，可选）
        
        // 是否启用分片接口（如果服务器提供了分片接口，设置为true）
        this.useSplitApi = false; // 默认false，从完整数据中提取
        
        // 内存缓存（避免重复请求）
        this.memoryCache = new Map();
    }

    /**
     * 初始化数据库
     */
    async init() {
        if (this.isInitialized && this.dbHelper) {
            return;
        }

        try {
            this.dbHelper = new IndexedDBHelper(this.dbName, 1);
            await this.dbHelper.openDB([{
                name: this.storeName,
                keyPath: 'key',
                indexes: [
                    { name: 'type', key: 'type', unique: false },
                    { name: 'updateTime', key: 'updateTime', unique: false }
                ]
            }]);
            this.isInitialized = true;
            console.log('✅ 地址数据懒加载器初始化成功');
        } catch (error) {
            console.error('❌ 地址数据懒加载器初始化失败:', error);
            this.isInitialized = true;
        }
    }

    /**
     * 从缓存获取数据
     */
    async getCachedData(key) {
        // 先检查内存缓存
        if (this.memoryCache.has(key)) {
            const cached = this.memoryCache.get(key);
            if (cached.expireTime > Date.now()) {
                return cached.data;
            } else {
                this.memoryCache.delete(key);
            }
        }

        // 检查 IndexedDB 缓存
        try {
            if (this.dbHelper) {
                const cached = await this.dbHelper.get(this.storeName, key);
                if (cached && cached.data) {
                    const updateTime = cached.updateTime || 0;
                    const expireTime = this.cacheExpireDays * 24 * 60 * 60 * 1000;
                    if (Date.now() - updateTime < expireTime) {
                        // 同时更新内存缓存
                        this.memoryCache.set(key, {
                            data: cached.data,
                            expireTime: Date.now() + expireTime
                        });
                        return cached.data;
                    }
                }
            }
        } catch (e) {
            console.warn('从 IndexedDB 读取缓存失败:', e);
        }

        // 降级方案：从 uni.storage 读取
        try {
            const cached = uni.getStorageSync(key);
            if (cached && cached.data) {
                const updateTime = cached.updateTime || 0;
                const expireTime = this.cacheExpireDays * 24 * 60 * 60 * 1000;
                if (Date.now() - updateTime < expireTime) {
                    this.memoryCache.set(key, {
                        data: cached.data,
                        expireTime: Date.now() + expireTime
                    });
                    return cached.data;
                }
            }
        } catch (e) {
            console.warn('从 uni.storage 读取缓存失败:', e);
        }

        return null;
    }

    /**
     * 保存数据到缓存
     */
    async saveToCache(key, data, type = 'province') {
        const cacheData = {
            key: key,
            type: type,
            data: data,
            updateTime: Date.now()
        };

        // 更新内存缓存（1小时有效期）
        this.memoryCache.set(key, {
            data: data,
            expireTime: Date.now() + 60 * 60 * 1000
        });

        try {
            if (this.dbHelper) {
                try {
                    const existing = await this.dbHelper.get(this.storeName, key);
                    if (existing) {
                        await this.dbHelper.update(this.storeName, cacheData);
                    } else {
                        await this.dbHelper.add(this.storeName, cacheData);
                    }
                } catch (e) {
                    await this.dbHelper.add(this.storeName, cacheData);
                }
            }
        } catch (e) {
            console.warn('保存到 IndexedDB 失败，降级到 uni.storage:', e);
        }

        // 降级方案：保存到 uni.storage
        try {
            uni.setStorageSync(key, cacheData);
        } catch (e) {
            if (e.errMsg?.includes('exceed')) {
                console.warn('存储空间不足，清理部分缓存');
                await this.clearOldCache();
            }
        }
    }

    /**
     * 从服务器加载数据
     */
    async fetchData(url, cacheKey = null) {
        return new Promise((resolve, reject) => {
            console.log(`📥 开始加载: ${url}`);
            const startTime = Date.now();

            uni.request({
                url: url,
                method: 'GET',
                timeout: 60000, // 60秒超时
                success: (res) => {
                    const endTime = Date.now();
                    const duration = ((endTime - startTime) / 1000).toFixed(2);
                    console.log(`✅ 数据加载完成，耗时 ${duration} 秒`);

                    if (res.statusCode === 200) {
                        let data = res.data;
                        if (typeof data === 'string') {
                            try {
                                data = JSON.parse(data);
                            } catch (e) {
                                reject(new Error('JSON解析失败: ' + e.message));
                                return;
                            }
                        }
                        
                        // 如果提供了缓存key，自动保存
                        if (cacheKey) {
                            this.saveToCache(cacheKey, data).catch(e => {
                                console.warn('保存缓存失败:', e);
                            });
                        }
                        
                        resolve(data);
                    } else {
                        reject(new Error(`请求失败，状态码: ${res.statusCode}`));
                    }
                },
                fail: (err) => {
                    console.error('❌ 数据加载失败:', err);
                    reject(err);
                }
            });
        });
    }

    /**
     * 加载省份列表（轻量级，只包含省份基本信息，不包含children）
     * 这是首次加载，数据量很小（< 1MB）
     */
    async loadProvinceList(forceRefresh = false) {
        await this.init();
        
        const cacheKey = 'address_provinces_list';
        
        // 如果不是强制刷新，先尝试从缓存加载
        if (!forceRefresh) {
            const cached = await this.getCachedData(cacheKey);
            if (cached) {
                console.log('✅ 从缓存加载省份列表');
                return cached;
            }
        }

        uni.showLoading({
            title: '加载省份列表...',
            mask: true
        });

        try {
            let data = null;
            
            // 方案1：如果启用了分片接口，尝试从分片接口加载
            if (this.useSplitApi) {
                try {
                    data = await this.fetchData(this.provinceListUrl, cacheKey);
                    if (data && Array.isArray(data) && data.length > 0) {
                        console.log('✅ 从分片接口加载省份列表');
                        return data;
                    }
                } catch (error) {
                    console.warn('⚠️ 分片接口不可用，降级到完整数据提取:', error.message);
                }
            }
            
            // 方案2：从完整数据中提取省份列表（默认方案）
            // 如果完整数据已缓存，提取会很快；如果未缓存，需要加载完整数据
            data = await this.loadProvinceListFromFullData(forceRefresh);
            return data;
        } catch (error) {
            console.error('❌ 加载省份列表失败:', error);
            
            // 如果加载失败，尝试使用缓存（即使已过期）
            if (!forceRefresh) {
                const cached = await this.getCachedData(cacheKey);
                if (cached) {
                    console.log('⚠️ 使用过期缓存数据');
                    return cached;
                }
            }
            
            throw error;
        } finally {
            uni.hideLoading();
        }
    }

    /**
     * 从完整数据中提取省份列表（默认方案）
     * 优化策略：
     * 1. 优先从缓存获取已提取的省份列表（最快）
     * 2. 如果未缓存，尝试从缓存的完整数据中提取（快速）
     * 3. 如果完整数据也未缓存，使用分段加载策略：
     *    - 先尝试只加载前2MB数据来提取省份列表（快速）
     *    - 同时在后台加载完整数据（不阻塞用户）
     */
    async loadProvinceListFromFullData(forceRefresh = false) {
        const cacheKey = 'address_full_data';
        const provinceListCacheKey = 'address_provinces_extracted';
        
        // 先尝试从缓存获取已提取的省份列表
        if (!forceRefresh) {
            const cached = await this.getCachedData(provinceListCacheKey);
            if (cached) {
                console.log('✅ 从缓存加载已提取的省份列表');
                // 如果完整数据未缓存，在后台预加载
                this.preloadFullDataInBackground();
                return cached;
            }
        }
        
        // 尝试从缓存获取完整数据（如果已缓存，提取会很快）
        let fullData = await this.getCachedData(cacheKey);
        
        if (!fullData || forceRefresh) {
            // 如果完整数据未缓存，使用分段加载策略
            console.log('📥 完整数据未缓存，使用分段加载策略...');
            
            // 方案1：尝试分段加载（只加载前2MB来提取省份列表）
            try {
                const provinceList = await this.loadProvinceListFromPartialData();
                if (provinceList && provinceList.length > 0) {
                    console.log('✅ 从部分数据提取省份列表成功');
                    // 缓存提取的省份列表
                    await this.saveToCache(provinceListCacheKey, provinceList, 'province_list');
                    // 在后台预加载完整数据
                    this.preloadFullDataInBackground();
                    return provinceList;
                }
            } catch (error) {
                console.warn('⚠️ 分段加载失败，降级到完整加载:', error.message);
            }
            
            // 方案2：如果分段加载失败，加载完整数据
            console.log('📥 开始加载完整数据...');
            console.log('💡 提示：首次加载需要一些时间，加载后会缓存，后续使用会很快');
            
            uni.showLoading({
                title: '加载地址数据...',
                mask: true
            });
            
            try {
                fullData = await this.fetchData(this.fullDataUrl, cacheKey);
                console.log('✅ 完整数据加载完成，已缓存');
            } finally {
                uni.hideLoading();
            }
        } else {
            console.log('✅ 从缓存提取省份列表（快速）');
        }
        
        // 提取省份列表（只保留基本信息，移除children）
        let provinceList = [];
        if (Array.isArray(fullData)) {
            provinceList = fullData.map(province => ({
                code: province.code,
                name: province.name,
                // 不包含children，减少数据量
                _hasChildren: !!province.children && province.children.length > 0
            }));
            
            // 缓存提取的省份列表
            await this.saveToCache(provinceListCacheKey, provinceList, 'province_list');
        }
        
        return provinceList;
    }

    /**
     * 尝试从部分数据中提取省份列表（只加载前2MB）
     * 这样可以快速显示省份列表，而不需要等待90M数据加载完成
     */
    async loadProvinceListFromPartialData() {
        // 尝试使用Range请求只加载前2MB数据
        const maxBytes = 2 * 1024 * 1024; // 2MB
        
        return new Promise((resolve, reject) => {
            console.log('📥 尝试分段加载（前2MB）...');
            
            // 在H5环境可以使用fetch + Range请求
            // #ifdef H5
            if (typeof fetch !== 'undefined') {
                fetch(this.fullDataUrl, {
                    headers: {
                        'Range': `bytes=0-${maxBytes - 1}`
                    }
                })
                .then(response => {
                    if (response.status === 206 || response.status === 200) {
                        return response.text();
                    } else {
                        throw new Error(`Range请求失败，状态码: ${response.status}`);
                    }
                })
                .then(text => {
                    // 尝试解析部分JSON
                    const provinceList = this.extractProvincesFromPartialJson(text);
                    if (provinceList && provinceList.length > 0) {
                        console.log(`✅ 从部分数据提取到 ${provinceList.length} 个省份`);
                        resolve(provinceList);
                    } else {
                        reject(new Error('无法从部分数据中提取省份列表'));
                    }
                })
                .catch(error => {
                    reject(error);
                });
            } else {
                reject(new Error('当前环境不支持Range请求'));
            }
            // #endif
            
            // #ifndef H5
            // 小程序环境不支持Range请求，直接拒绝
            reject(new Error('小程序环境不支持Range请求，将使用完整加载'));
            // #endif
        });
    }

    /**
     * 从部分JSON字符串中提取省份列表
     * 由于JSON可能不完整，需要智能解析
     */
    extractProvincesFromPartialJson(partialJson) {
        try {
            const provinces = [];
            const seenCodes = new Set();
            
            // 方法1：使用正则表达式提取所有省份（code和name）
            // 匹配模式：{"code":"31","name":"上海市",...} 或 "code":"31","name":"上海市"
            const patterns = [
                // 标准格式：{"code":"31","name":"上海市"}
                /\{\s*"code"\s*:\s*"([^"]+)"\s*,\s*"name"\s*:\s*"([^"]+)"[^}]*\}/g,
                // 简化格式："code":"31","name":"上海市"
                /"code"\s*:\s*"([^"]+)"\s*,\s*"name"\s*:\s*"([^"]+)"/g
            ];
            
            for (const pattern of patterns) {
                let match;
                while ((match = pattern.exec(partialJson)) !== null) {
                    const code = match[1];
                    const name = match[2];
                    
                    // 省份code通常是2位数字（如"31"），或者6位数字（如"310000"）
                    // 根据实际数据结构，code可能是"31"格式
                    if (code && name && !seenCodes.has(code)) {
                        // 判断是否为省份code（2位或6位数字）
                        if ((code.length === 2 && /^\d{2}$/.test(code)) || 
                            (code.length === 6 && /^\d{6}$/.test(code))) {
                            seenCodes.add(code);
                            provinces.push({
                                code: code,
                                name: name,
                                _hasChildren: true // 假设都有下级
                            });
                        }
                    }
                }
            }
            
            // 方法2：如果正则提取失败，尝试解析JSON（可能不完整）
            if (provinces.length === 0) {
                try {
                    // 尝试修复不完整的JSON
                    let jsonStr = partialJson.trim();
                    
                    // 如果以[开头，尝试找到所有完整的省份对象
                    if (jsonStr.startsWith('[')) {
                        // 查找所有省份对象的开始位置
                        let pos = 1; // 跳过开头的[
                        while (pos < jsonStr.length) {
                            // 找到下一个{的位置
                            const objStart = jsonStr.indexOf('{', pos);
                            if (objStart === -1) break;
                            
                            // 尝试找到这个对象的结束位置（简单的匹配）
                            let braceCount = 0;
                            let objEnd = objStart;
                            for (let i = objStart; i < jsonStr.length; i++) {
                                if (jsonStr[i] === '{') braceCount++;
                                if (jsonStr[i] === '}') braceCount--;
                                if (braceCount === 0) {
                                    objEnd = i + 1;
                                    break;
                                }
                            }
                            
                            if (objEnd > objStart) {
                                const objStr = jsonStr.substring(objStart, objEnd);
                                try {
                                    const obj = JSON.parse(objStr);
                                    if (obj.code && obj.name && !seenCodes.has(obj.code)) {
                                        seenCodes.add(obj.code);
                                        provinces.push({
                                            code: obj.code,
                                            name: obj.name,
                                            _hasChildren: true
                                        });
                                    }
                                } catch (e) {
                                    // 解析失败，继续下一个
                                }
                            }
                            
                            pos = objEnd;
                        }
                    }
                } catch (e) {
                    // 解析失败，忽略
                }
            }
            
            // 去重并排序
            const uniqueProvinces = Array.from(new Map(provinces.map(p => [p.code, p])).values());
            
            return uniqueProvinces.length > 0 ? uniqueProvinces : null;
        } catch (error) {
            console.warn('从部分JSON提取省份列表失败:', error);
            return null;
        }
    }

    /**
     * 在后台预加载完整数据（不阻塞用户操作）
     */
    async preloadFullDataInBackground() {
        const cacheKey = 'address_full_data';
        
        // 检查是否已缓存
        const cached = await this.getCachedData(cacheKey);
        if (cached) {
            console.log('✅ 完整数据已缓存，无需预加载');
            return;
        }
        
        console.log('🔄 开始在后台预加载完整数据...');
        
        // 使用setTimeout让出主线程，避免阻塞
        setTimeout(async () => {
            try {
                await this.fetchData(this.fullDataUrl, cacheKey);
                console.log('✅ 后台预加载完成，完整数据已缓存');
            } catch (error) {
                console.warn('⚠️ 后台预加载失败:', error);
            }
        }, 100);
    }

    /**
     * 加载省份详情（包含该省份的所有下级数据）
     * 按需加载，只有用户选择该省份时才加载
     */
    async loadProvinceDetail(provinceCode, forceRefresh = false) {
        await this.init();
        
        const cacheKey = `address_province_${provinceCode}`;
        
        // 如果不是强制刷新，先尝试从缓存加载
        if (!forceRefresh) {
            const cached = await this.getCachedData(cacheKey);
            if (cached) {
                console.log(`✅ 从缓存加载省份详情: ${provinceCode}`);
                return cached;
            }
        }

        uni.showLoading({
            title: '加载城市数据...',
            mask: true
        });

        try {
            let data = null;
            
            // 方案1：如果启用了分片接口，尝试从分片接口加载
            if (this.useSplitApi) {
                try {
                    const url = this.provinceDetailUrl.replace('{code}', provinceCode);
                    data = await this.fetchData(url, cacheKey);
                    if (data && data.code === provinceCode) {
                        console.log(`✅ 从分片接口加载省份详情: ${provinceCode}`);
                        return data;
                    }
                } catch (error) {
                    console.warn(`⚠️ 分片接口不可用，降级到完整数据提取: ${error.message}`);
                }
            }
            
            // 方案2：从完整数据中提取省份详情（默认方案）
            data = await this.loadProvinceDetailFromFullData(provinceCode, forceRefresh);
            return data;
        } catch (error) {
            console.error(`❌ 加载省份详情失败: ${provinceCode}`, error);
            
            // 如果加载失败，尝试使用缓存
            if (!forceRefresh) {
                const cached = await this.getCachedData(cacheKey);
                if (cached) {
                    console.log('⚠️ 使用过期缓存数据');
                    return cached;
                }
            }
            
            throw error;
        } finally {
            uni.hideLoading();
        }
    }

    /**
     * 从完整数据中提取省份详情（默认方案）
     * 如果完整数据已缓存，提取会很快
     */
    async loadProvinceDetailFromFullData(provinceCode, forceRefresh = false) {
        const cacheKey = 'address_full_data';
        
        // 先尝试从缓存获取完整数据（如果已缓存，提取会很快）
        let fullData = await this.getCachedData(cacheKey);
        
        if (!fullData || forceRefresh) {
            // 如果完整数据未缓存，需要加载完整数据
            console.log(`📥 完整数据未缓存，开始加载完整数据以获取省份 ${provinceCode}...`);
            
            uni.showLoading({
                title: '加载地址数据...',
                mask: true
            });
            
            try {
                fullData = await this.fetchData(this.fullDataUrl, cacheKey);
                console.log('✅ 完整数据加载完成，已缓存');
            } finally {
                uni.hideLoading();
            }
        } else {
            console.log(`✅ 从缓存提取省份详情: ${provinceCode}（快速）`);
        }
        
        // 查找并返回指定省份的完整数据
        // 注意：根据实际数据结构，code可能是"31"格式，需要精确匹配
        if (Array.isArray(fullData)) {
            const province = fullData.find(p => p.code === provinceCode || p.code === String(provinceCode));
            if (province) {
                return province;
            } else {
                console.warn(`⚠️ 未找到省份: ${provinceCode}`);
                return null;
            }
        }
        
        return null;
    }

    /**
     * 清除缓存
     */
    async clearCache() {
        await this.init();
        
        try {
            if (this.dbHelper) {
                await this.dbHelper.clearStore(this.storeName);
            }
            // 清除 uni.storage
            const keys = uni.getStorageInfoSync().keys;
            keys.forEach(key => {
                if (key.startsWith('address_')) {
                    uni.removeStorageSync(key);
                }
            });
            // 清除内存缓存
            this.memoryCache.clear();
            console.log('✅ 已清除所有地址数据缓存');
        } catch (e) {
            console.error('清除缓存失败:', e);
        }
    }

    /**
     * 清除旧缓存
     */
    async clearOldCache() {
        try {
            // 清除7天前的缓存
            const expireTime = this.cacheExpireDays * 24 * 60 * 60 * 1000;
            const now = Date.now();
            
            if (this.dbHelper) {
                const allData = await this.dbHelper.getAll(this.storeName);
                for (const item of allData) {
                    if (item.updateTime && (now - item.updateTime) > expireTime) {
                        await this.dbHelper.delete(this.storeName, item.key);
                    }
                }
            }
        } catch (e) {
            console.warn('清理旧缓存失败:', e);
        }
    }
}

// 单例模式
const addressDataLoaderLazy = new AddressDataLoaderLazy();

export default addressDataLoaderLazy;