background.js

// Background service worker for proxy management

let proxyConfig = {
  enabled: true,
  host: "127.0.0.1",
  port: "1080",
  type: "socks5",
};

let whitelist = [];
let vpnDetected = false;
let lastIpAddress = null;
let autoAddMode = true;

let tabDomains = {};
let tabMainDomain = {};
let autoAddedDomains = new Set();

chrome.runtime.onInstalled.addListener(async () => {
  const data = await chrome.storage.local.get(["proxyConfig", "whitelist"]);

  if (data.proxyConfig) {
    proxyConfig = data.proxyConfig;
  } else {
    await chrome.storage.local.set({ proxyConfig });
  }

  if (data.whitelist && Array.isArray(data.whitelist)) {
    whitelist = data.whitelist;
  } else {
    whitelist = [];
    await chrome.storage.local.set({ whitelist: [] });
  }

  const autoAddData = await chrome.storage.local.get(["autoAddMode"]);
  if (autoAddData.autoAddMode !== undefined) {
    autoAddMode = autoAddData.autoAddMode;
  } else {
    await chrome.storage.local.set({ autoAddMode: true });
  }

  updateProxySettings();
  startVpnDetection();
});

chrome.runtime.onStartup.addListener(async () => {
  const data = await chrome.storage.local.get(["proxyConfig", "whitelist"]);

  if (data.proxyConfig) {
    proxyConfig = data.proxyConfig;
  }

  if (data.whitelist && Array.isArray(data.whitelist)) {
    whitelist = data.whitelist;
  }

  const autoAddData = await chrome.storage.local.get(["autoAddMode"]);
  if (autoAddData.autoAddMode !== undefined) {
    autoAddMode = autoAddData.autoAddMode;
  }

  updateProxySettings();
  startVpnDetection();
});

// Listen for messages from popup
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  if (request.action === "getConfig") {
    sendResponse({
      proxyConfig,
      whitelist,
      vpnDetected,
      autoAddMode,
    });
  } else if (request.action === "toggleAutoAdd") {
    autoAddMode = request.enabled;
    chrome.storage.local.set({ autoAddMode });
    sendResponse({ success: true, autoAddMode });
  } else if (request.action === "updateConfig") {
    proxyConfig = request.proxyConfig;
    chrome.storage.local.set({ proxyConfig });
    updateProxySettings();
    sendResponse({ success: true });
  } else if (request.action === "getTabDomains") {
    // Get all domains used by the current tab
    const domains = tabDomains[request.tabId] || new Set();
    sendResponse({ domains: Array.from(domains) });
  } else if (request.action === "addToWhitelist") {
    const domainsToAdd = request.domains || [request.domain];
    let added = [];

    domainsToAdd.forEach((domain) => {
      if (domain && !whitelist.includes(domain)) {
        whitelist.push(domain);
        added.push(domain);

        // Add related domains for common services
        const relatedDomains = getRelatedDomains(domain);
        relatedDomains.forEach((related) => {
          if (!whitelist.includes(related)) {
            whitelist.push(related);
            added.push(related);
            console.log(`Auto-added related domain: ${related} for ${domain}`);
          }
        });
      }
    });

    if (added.length > 0) {
      chrome.storage.local.set({ whitelist }, () => {
        updateProxySettings();
      });
    }

    sendResponse({ success: true, whitelist, added });
  } else if (request.action === "removeFromWhitelist") {
    whitelist = whitelist.filter((d) => d !== request.domain);
    chrome.storage.local.set({ whitelist }, () => {
      updateProxySettings();
    });
    sendResponse({ success: true, whitelist });
  } else if (request.action === "toggleProxy") {
    proxyConfig.enabled = request.enabled;
    chrome.storage.local.set({ proxyConfig }, () => {
      updateProxySettings();
    });
    sendResponse({ success: true });
  }
  return true;
});

// Update proxy settings based on configuration
async function updateProxySettings() {
  // If VPN is detected or proxy is disabled, use direct connection
  if (vpnDetected || !proxyConfig.enabled) {
    await chrome.proxy.settings.set({
      value: {
        mode: "direct",
      },
      scope: "regular",
    });
    return;
  }

  // Configure PAC script for whitelist-based routing
  const pacScript = generatePacScript();

  await chrome.proxy.settings.set({
    value: {
      mode: "pac_script",
      pacScript: {
        data: pacScript,
      },
    },
    scope: "regular",
  });
}

