rules.mjs

const SUPPORTED_SCHEMES = new Set(["http", "https", "*"]);
export const MAX_USER_AGENT_LENGTH = 1024;
export const MAX_USER_AGENT_HOSTS = 32;
export const MAX_USER_AGENT_HOSTS_LENGTH = 1024;

export function normalizeScriptWorld(value) {
  return value === "MAIN" ? "MAIN" : "USER_SCRIPT";
}

function isValidHostname(hostname) {
  if (hostname === "*") {
    return true;
  }

  const value = hostname.startsWith("*.") ? hostname.slice(2) : hostname;
  if (!value || value.includes("*") || value.length > 253) {
    return false;
  }

  // Chrome match patterns do not accept ports. IPv4, localhost and DNS names
  // are all covered by these hostname labels.
  return value.split(".").every((label) =>
    label.length > 0
    && label.length <= 63
    && /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(label)
  );
}

export function parseMatchPattern(pattern) {
  if (typeof pattern !== "string") {
    throw new Error("errorMatchString");
  }

  const trimmed = pattern.trim();
  const match = /^(https?|\*):\/\/([^/]+)(\/.*)$/.exec(trimmed);
  if (!match) {
    throw new Error("errorMatchFormat");
  }

  const [, scheme, rawHost, path] = match;
  const host = rawHost.toLowerCase();

  if (!SUPPORTED_SCHEMES.has(scheme) || !isValidHostname(host)) {
    throw new Error("errorMatchSchemeHost");
  }

  if (!path.startsWith("/")) {
    throw new Error("errorMatchPath");
  }

  if (/\s/.test(path) || path.includes("#")) {
    throw new Error("errorMatchWhitespaceFragment");
  }

  return { scheme, host, path, pattern: `${scheme}://${host}${path}` };
}

function hostMatches(patternHost, hostname) {
  const normalized = hostname.toLowerCase();
  if (patternHost === "*") {
    return true;
  }

  if (patternHost.startsWith("*.")) {
    const base = patternHost.slice(2);
    return normalized === base || normalized.endsWith(`.${base}`);
  }

  return normalized === patternHost;
}

function wildcardMatches(pattern, value) {
  const escapedParts = pattern.split("*").map((part) =>
    part.replace(/[|\\{}()[\]^$+?.]/g, "\\$&")
  );
  return new RegExp(`^${escapedParts.join(".*")}$`).test(value);
}

export function matchesUrl(pattern, urlValue) {
  let parsedPattern;
  let url;

  try {
    parsedPattern = parseMatchPattern(pattern);
    url = new URL(urlValue);
  } catch {
    return false;
  }

  if (url.protocol !== "http:" && url.protocol !== "https:") {
    return false;
  }

  const scheme = url.protocol.slice(0, -1);
  if (parsedPattern.scheme !== "*" && parsedPattern.scheme !== scheme) {
    return false;
  }

  return hostMatches(parsedPattern.host, url.hostname)
    && wildcardMatches(parsedPattern.path, `${url.pathname}${url.search}`);
}

export function permissionPatternFor(pattern) {
  const { scheme, host } = parseMatchPattern(pattern);
  return `${scheme}://${host}/*`;
}

function escapeRegex(value) {
  return value.replace(/[|\\{}()[\]^$+?.-]/g, "\\$&");
}

export function dnrRegexForMatchPattern(pattern) {
  const { scheme, host, path } = parseMatchPattern(pattern);
  const schemePattern = scheme === "*" ? "https?" : scheme;
  const hostPattern = host === "*"
    ? "(?:\\[[0-9a-f:]+\\]|[^/:]+)"
    : host.startsWith("*.")
      ? `(?:[^./:]+\\.)*${escapeRegex(host.slice(2))}`
      : escapeRegex(host);
  const encodedPath = encodeURI(path);
  const pathPattern = encodedPath
    .split("*")
    .map(escapeRegex)
    .join(".*");
  return `^${schemePattern}:\\/\\/${hostPattern}(?::[0-9]+)?${pathPattern}$`;
}

