{
  "permissions": [
    "declarativeNetRequest",
    "declarativeNetRequestWithHostAccess"
  ],
  "host_permissions": [
    "*://*.example.com/*"
  ]
}

{
  "declarative_net_request": {
    "rule_resources": [
      {
        "id": "block_ads",
        "enabled": true,
        "path": "rules/block-ads.json"
      },
      {
        "id": "redirect_tracker",
        "enabled": false,
        "path": "rules/redirect-trackers.json"
      }
    ]
  }
}

[
  {
    "id": 1,
    "priority": 1,
    "action": {
      "type": "block"
    },
    "condition": {
      "urlFilter": "||ads.example.com",
      "resourceTypes": ["script", "image", "xmlhttprequest", "sub_frame"]
    }
  },
  {
    "id": 2,
    "priority": 1,
    "action": {
      "type": "redirect",
      "redirect": {
        "url": "https://example.com/tracker-pixel.gif"
      }
    },
    "condition": {
      "urlFilter": "||tracker.example.com/pixel",
      "resourceTypes": ["image"]
    }
  },
  {
    "id": 3,
    "priority": 1,
    "action": {
      "type": "modifyHeaders",
      "requestHeaders": [
        {
          "header": "Referer",
          "operation": "remove"
        }
      ]
    },
    "condition": {
      "urlFilter": "||api.example.com",
      "resourceTypes": ["xmlhttprequest"]
    }
  },
  {
    "id": 4,
    "priority": 2,
    "action": {
      "type": "allow"
    },
    "condition": {
      "urlFilter": "||safe-ads.example.com",
      "resourceTypes": ["script"]
    }
  }
]

{
  "condition": {
    "urlFilter": "||example.com",
    "regexFilter": "https://api\\.example\\.com/v[0-9]+/.*",
    "resourceTypes": ["script", "image", "stylesheet"],
    "excludedResourceTypes": ["main_frame"],
    "domains": ["example.com"],
    "excludedDomains": ["safe.example.com"],
    "initiatorDomains": ["myapp.com"],
    "tabIds": [1, 2, 3],
    "excludedTabIds": [4],
    "isUrlFilterCaseSensitive": false,
    "requestMethods": ["get", "post"],
    "requestHeaders": [
      {
        "header": "Content-Type",
        "values": ["application/json"]
      }
    ]
  }
}

// 添加动态规则
async function addBlockingRule() {
  await chrome.declarativeNetRequest.updateDynamicRules({
    addRules: [
      {
        id: 1001,
        priority: 1,
        action: { type: 'block' },
        condition: {
          urlFilter: '||new-tracker.com',
          resourceTypes: ['script', 'xmlhttprequest']
        }
      }
    ],
    removeRuleIds: [1001] // 先移除同 ID 的旧规则
  });
}

// 删除动态规则
async function removeBlockingRule() {
  await chrome.declarativeNetRequest.updateDynamicRules({
    removeRuleIds: [1001]
  });
}

// 获取当前规则
async function listRules() {
  const rules = await chrome.declarativeNetRequest.getDynamicRules();
  console.log('动态规则:', rules);

  const sessionRules = await chrome.declarativeNetRequest.getSessionRules();
  console.log('会话规则:', sessionRules);
}

// 更新静态规则集状态
async function toggleRuleset(rulesetId, enabled) {
  const rulesets = await chrome.declarativeNetRequest.getEnabledRulesets();
  await chrome.declarativeNetRequest.updateEnabledRulesets({
    enableRulesetIds: enabled ? [rulesetId] : [],
    disableRulesetIds: enabled ? [] : [rulesetId]
  });
}

// 会话规则仅在当前浏览器会话中有效，不会持久化
await chrome.declarativeNetRequest.updateSessionRules({
  addRules: [{
    id: 5001,
    priority: 1,
    action: { type: 'block' },
    condition: {
      urlFilter: '||temp-block.com',
      resourceTypes: ['script']
    }
  }],
  removeRuleIds: []
});