// Get related domains for common services
function getRelatedDomains(domain) {
  const relatedMap = {
    // YouTube domains
    "youtube.com": [
      "ytimg.com",
      "googlevideo.com",
      "yt3.ggpht.com",
      "yt3.googleusercontent.com",
      "googleapis.com",
    ],
    "www.youtube.com": [
      "ytimg.com",
      "googlevideo.com",
      "yt3.ggpht.com",
      "yt3.googleusercontent.com",
    ],

    // Twitter domains
    "twitter.com": ["twimg.com", "t.co"],
    "x.com": ["twimg.com", "t.co"],

    // Facebook domains
    "facebook.com": ["fbcdn.net", "facebook.net"],

    // Instagram domains
    "instagram.com": ["cdninstagram.com", "fbcdn.net"],

    // Google services
    "google.com": ["gstatic.com", "googleapis.com", "googleusercontent.com"],

    // Add more as needed
  };

  // Check if domain or its parent has related domains
  const exactMatch = relatedMap[domain];
  if (exactMatch) return exactMatch;

  // Check without www
  const withoutWww = domain.replace(/^www\./, "");
  if (relatedMap[withoutWww]) return relatedMap[withoutWww];

  return [];
}

// Generate PAC script for selective proxy routing
function generatePacScript() {
  const proxyString = `${proxyConfig.type.toUpperCase()} ${proxyConfig.host}:${
    proxyConfig.port
  }`;

  // Create whitelist pattern matching
  const whitelistConditions = whitelist
    .map((domain) => {
      // Match exact domain, all subdomains, and all paths/APIs
      return `(host == "${domain}" || dnsDomainIs(host, ".${domain}"))`;
    })
    .join(" || ");

  const pacScript = `
function FindProxyForURL(url, host) {
  // Whitelist check - these domains and ALL their subdomains/APIs use proxy
  if (${whitelistConditions || "false"}) {
    return "${proxyString}";
  }

  // Everything else goes direct
  return "DIRECT";
}
`;

  return pacScript;
}

// VPN Detection - check for routing changes
async function detectVpn() {
  try {
    // Check if external IP has changed significantly
    // This is a heuristic - if we can't reach a test server or routing changed
    const response = await fetch("https://api.ipify.org?format=json", {
      method: "GET",
      cache: "no-cache",
    });

    const data = await response.json();
    const currentIp = data.ip;

    if (lastIpAddress === null) {
      lastIpAddress = currentIp;
      return false;
    }

    // If IP changed, might indicate VPN activation
    // Additional check: test latency or routing
    if (lastIpAddress !== currentIp) {
      // IP changed - could be VPN, check if it's a known VPN range
      // For now, we'll use a simple check
      const wasVpn = vpnDetected;

      // Check if routing through a tunnel (heuristic: check for private IP from public service)
      // This is a simplified check
      const startTime = Date.now();
      await fetch("https://www.google.com/generate_204", { cache: "no-cache" });
      const latency = Date.now() - startTime;

      // High latency might indicate VPN tunnel
      vpnDetected = latency > 500; // Threshold can be adjusted

      if (vpnDetected !== wasVpn) {
        console.log("VPN status changed:", vpnDetected);
        updateProxySettings();
      }

      lastIpAddress = currentIp;
    }

    return vpnDetected;
  } catch (error) {
    console.error("VPN detection error:", error);
    return false;
  }
}

// Start VPN detection polling
function startVpnDetection() {
  // Check every 30 seconds
  setInterval(detectVpn, 30000);
  // Initial check
  detectVpn();
}

// Track web requests to detect all domains used by a page
chrome.webRequest.onBeforeRequest.addListener(
  (details) => {
    if (details.tabId > 0) {
      try {
        const url = new URL(details.url);
        const domain = url.hostname;

        // Initialize set for this tab if it doesn't exist
        if (!tabDomains[details.tabId]) {
          tabDomains[details.tabId] = new Set();
        }

        // Add domain to the tab's domain list
        tabDomains[details.tabId].add(domain);

        const parts = domain.split(".");
        if (parts.length > 2) {
          const parentDomain = parts.slice(-2).join(".");
          tabDomains[details.tabId].add(parentDomain);
        }
      } catch (e) {}
    }
  },
  { urls: ["<all_urls>"] }
);

