{
  "permissions": [
    "storage",
    "contextMenus",
    "alarms",
    "sidePanel",
    "activeTab",
    "scripting"
  ],

  "optional_permissions": [
    "tabs",
    "bookmarks",
    "history",
    "cookies",
    "downloads",
    "notifications"
  ],

  "host_permissions": [
    "*://*.example.com/*",
    "*://api.example.com/*"
  ],

  "optional_host_permissions": [
    "*://*/*"
  ]
}

// 用户点击扩展图标时，获得 activeTab 权限
chrome.action.onClicked.addListener(async (tab) => {
  // 此时可以注入脚本到当前标签页
  await chrome.scripting.executeScript({
    target: { tabId: tab.id },
    func: () => {
      document.body.style.border = '3px solid red';
    }
  });

  // 可以获取标签页的详细信息
  console.log('URL:', tab.url);
  console.log('Title:', tab.title);
});

// 请求可选权限
async function requestPermission(permission) {
  try {
    const granted = await chrome.permissions.request({
      permissions: [permission]
    });

    if (granted) {
      console.log(`权限 ${permission} 已授予`);
      return true;
    } else {
      console.log(`权限 ${permission} 被拒绝`);
      return false;
    }
  } catch (error) {
    console.error('申请权限失败:', error);
    return false;
  }
}

// 请求主机权限
async function requestHostPermission(hostPattern) {
  try {
    const granted = await chrome.permissions.request({
      origins: [hostPattern]
    });
    return granted;
  } catch (error) {
    console.error('申请主机权限失败:', error);
    return false;
  }
}

// 检查是否拥有某个权限
async function hasPermission(permission) {
  return await chrome.permissions.contains({
    permissions: [permission]
  });
}

// 检查主机权限
async function hasHostPermission(hostPattern) {
  return await chrome.permissions.contains({
    origins: [hostPattern]
  });
}

// 使用示例
async function showBookmarks() {
  const hasBookmarks = await hasPermission('bookmarks');

  if (!hasBookmarks) {
    const granted = await requestPermission('bookmarks');
    if (!granted) {
      showToast('需要书签权限才能使用此功能');
      return;
    }
  }

  // 现在可以安全使用 bookmarks API
  const bookmarks = await chrome.bookmarks.getRecent(10);
  renderBookmarks(bookmarks);
}

// 在 Options 页面中展示权限状态
class PermissionsPanel {
  constructor(container) {
    this.container = container;
    this.permissions = [
      { name: 'bookmarks', label: '书签', desc: '读取和管理书签' },
      { name: 'history', label: '历史记录', desc: '读取浏览历史' },
      { name: 'tabs', label: '标签页', desc: '访问标签页信息' },
      { name: 'cookies', label: 'Cookie', desc: '读写网站 Cookie' },
      { name: 'notifications', label: '通知', desc: '显示桌面通知' }
    ];
  }

  async render() {
    const html = [];

    for (const perm of this.permissions) {
      const has = await chrome.permissions.contains({
        permissions: [perm.name]
      });

      html.push(`
        <div class="permission-item">
          <div class="permission-info">
            <span class="permission-label">${perm.label}</span>
            <span class="permission-desc">${perm.desc}</span>
          </div>
          <label class="toggle-switch">
            <input type="checkbox" data-permission="${perm.name}"
                   ${has ? 'checked' : ''}>
            <span class="slider"></span>
          </label>
        </div>
      `);
    }

    this.container.innerHTML = html.join('');

    // 绑定切换事件
    this.container.querySelectorAll('input[type="checkbox"]')
      .forEach(input => {
      input.addEventListener('change', (e) => {
        this.togglePermission(e.target.dataset.permission, e.target.checked);
      });
    });
  }

  async togglePermission(permission, enable) {
    if (enable) {
      const granted = await chrome.permissions.request({
        permissions: [permission]
      });
      if (!granted) {
        // 用户拒绝，恢复开关状态
        this.render();
      }
    } else {
      await chrome.permissions.remove({
        permissions: [permission]
      });
    }
  }
}

// lib/feature-gates.js

class FeatureGate {
  static features = {
    autoLogin: {
      requiredPermissions: ['cookies'],
      requiredHosts: ['*://accounts.google.com/*'],
      description: '自动登录功能'
    },
    historySearch: {
      requiredPermissions: ['history'],
      description: '历史记录搜索'
    },
    bookmarkSync: {
      requiredPermissions: ['bookmarks'],
      description: '书签同步'
    },
    downloadManager: {
      requiredPermissions: ['downloads'],
      description: '下载管理'
    }
  };

  static async check(featureName) {
    const feature = this.features[featureName];
    if (!feature) throw new Error(`Unknown feature: ${featureName}`);

    const required = {};
    if (feature.requiredPermissions) {
      required.permissions = feature.requiredPermissions;
    }
    if (feature.requiredHosts) {
      required.origins = feature.requiredHosts;
    }

    return await chrome.permissions.contains(required);
  }

  static async ensure(featureName) {
    const has = await this.check(featureName);
    if (has) return true;

    const feature = this.features[featureName];
    const request = {};
    if (feature.requiredPermissions) {
      request.permissions = feature.requiredPermissions;
    }
    if (feature.requiredHosts) {
      request.origins = feature.requiredHosts;
    }

    try {
      return await chrome.permissions.request(request);
    } catch {
      return false;
    }
  }
}

// 使用
if (await FeatureGate.ensure('historySearch')) {
  const results = await chrome.history.search({ text: query });
  renderHistory(results);
}

// 监听权限授予
chrome.permissions.onAdded.addListener((permissions) => {
  console.log('新增权限:', permissions);
  // permissions.permissions — 新增的 API 权限列表
  // permissions.origins — 新增的主机权限列表
});

// 监听权限移除
chrome.permissions.onRemoved.addListener((permissions) => {
  console.log('移除权限:', permissions);
  // 禁用对应功能
  disableFeaturesRequiring(permissions);
});

function disableFeaturesRequiring(permissions) {
  if (permissions.permissions?.includes('bookmarks')) {
    document.getElementById('bookmarkFeature')?.classList.add('disabled');
  }
  if (permissions.permissions?.includes('history')) {
    document.getElementById('historyFeature')?.classList.add('disabled');
  }
}

// 场景：网页剪藏工具
{
  "permissions": ["storage", "activeTab", "contextMenus", "scripting"],
  "optional_permissions": ["tabs", "downloads"],
  "optional_host_permissions": ["<all_urls>"]
}

// 场景：密码管理器
{
  "permissions": ["storage", "tabs", "activeTab", "scripting", "notifications"],
  "host_permissions": ["<all_urls>"],
  "optional_permissions": ["cookies", "webRequest"]
}

// 场景：广告拦截器
{
  "permissions": [
    "storage", "declarativeNetRequest",
    "declarativeNetRequestWithHostAccess"
  ],
  "host_permissions": ["<all_urls>"]
}