interface Rule {
  id: number;              // Unique within its source (static/dynamic/session)
  priority?: number;       // Default: 1. Higher number = higher priority.
  action: RuleAction;
  condition: RuleCondition;
}

interface RuleAction {
  type: "block" | "redirect" | "allow" | "upgradeScheme"
      | "modifyHeaders" | "allowAllRequests";
  redirect?: {
    url?: string;               // Absolute redirect URL
    extensionPath?: string;     // Path within the extension (e.g., "/blocked.html")
    regexSubstitution?: string; // Substitution using capture groups from regexFilter
    transform?: URLTransform;   // Modify parts of the URL
  };
  requestHeaders?: ModifyHeaderInfo[];   // For modifyHeaders
  responseHeaders?: ModifyHeaderInfo[];  // For modifyHeaders
}

interface ModifyHeaderInfo {
  header: string;
  operation: "append" | "set" | "remove";
  value?: string;  // Required for "append" and "set"
}

interface RuleCondition {
  urlFilter?: string;           // Match pattern with wildcards (* and |)
  regexFilter?: string;         // RE2 regular expression (mutually exclusive with urlFilter)
  resourceTypes?: ResourceType[];
  excludedResourceTypes?: ResourceType[];
  initiatorDomains?: string[];
  excludedInitiatorDomains?: string[];
  requestDomains?: string[];
  excludedRequestDomains?: string[];
  requestMethods?: string[];         // "get", "post", "put", etc.
  excludedRequestMethods?: string[];
  domainType?: "firstParty" | "thirdParty";
  isUrlFilterCaseSensitive?: boolean;   // Default: false
  tabIds?: number[];
  excludedTabIds?: number[];
}

type ResourceType =
  | "main_frame" | "sub_frame" | "stylesheet" | "script"
  | "image" | "font" | "object" | "xmlhttprequest" | "ping"
  | "csp_report" | "media" | "websocket" | "webtransport"
  | "webbundle" | "other";

function updateDynamicRules(options: {
  addRules?: Rule[];
  removeRuleIds?: number[];
}): Promise<void>;

await chrome.declarativeNetRequest.updateDynamicRules({
  addRules: [{
    id: 1, priority: 1,
    action: { type: "block" },
    condition: { urlFilter: "||ads.example.com", resourceTypes: ["script", "image"] },
  }],
});

// Replace a rule (remove then add in one call)
await chrome.declarativeNetRequest.updateDynamicRules({
  removeRuleIds: [1],
  addRules: [{
    id: 1, priority: 2,
    action: { type: "block" },
    condition: { urlFilter: "||ads.example.com", resourceTypes: ["script", "image", "xmlhttprequest"] },
  }],
});

function updateSessionRules(options: {
  addRules?: Rule[];
  removeRuleIds?: number[];
}): Promise<void>;

function getDynamicRules(filter?: { ruleIds?: number[] }): Promise<Rule[]>;

const allDynamic = await chrome.declarativeNetRequest.getDynamicRules();
const specific = await chrome.declarativeNetRequest.getDynamicRules({ ruleIds: [1, 2] });

function getSessionRules(filter?: { ruleIds?: number[] }): Promise<Rule[]>;

function updateEnabledRulesets(options: {
  enableRulesetIds?: string[];
  disableRulesetIds?: string[];
}): Promise<void>;

await chrome.declarativeNetRequest.updateEnabledRulesets({
  enableRulesetIds: ["block_trackers"],
});

function getEnabledRulesets(): Promise<string[]>;

function getMatchedRules(filter?: {
  tabId?: number;
  minTimeStamp?: number;
}): Promise<{ rulesMatchedInfo: MatchedRuleInfo[] }>;

interface MatchedRuleInfo {
  rule: { ruleId: number; rulesetId: string };
  timeStamp: number;
  tabId: number;
}

const { rulesMatchedInfo } = await chrome.declarativeNetRequest.getMatchedRules({
  tabId: tab.id,
});
for (const info of rulesMatchedInfo) {
  console.log(`Rule ${info.rule.ruleId} from ${info.rule.rulesetId}`);
}

const available = await chrome.declarativeNetRequest.getAvailableStaticRuleCount();
console.log(`Can still add ${available} static rules`);

await chrome.declarativeNetRequest.updateDynamicRules({
  addRules: [{
    id: 1, priority: 1,
    action: {
      type: "modifyHeaders",
      responseHeaders: [
        { header: "Access-Control-Allow-Origin", operation: "set", value: "*" },
        { header: "Access-Control-Allow-Methods", operation: "set", value: "GET, POST, PUT, DELETE, OPTIONS" },
        { header: "Access-Control-Allow-Headers", operation: "set", value: "Content-Type, Authorization" },
      ],
    },
    condition: { urlFilter: "||api.example.com", resourceTypes: ["xmlhttprequest"] },
  }],
});

async function addRedirect(from: string, to: string) {
  const existing = await chrome.declarativeNetRequest.getDynamicRules();
  const nextId = existing.length > 0
    ? Math.max(...existing.map((r) => r.id)) + 1
    : 1;

  await chrome.declarativeNetRequest.updateDynamicRules({
    addRules: [{
      id: nextId, priority: 1,
      action: { type: "redirect", redirect: { url: to } },
      condition: { urlFilter: from, resourceTypes: ["main_frame"] },
    }],
  });
}

await addRedirect("||old-site.com", "https://new-site.com");

await chrome.declarativeNetRequest.updateSessionRules({
  addRules: [{
    id: 1, priority: 1,
    action: {
      type: "modifyHeaders",
      requestHeaders: [
        { header: "X-Custom-Auth", operation: "set", value: "Bearer dev-token" },
        { header: "X-Debug", operation: "set", value: "true" },
      ],
    },
    condition: { urlFilter: "||staging-api.example.com", resourceTypes: ["xmlhttprequest"] },
  }],
});