/**
 * 存储相关工具函数
 */
const cloud = require('./cloud');
const eventManager = require('./eventManager');

// 存储键常量
const STORAGE_KEY = 'tokens';

/**
 * 从本地存储获取所有令牌
 * @returns {Promise<Array>} 令牌列表
 */
const getTokens = () => {
  return new Promise((resolve, reject) => {
    wx.getStorage({
      key: STORAGE_KEY,
      success: (res) => resolve(res.data || []),
      fail: (err) => {
        if (err.errMsg.includes('data not found')) {
          resolve([]);
        } else {
          reject(err);
        }
      }
    });
  });
};

/**
 * 保存令牌数组到本地存储
 * @param {Array} tokens - 令牌数组
 * @returns {Promise<void>} 异步操作结果
 */
const saveTokens = (tokens) => {
  return new Promise((resolve, reject) => {
    wx.setStorage({
      key: STORAGE_KEY,
      data: tokens,
      success: () => resolve(),
      fail: (err) => reject(err)
    });
  });
};

/**
 * 添加令牌到本地存储
 * @param {Object} tokenData - 令牌数据对象
 * @returns {Promise<void>} 异步操作结果
 */
const addToken = async (tokenData) => {
  try {
    const tokens = await getTokens();
    tokens.push(tokenData);
    await saveTokens(tokens);
    eventManager.emit('tokensUpdated', tokens);
  } catch (error) {
    throw error;
  }
};

/**
 * 更新令牌信息
 * @param {string} tokenId - 令牌ID
 * @param {Object} updates - 要更新的字段
 * @returns {Promise<void>} 异步操作结果
 */
const updateToken = async (tokenId, updates) => {
  try {
    const tokens = await getTokens();
    const index = tokens.findIndex(t => t.id === tokenId);
    
    if (index === -1) {
      throw new Error('令牌不存在');
    }
    
    tokens[index] = { ...tokens[index], ...updates };
    await saveTokens(tokens);
  } catch (error) {
    throw error;
  }
};

/**
 * 删除令牌
 * @param {string} tokenId - 令牌ID
 * @returns {Promise<void>} 异步操作结果
 */
const deleteToken = async (tokenId) => {
  try {
    const tokens = await getTokens();
    const newTokens = tokens.filter(t => t.id !== tokenId);
    await saveTokens(newTokens);
  } catch (error) {
    throw error;
  }
};

/**
 * 备份令牌到云端
 * @returns {Promise<string>} 云端数据ID
 */
const backupToCloud = async () => {
  try {
    const tokens = await getTokens();
    return await cloud.uploadTokens(tokens);
  } catch (error) {
    throw error;
  }
};

/**
 * 从云端恢复令牌
 * @param {Object} options - 恢复选项
 * @param {boolean} [options.merge=false] - 是否合并数据而不是覆盖
 * @param {boolean} [options.preferCloud=true] - 合并时是否优先使用云端数据
 * @returns {Promise<void>} 异步操作结果
 */
const restoreFromCloud = async (options = { merge: false, preferCloud: true }) => {
  try {
    const cloudData = await cloud.fetchLatestTokens();
    const cloudTokens = cloudData.tokens;

    if (options.merge) {
      const localTokens = await getTokens();
      const mergedTokens = cloud.mergeTokens(localTokens, cloudTokens, {
        preferCloud: options.preferCloud
      });
      await saveTokens(mergedTokens);
    } else {
      await saveTokens(cloudTokens);
    }
  } catch (error) {
    throw error;
  }
};

module.exports = {
  getTokens,
  addToken,
  updateToken,
  deleteToken,
  backupToCloud,
  restoreFromCloud
};