export function dnrRegexForOrigin(urlValue) {
  const url = new URL(urlValue);
  if (url.protocol !== "http:" && url.protocol !== "https:") {
    throw new Error("errorMatchSchemeHost");
  }
  return `^${escapeRegex(url.origin)}\\/`;
}

export function parseUserAgentHost(value) {
  if (typeof value !== "string" || !value.trim()) {
    throw new Error("errorUserAgentHostInvalid");
  }

  const host = value.trim().toLowerCase();
  if (host === "*" || !isValidHostname(host)) {
    throw new Error("errorUserAgentHostInvalid");
  }
  return host;
}

export function normalizeUserAgentHosts(values) {
  const input = Array.isArray(values)
    ? values
    : (typeof values === "string" ? [values] : []);
  const hosts = [];
  const indexes = [];
  const errors = [];
  const seen = new Set();

  input.forEach((value, index) => {
    const trimmed = typeof value === "string" ? value.trim() : "";
    if (!trimmed) {
      return;
    }
    try {
      const host = parseUserAgentHost(trimmed);
      if (!seen.has(host)) {
        seen.add(host);
        hosts.push(host);
        indexes.push(index);
      }
    } catch (error) {
      errors.push({ index, message: error.message });
    }
  });

  if (hosts.length > MAX_USER_AGENT_HOSTS) {
    errors.push({
      index: indexes[MAX_USER_AGENT_HOSTS],
      message: "errorUserAgentHostsTooMany"
    });
  }
  if (hosts.join("\n").length > MAX_USER_AGENT_HOSTS_LENGTH) {
    let length = 0;
    let overflowIndex = indexes.at(-1) || 0;
    hosts.some((host, index) => {
      length += host.length + (index > 0 ? 1 : 0);
      if (length > MAX_USER_AGENT_HOSTS_LENGTH) {
        overflowIndex = indexes[index];
        return true;
      }
      return false;
    });
    errors.push({ index: overflowIndex, message: "errorUserAgentHostsTooLong" });
  }

  const safeHosts = hosts.slice(0, MAX_USER_AGENT_HOSTS);
  while (safeHosts.join("\n").length > MAX_USER_AGENT_HOSTS_LENGTH) {
    safeHosts.pop();
  }
  return { hosts: safeHosts, errors };
}

export function permissionPatternForUserAgentHost(value) {
  return `*://${parseUserAgentHost(value)}/*`;
}

export function dnrRegexForUserAgentHost(value) {
  const host = parseUserAgentHost(value);
  const hostPattern = host.startsWith("*.")
    ? `(?:[^./:]+\\.)*${escapeRegex(host.slice(2))}`
    : escapeRegex(host);
  return `^(?:https?|wss?):\\/\\/${hostPattern}(?::[0-9]+)?\\/`;
}

export function dnrRegexForUserAgentTargets(urlValue, hosts) {
  const patterns = [
    dnrRegexForOrigin(urlValue),
    ...normalizeUserAgentHosts(hosts).hosts.map(dnrRegexForUserAgentHost)
  ];
  return `^(?:${patterns.map((pattern) => pattern.slice(1)).join("|")})`;
}

export function parseResourceUrl(value) {
  if (typeof value !== "string" || !value.trim()) {
    throw new Error("errorResourceRequired");
  }

  let url;
  try {
    url = new URL(value.trim());
  } catch {
    throw new Error("errorResourceInvalid");
  }

  if (url.protocol !== "http:" && url.protocol !== "https:") {
    throw new Error("errorResourceScheme");
  }

  if (url.username || url.password) {
    throw new Error("errorResourceCredentials");
  }

  return url.href;
}

export function permissionPatternForResourceUrl(value) {
  const url = new URL(parseResourceUrl(value));
  return `${url.protocol}//${url.hostname}/*`;
}

