// 写入单个值
await chrome.storage.local.set({ key: 'value' });

// 写入多个值
await chrome.storage.local.set({
  username: 'user123',
  theme: 'dark',
  settings: {
    notifications: true,
    fontSize: 14
  },
  recentItems: [1, 2, 3, 4, 5]
});

// sync 存储
await chrome.storage.sync.set({ preferredLanguage: 'zh-CN' });

// session 存储
await chrome.storage.session.set({ currentPage: 1 });

// 读取单个值
const result = await chrome.storage.local.get('username');
console.log(result.username); // 'user123'

// 读取多个值
const data = await chrome.storage.local.get(['theme', 'settings']);
console.log(data.theme);    // 'dark'
console.log(data.settings); // { notifications: true, fontSize: 14 }

// 读取全部数据
const allData = await chrome.storage.local.get(null);
console.log(allData); // { username: '...', theme: '...', ... }

// 带默认值的读取
async function getWithDefault(key, defaultValue) {
  const result = await chrome.storage.local.get(key);
  return result[key] ?? defaultValue;
}

const theme = await getWithDefault('theme', 'light');

// 删除单个键
await chrome.storage.local.remove('username');

// 删除多个键
await chrome.storage.local.remove(['theme', 'settings']);

// 清空整个存储区域
await chrome.storage.local.clear();

// 获取已用字节数
const localBytes = await chrome.storage.local.getBytesInUse();
console.log(`local 已用: ${localBytes} / ${10 * 1024 * 1024} bytes`);

// 获取特定键的字节数
const themeBytes = await chrome.storage.local.getBytesInUse('theme');
console.log(`theme 占用: ${themeBytes} bytes`);

// sync 存储
const syncBytes = await chrome.storage.sync.getBytesInUse();
console.log(`sync 已用: ${syncBytes} / ${100 * 1024} bytes`);

// 监听所有存储区域的变化
chrome.storage.onChanged.addListener((changes, areaName) => {
  console.log(`存储区域 "${areaName}" 发生变化:`);

  for (const [key, { oldValue, newValue }] of Object.entries(changes)) {
    console.log(`  ${key}: ${JSON.stringify(oldValue)} → ${JSON.stringify(newValue)}`);
  }
});

// 只监听特定区域
chrome.storage.onChanged.addListener((changes, areaName) => {
  if (areaName !== 'sync') return;

  if (changes.theme) {
    applyTheme(changes.theme.newValue);
  }

  if (changes.fontSize) {
    document.documentElement.style.fontSize = changes.fontSize.newValue + 'px';
  }
});

// background/service-worker.js

chrome.storage.onChanged.addListener(async (changes, areaName) => {
  // 通知所有打开的 UI 页面
  const views = chrome.runtime.getContexts({
    contextTypes: ['POPUP', 'SIDE_PANEL', 'TAB']
  });

  for (const view of views) {
    try {
      await chrome.tabs.sendMessage(view.tabId || 0, {
        type: 'STORAGE_CHANGED',
        changes,
        areaName
      });
    } catch (e) {
      // 页面可能已关闭
    }
  }
});

// lib/storage.js

class TypedStorage {
  constructor(area = 'local') {
    this.area = chrome.storage[area];
    this.validators = new Map();
  }

  // 注册键的类型验证器
  register(key, validator, defaultValue) {
    this.validators.set(key, { validator, defaultValue });
    return this;
  }

  async get(key) {
    const result = await this.area.get(key);
    const config = this.validators.get(key);

    if (result[key] === undefined && config) {
      return config.defaultValue;
    }

    return result[key];
  }

  async set(key, value) {
    const config = this.validators.get(key);
    if (config && !config.validator(value)) {
      throw new Error(`Validation failed for key "${key}"`);
    }

    await this.area.set({ [key]: value });
  }

  async getMultiple(keys) {
    const result = await this.area.get(keys);
    const config = this.validators;

    for (const key of keys) {
      if (result[key] === undefined && config.has(key)) {
        result[key] = config.get(key).defaultValue;
      }
    }

    return result;
  }
}

// 使用示例
const storage = new TypedStorage('local')
  .register('theme', v => ['light', 'dark', 'system'].includes(v), 'system')
  .register('fontSize', v => typeof v === 'number' && v >= 12 && v <= 24, 14)
  .register('username', v => typeof v === 'string' && v.length > 0, '');

// 类型安全的读写
await storage.set('theme', 'dark');       // ✅
await storage.set('theme', 'invalid');    // ❌ 抛出错误
const theme = await storage.get('theme'); // 'dark'

// lib/cache.js

class CacheStorage {
  constructor(ttl = 3600000) { // 默认 1 小时
    this.ttl = ttl;
  }

  async set(key, value, ttl = this.ttl) {
    const entry = {
      value,
      expiresAt: Date.now() + ttl
    };
    await chrome.storage.local.set({ [key]: entry });
  }

