import { chromium } from 'playwright';
import log from 'electron-log';

const parseChannels = () => {
  const raw = process.env.CHANNELS || '';
  if (!raw) return [];
  try {
    const parsed = JSON.parse(raw);
    return Array.isArray(parsed) ? parsed : [];
  } catch {
    return [];
  }
};

const normalizeUrl = (value) => {
  const raw = String(value || '').trim();
  if (!raw) return null;
  try {
    return new URL(raw);
  } catch {
    return null;
  }
};

const isSameTarget = (currentUrl, targetUrl) => {
  if (!currentUrl || !targetUrl) return false;
  if (currentUrl.startsWith(targetUrl)) return true;

  const current = normalizeUrl(currentUrl);
  const target = normalizeUrl(targetUrl);
  if (!current || !target) return false;
  if (current.origin !== target.origin) return false;
  if (!current.pathname.startsWith(target.pathname)) return false;
  return true;
};

const isBlankLikePage = (url) => {
  const u = String(url || '').trim().toLowerCase();
  if (!u) return true;
  if (u === 'about:blank' || u.startsWith('about:blank#') || u.startsWith('about:blank?')) return true;
  if (u === 'chrome://newtab/' || u.startsWith('chrome://newtab')) return true;
  if (u.startsWith('chrome://new-tab-page')) return true;
  return false;
};

(async () => {
  let browser;

  try {
    const channels = parseChannels();
    
    if (!channels.length) {
      log.info('No channels provided, skip.');
      return;
    }

    browser = await chromium.connectOverCDP('http://127.0.0.1:9222');
    const context = browser.contexts()[0];

    if (!context) {
      throw new Error('No browser context available');
    }

    await context.addInitScript(() => {
      Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
    });

    const usedPages = new Set();

    for (let i = 0; i < channels.length; i++) {
      const targetUrl = channels[i]?.channelUrl;

      if (!targetUrl) continue;

      let pages = await context.pages();
      let page = null;
      for (let j = 0; j < pages.length; j++) {
        const p = pages[j];
        const current = p.url();
        if (isSameTarget(current, targetUrl)) {
          page = p;
          break;
        }
      }

      if (!page) {
        for (let j = 0; j < pages.length; j++) {
          const p = pages[j];
          if (usedPages.has(p)) continue;
          if (isBlankLikePage(p.url())) {
            page = p;
            break;
          }
        }
      }

      if (!page) {
        page = await context.newPage();
      }
      await page.bringToFront();
      usedPages.add(page);

      const current = page.url();

      if (!current || !isSameTarget(current, targetUrl)) {
        await page.goto(targetUrl, { waitUntil: 'domcontentloaded' });
      }
    }

    const pagesAfter = await context.pages();
    for (const p of pagesAfter) {
      if (!usedPages.has(p)) {
        try {
          await p.close();
        } catch {}
      }
    }
  } catch (error) {
    log.error(error);
    process.exitCode = 1;
  } finally {
    if(browser){
      try {
        if (typeof browser.disconnect === 'function') {
          await browser.disconnect();
        } else {
          await browser.close();
        }
      } catch {}
    }
  }
})();