export function normalizeResourceUrls(values) {
  const input = Array.isArray(values)
    ? values
    : (typeof values === "string" ? [values] : []);
  const urls = [];
  const errors = [];
  const seen = new Set();

  input.forEach((value, index) => {
    const trimmed = typeof value === "string" ? value.trim() : "";
    if (!trimmed) {
      return;
    }

    try {
      const normalized = parseResourceUrl(trimmed);
      if (!seen.has(normalized)) {
        seen.add(normalized);
        urls.push(normalized);
      }
    } catch (error) {
      errors.push({ index, message: error.message });
    }
  });

  return { urls, errors };
}

function ruleUrls(rule, pluralKey, legacyKey) {
  if (Array.isArray(rule?.[pluralKey])) {
    return rule[pluralKey];
  }
  return typeof rule?.[legacyKey] === "string" && rule[legacyKey].trim()
    ? [rule[legacyKey]]
    : [];
}

export function jsResourcePermissionPatterns(rule) {
  const patterns = new Set();
  for (const value of ruleUrls(rule, "jsUrls", "jsUrl")) {
    if (typeof value === "string" && value.trim()) {
      patterns.add(permissionPatternForResourceUrl(value));
    }
  }
  return [...patterns];
}

export function userAgentHostPermissionPatterns(rule) {
  if (!ruleHasUserAgent(rule)) {
    return [];
  }
  return normalizeUserAgentHosts(rule?.userAgentHosts).hosts
    .map(permissionPatternForUserAgentHost);
}

export function rulePermissionPatterns(rule) {
  return [
    ...new Set([
      permissionPatternFor(rule.match),
      ...jsResourcePermissionPatterns(rule),
      ...userAgentHostPermissionPatterns(rule)
    ])
  ];
}

export async function findMissingRulePermissions(rules, containsOrigin) {
  const patternsByRuleId = new Map();
  const uniquePatterns = new Set();

  for (const rule of Array.isArray(rules) ? rules : []) {
    if (!rule?.enabled || !rule.id) {
      continue;
    }

    const patterns = rulePermissionPatterns(rule);
    patternsByRuleId.set(rule.id, patterns);
    patterns.forEach((pattern) => uniquePatterns.add(pattern));
  }

  const grantedEntries = await Promise.all(
    [...uniquePatterns].map(async (pattern) => [
      pattern,
      await containsOrigin(pattern)
    ])
  );
  const grantedByPattern = new Map(grantedEntries);
  const missingByRuleId = new Map();

  for (const [ruleId, patterns] of patternsByRuleId) {
    const missing = patterns.filter((pattern) => !grantedByPattern.get(pattern));
    if (missing.length > 0) {
      missingByRuleId.set(ruleId, missing);
    }
  }

  return missingByRuleId;
}

export function normalizeRule(rule) {
  const cssUrls = normalizeResourceUrls(ruleUrls(rule, "cssUrls", "cssUrl")).urls;
  const jsUrls = normalizeResourceUrls(ruleUrls(rule, "jsUrls", "jsUrl")).urls;
  const userAgentHosts = normalizeUserAgentHosts(rule?.userAgentHosts).hosts;
  return {
    id: typeof rule?.id === "string" ? rule.id : "",
    name: typeof rule?.name === "string" ? rule.name.trim() : "",
    match: typeof rule?.match === "string" ? rule.match.trim() : "",
    css: typeof rule?.css === "string" ? rule.css.trim() : "",
    cssUrls,
    js: typeof rule?.js === "string" ? rule.js.trim() : "",
    jsUrls,
    jsWorld: normalizeScriptWorld(rule?.jsWorld),
    userAgent: typeof rule?.userAgent === "string" ? rule.userAgent.trim() : "",
    userAgentHosts,
    enabled: rule?.enabled === true
  };
}

export function ruleHasUserAgent(rule) {
  return typeof rule?.userAgent === "string" && Boolean(rule.userAgent.trim());
}

export function ruleHasJavaScript(rule) {
  return Boolean(rule?.js?.trim() || ruleUrls(rule, "jsUrls", "jsUrl").length);
}