  async get(key) {
    const result = await chrome.storage.local.get(key);
    const entry = result[key];

    if (!entry) return undefined;

    if (Date.now() > entry.expiresAt) {
      await chrome.storage.local.remove(key);
      return undefined; // 已过期
    }

    return entry.value;
  }

  async has(key) {
    return (await this.get(key)) !== undefined;
  }

  async clear() {
    const all = await chrome.storage.local.get(null);
    const keys = Object.keys(all);
    await chrome.storage.local.remove(keys);
  }

  // 清理过期缓存
  async cleanup() {
    const all = await chrome.storage.local.get(null);
    const now = Date.now();
    const expiredKeys = [];

    for (const [key, entry] of Object.entries(all)) {
      if (entry?.expiresAt && now > entry.expiresAt) {
        expiredKeys.push(key);
      }
    }

    if (expiredKeys.length > 0) {
      await chrome.storage.local.remove(expiredKeys);
    }

    return expiredKeys.length;
  }
}

// 使用示例
const cache = new CacheStorage(30 * 60 * 1000); // 30 分钟 TTL

// 缓存 API 响应
async function fetchWithCache(url) {
  const cacheKey = `cache:${url}`;

  let data = await cache.get(cacheKey);
  if (data) return data; // 命中缓存

  const response = await fetch(url);
  data = await response.json();
  await cache.set(cacheKey, data);

  return data;
}

// lib/migration.js

class StorageMigration {
  constructor(storageKey = 'dbVersion') {
    this.storageKey = storageKey;
    this.migrations = [];
  }

  addMigration(version, migrateFn) {
    this.migrations.push({ version, migrateFn });
    this.migrations.sort((a, b) => a.version - b.version);
    return this;
  }

  async run() {
    const { [this.storageKey]: currentVersion = 0 } =
      await chrome.storage.local.get(this.storageKey);

    const pending = this.migrations.filter(m => m.version > currentVersion);

    if (pending.length === 0) {
      console.log('无需迁移');
      return;
    }

    for (const migration of pending) {
      console.log(`执行迁移 v${migration.version}...`);
      try {
        await migration.migrateFn();
        await chrome.storage.local.set({
          [this.storageKey]: migration.version
        });
      } catch (error) {
        console.error(`迁移 v${migration.version} 失败:`, error);
        throw error;
      }
    }

    console.log('迁移完成');
  }
}

// 使用示例
const migrator = new StorageMigration();

migrator
  .addMigration(1, async () => {
    // v1: 将 settings 从 flat 结构改为嵌套结构
    const { theme, fontSize } = await chrome.storage.local.get(
      ['theme', 'fontSize']
    );
    await chrome.storage.local.set({
      settings: { theme: theme || 'light', fontSize: fontSize || 14 }
    });
    await chrome.storage.local.remove(['theme', 'fontSize']);
  })
  .addMigration(2, async () => {
    // v2: 添加 bookmarks 字段
    const { bookmarks } = await chrome.storage.local.get('bookmarks');
    if (!bookmarks) {
      await chrome.storage.local.set({ bookmarks: [] });
    }
  });

// Service Worker 安装时执行迁移
chrome.runtime.onInstalled.addListener(async () => {
  await migrator.run();
});

// content/auto-save.js

class FormAutoSave {
  constructor() {
    this.debounceTimer = null;
    this.init();
  }

  init() {
    document.querySelectorAll('textarea, input[type="text"]').forEach(input => {
      this.restoreValue(input);
      input.addEventListener('input', () => this.saveValue(input));
    });
  }

  getElementKey(element) {
    return `autosave:${window.location.pathname}:${element.name || element.id}`;
  }

  async saveValue(element) {
    clearTimeout(this.debounceTimer);
    this.debounceTimer = setTimeout(async () => {
      const key = this.getElementKey(element);
      await chrome.storage.session.set({ [key]: element.value });
    }, 500);
  }

  async restoreValue(element) {
    const key = this.getElementKey(element);
    const result = await chrome.storage.session.get(key);
    if (result[key] && !element.value) {
      element.value = result[key];
    }
  }
}

new FormAutoSave();

// background/stats.js

class BrowsingStats {
  async recordVisit(url, title) {
    const { visits = {} } = await chrome.storage.local.get('visits');

    const domain = new URL(url).hostname;

    if (!visits[domain]) {
      visits[domain] = { count: 0, lastVisit: null, pages: {} };
    }

    visits[domain].count++;
    visits[domain].lastVisit = Date.now();

    if (!visits[domain].pages[url]) {
      visits[domain].pages[url] = { title, count: 0 };
    }
    visits[domain].pages[url].count++;

    await chrome.storage.local.set({ visits });
  }

  async getTopDomains(limit = 10) {
    const { visits = {} } = await chrome.storage.local.get('visits');

    return Object.entries(visits)
      .sort(([, a], [, b]) => b.count - a.count)
      .slice(0, limit)
      .map(([domain, data]) => ({
        domain,
        count: data.count,
        lastVisit: data.lastVisit
      }));
  }
}