// Also track completed requests to catch more domains
chrome.webRequest.onCompleted.addListener(
  (details) => {
    if (details.tabId > 0) {
      try {
        const url = new URL(details.url);
        const domain = url.hostname;

        if (!tabDomains[details.tabId]) {
          tabDomains[details.tabId] = new Set();
        }

        tabDomains[details.tabId].add(domain);

        const parts = domain.split(".");
        if (parts.length > 2) {
          const parentDomain = parts.slice(-2).join(".");
          tabDomains[details.tabId].add(parentDomain);
        }

        if (autoAddMode && tabMainDomain[details.tabId]) {
          autoAddDomainsForTab(details.tabId);
        }
      } catch (e) {}
    }
  },
  { urls: ["<all_urls>"] }
);

chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
  if (changeInfo.status === "complete" && tab.url) {
    try {
      const url = new URL(tab.url);
      if (!url.protocol.startsWith("chrome")) {
        tabMainDomain[tabId] = url.hostname;
        if (autoAddMode) {
          setTimeout(() => {
            autoAddDomainsForTab(tabId);
          }, 3000);
        }
      }
    } catch (e) {}
  }
});

function autoAddDomainsForTab(tabId) {
  if (!autoAddMode || !tabDomains[tabId] || tabDomains[tabId].size === 0) {
    return;
  }

  const mainDomain = tabMainDomain[tabId];
  if (!mainDomain) return;

  const mainDomainInWhitelist = whitelist.some(
    (w) =>
      mainDomain === w ||
      mainDomain.endsWith("." + w) ||
      w.endsWith("." + mainDomain) ||
      (mainDomain.startsWith("www.") && mainDomain.substring(4) === w) ||
      "www." + mainDomain === w
  );

  if (!mainDomainInWhitelist) {
    return;
  }

  if (autoAddedDomains.has(mainDomain)) {
    return;
  }

  const domains = Array.from(tabDomains[tabId]);
  let addedCount = 0;
  let addedDomainsList = [];

  domains.forEach((domain) => {
    if (!whitelist.includes(domain)) {
      whitelist.push(domain);
      addedCount++;
      addedDomainsList.push(domain);

      // Add related domains
      const relatedDomains = getRelatedDomains(domain);
      relatedDomains.forEach((related) => {
        if (!whitelist.includes(related)) {
          whitelist.push(related);
          addedCount++;
          addedDomainsList.push(related);
        }
      });

      // Add www/non-www versions
      if (domain.startsWith("www.")) {
        const nonWww = domain.substring(4);
        if (!whitelist.includes(nonWww)) {
          whitelist.push(nonWww);
          addedCount++;
          addedDomainsList.push(nonWww);
        }
      } else {
        const withWww = "www." + domain;
        if (!whitelist.includes(withWww)) {
          whitelist.push(withWww);
          addedCount++;
          addedDomainsList.push(withWww);
        }
      }
    }
  });

  if (addedCount > 0) {
    autoAddedDomains.add(mainDomain);
    chrome.storage.local.set({ whitelist }, () => {
      updateProxySettings();
    });
  }
}

// Clean up when tab is closed
chrome.tabs.onRemoved.addListener((tabId) => {
  delete tabDomains[tabId];
  delete tabMainDomain[tabId];
});

setInterval(() => {
  const tabIds = Object.keys(tabDomains);
  if (tabIds.length > 100) {
    tabIds.slice(0, tabIds.length - 100).forEach((id) => {
      delete tabDomains[id];
    });
  }
}, 60000);
chrome.runtime.onInstalled.addListener(() => {
  chrome.contextMenus.create({
    id: "addToWhitelist",
    title: "Add to Proxy Whitelist (with all domains)",
    contexts: ["page"],
  });
});

chrome.contextMenus.onClicked.addListener((info, tab) => {
  if (info.menuItemId === "addToWhitelist") {
    const url = new URL(tab.url);
    const mainDomain = url.hostname;

    const allDomains = tabDomains[tab.id]
      ? Array.from(tabDomains[tab.id])
      : [mainDomain];

    let added = [];
    allDomains.forEach((domain) => {
      if (!whitelist.includes(domain)) {
        whitelist.push(domain);
        added.push(domain);
      }
    });

    if (added.length > 0) {
      chrome.storage.local.set({ whitelist }, () => {
        updateProxySettings();
      });
    }
  }
});