export function ruleHasContent(rule) {
  return Boolean(
    rule?.css?.trim()
    || ruleUrls(rule, "cssUrls", "cssUrl").length
    || rule?.js?.trim()
    || ruleUrls(rule, "jsUrls", "jsUrl").length
    || ruleHasUserAgent(rule)
  );
}

function userAgentSpecificity(rule, index) {
  const { scheme, host, path } = parseMatchPattern(rule.match);
  const hostRank = host === "*" ? 0 : (host.startsWith("*.") ? 1 : 2);
  const pathLiteralLength = path.replaceAll("*", "").length;
  const schemeRank = scheme === "*" ? 0 : 1;
  return [hostRank, pathLiteralLength, schemeRank, index];
}

function compareSpecificity(left, right) {
  for (let index = 0; index < left.length; index += 1) {
    if (left[index] !== right[index]) {
      return left[index] - right[index];
    }
  }
  return 0;
}

export function selectUserAgentRule(rules, urlValue) {
  let selected = null;
  let selectedSpecificity = null;
  (Array.isArray(rules) ? rules : []).forEach((rule, index) => {
    if (!rule?.enabled || !ruleHasUserAgent(rule) || !matchesUrl(rule.match, urlValue)) {
      return;
    }
    const specificity = userAgentSpecificity(rule, index);
    if (!selected || compareSpecificity(specificity, selectedSpecificity) > 0) {
      selected = rule;
      selectedSpecificity = specificity;
    }
  });
  return selected;
}

export function sortUserAgentRulesByPriority(rules) {
  return (Array.isArray(rules) ? rules : [])
    .map((rule, index) => ({ rule, specificity: userAgentSpecificity(rule, index) }))
    .sort((left, right) => compareSpecificity(left.specificity, right.specificity))
    .map((entry) => entry.rule);
}

export function ruleDisplayName(rule) {
  const name = typeof rule?.name === "string" ? rule.name.trim() : "";
  if (name) {
    return name;
  }

  const match = typeof rule?.match === "string" ? rule.match.trim() : "";
  try {
    const { host } = parseMatchPattern(match);
    return host.startsWith("*.") ? host.slice(2) : host;
  } catch {
    return match;
  }
}

export function validateRuleInput(input) {
  const errors = {};
  const name = typeof input?.name === "string" ? input.name.trim() : "";
  const match = typeof input?.match === "string" ? input.match.trim() : "";
  const css = typeof input?.css === "string" ? input.css.trim() : "";
  const js = typeof input?.js === "string" ? input.js.trim() : "";
  const userAgent = typeof input?.userAgent === "string" ? input.userAgent.trim() : "";
  const cssUrlResult = normalizeResourceUrls(input?.cssUrls);
  const jsUrlResult = normalizeResourceUrls(input?.jsUrls);
  const userAgentHostResult = normalizeUserAgentHosts(input?.userAgentHosts);

  try {
    parseMatchPattern(match);
  } catch (error) {
    errors.match = error.message;
  }

  if (cssUrlResult.errors.length > 0) {
    errors.cssUrls = cssUrlResult.errors;
  }

  if (jsUrlResult.errors.length > 0) {
    errors.jsUrls = jsUrlResult.errors;
  }

  if (userAgentHostResult.errors.length > 0) {
    errors.userAgentHosts = userAgentHostResult.errors;
  }

  if (userAgent.length > MAX_USER_AGENT_LENGTH) {
    errors.userAgent = "errorUserAgentTooLong";
  } else if (/[\u0000-\u001f\u007f]/.test(userAgent)) {
    errors.userAgent = "errorUserAgentControlCharacters";
  }

  const value = {
    name,
    match,
    css,
    cssUrls: cssUrlResult.urls,
    js,
    jsUrls: jsUrlResult.urls,
    jsWorld: normalizeScriptWorld(input?.jsWorld),
    userAgent,
    userAgentHosts: userAgentHostResult.hosts,
    enabled: Boolean(input?.enabled)
  };

  return {
    valid: Object.keys(errors).length === 0,
    errors,
    value
  };
}