[
  {
    "id": 100,
    "priority": 1,
    "action": {
      "type": "modifyHeaders",
      "requestHeaders": [
        { "header": "X-Custom-Header", "operation": "set", "value": "my-value" },
        { "header": "Referer", "operation": "remove" }
      ],
      "responseHeaders": [
        { "header": "X-Frame-Options", "operation": "remove" },
        { "header": "Access-Control-Allow-Origin", "operation": "set", "value": "*" }
      ]
    },
    "condition": {
      "urlFilter": "||api.example.com",
      "resourceTypes": ["xmlhttprequest"]
    }
  }
]

// 监听导航事件
chrome.webNavigation.onBeforeNavigate.addListener((details) => {
  console.log(`即将导航: ${details.url} (标签页: ${details.tabId})`);
});

chrome.webNavigation.onCompleted.addListener((details) => {
  if (details.frameId === 0) { // 主框架
    console.log(`页面加载完成: ${details.url}`);
  }
});

// 监听子框架加载
chrome.webNavigation.onDOMContentLoaded.addListener((details) => {
  if (details.frameId !== 0) {
    console.log(`iframe 加载: ${details.url}`);
  }
});

// 检测 SPA 导航
chrome.webNavigation.onHistoryStateUpdated.addListener((details) => {
  console.log(`SPA URL 变化: ${details.url}`);
});

// 基本请求
async function fetchJSON(url, options = {}) {
  const response = await fetch(url, {
    headers: {
      'Content-Type': 'application/json',
      ...options.headers
    },
    ...options
  });

  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
  }

  return response.json();
}

// 带重试的请求
async function fetchWithRetry(url, options = {}, maxRetries = 3) {
  let lastError;

  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fetchJSON(url, options);
    } catch (error) {
      lastError = error;
      await new Promise(r => setTimeout(r, 1000 * (i + 1)));
    }
  }

  throw lastError;
}

// 并发请求
async function fetchMultiple(urls) {
  const results = await Promise.allSettled(
    urls.map(url => fetchJSON(url))
  );

  return results.map((result, i) => ({
    url: urls[i],
    success: result.status === 'fulfilled',
    data: result.status === 'fulfilled' ? result.value : null,
    error: result.status === 'rejected' ? result.reason.message : null
  }));
}

// 取消请求（AbortController）
async function fetchWithTimeout(url, timeout = 5000) {
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), timeout);

  try {
    const response = await fetch(url, { signal: controller.signal });
    clearTimeout(timeoutId);
    return response;
  } catch (error) {
    clearTimeout(timeoutId);
    if (error.name === 'AbortError') {
      throw new Error('请求超时');
    }
    throw error;
  }
}

// Service Worker 中代理 API 请求，自动添加认证头
async function authenticatedFetch(url, options = {}) {
  const { apiToken } = await chrome.storage.local.get('apiToken');

  if (!apiToken) {
    throw new Error('未登录');
  }

  return fetch(url, {
    ...options,
    headers: {
      ...options.headers,
      'Authorization': `Bearer ${apiToken}`,
      'X-Extension-Version': chrome.runtime.getManifest().version
    }
  });
}

// 监听 Content Script 的 API 请求
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  if (message.type === 'API_REQUEST') {
    authenticatedFetch(message.url, message.options)
      .then(res => res.json())
      .then(data => sendResponse({ success: true, data }))
      .catch(err => sendResponse({ success: false, error: err.message }));
    return true;
  }
});

// 动态添加拦截规则
async function addCustomBlockRule(domain) {
  const existingRules = await chrome.declarativeNetRequest.getDynamicRules();
  const maxId = Math.max(0, ...existingRules.map(r => r.id));

  await chrome.declarativeNetRequest.updateDynamicRules({
    addRules: [{
      id: maxId + 1,
      priority: 1,
      action: { type: 'block' },
      condition: {
        urlFilter: `||${domain}`,
        resourceTypes: [
          'script', 'image', 'sub_frame',
          'xmlhttprequest', 'media'
        ]
      }
    }],
    removeRuleIds: []
  });
}

// 从规则文件批量导入
async function importRulesFromURL(url) {
  const response = await fetch(url);
  const rules = await response.json();

  const maxId = Math.max(
    0,
    ...rules.map(r => r.id)
  );

  await chrome.declarativeNetRequest.updateDynamicRules({
    addRules: rules.map((rule, i) => ({
      ...rule,
      id: maxId + i + 1
    })),
    removeRuleIds: []
  });
}