export const runtime = "nodejs";

import { type Browser, type BrowserContext } from "playwright";
import { chromium } from "playwright-extra"; // A simple singleton manager for a persistent Chromium context with ref-counting. // Prevents concurrent tasks from closing the shared window prematurely.
import stealth from "puppeteer-extra-plugin-stealth";
chromium.use(stealth());

let contextPromise: Promise<BrowserContext> | null = null;
let context: BrowserContext | null = null;
let refCount = 0;
let idleCloseTimer: NodeJS.Timeout | null = null;

const USER_DATA_DIR = process.env.USER_DATA_DIR ?? "chrome-profile/douyin";

async function launchContext(): Promise<BrowserContext> {
  const ctx = await chromium.launchPersistentContext(USER_DATA_DIR, {
    headless: process.env.CHROMIUM_HEADLESS === "true",
    viewport: {
      width: Number(process.env.CHROMIUM_VIEWPORT_WIDTH ?? 1280),
      height: Number(process.env.CHROMIUM_VIEWPORT_HEIGHT ?? 1080),
    },
  });
  // When the context is closed externally, reset manager state
  ctx.on("close", () => {
    context = null;
    contextPromise = null;
    refCount = 0;
    if (idleCloseTimer) {
      clearTimeout(idleCloseTimer);
      idleCloseTimer = null;
    }
  });
  return ctx;
}

export async function acquireBrowserContext(): Promise<BrowserContext> {
  // Cancel any pending idle close if a new consumer arrives
  if (idleCloseTimer) {
    clearTimeout(idleCloseTimer);
    idleCloseTimer = null;
  }

  if (context) {
    refCount += 1;
    return context;
  }

  if (!contextPromise) {
    contextPromise = launchContext();
  }
  context = await contextPromise;
  refCount += 1;
  return context;
}

export async function releaseBrowserContext(options?: {
  idleMillis?: number;
}): Promise<void> {
  const idleMillis = options?.idleMillis ?? 15_000;
  refCount = Math.max(0, refCount - 1);

  if (refCount > 0 || !context) return;

  // Delay the close to allow bursty workloads to reuse the context
  if (idleCloseTimer) {
    clearTimeout(idleCloseTimer);
    idleCloseTimer = null;
  }
  idleCloseTimer = setTimeout(async () => {
    try {
      if (context && refCount === 0) {
        await context.close();
      }
    } finally {
      context = null;
      contextPromise = null;
      idleCloseTimer = null;
    }
  }, idleMillis);
}

// --- Isolated context support for per-scrape independence ---

const isolatedMap = new WeakMap<BrowserContext, Browser>();

async function getSharedStorageState(): Promise<any | undefined> {
  try {
    const shared = await acquireBrowserContext();
    const state = await shared.storageState();
    // Do not force-close immediately; keep ref-counting behavior
    await releaseBrowserContext();
    return state;
  } catch {
    // If shared context not available, proceed without storageState
    return undefined;
  }
}

/**
 * Create a brand-new, independent Browser + Context for a single scrape.
 * Attempts to import cookies/localStorage from the shared persistent profile
 * so you remain logged-in, but isolates network events, cache and listeners.
 */
export async function acquireIsolatedContext(): Promise<BrowserContext> {
  const storageState = await getSharedStorageState();
  const browser = await chromium.launch({
    headless: process.env.CHROMIUM_HEADLESS === "true",
  });
  const ctx = await browser.newContext({
    storageState,
    viewport: {
      width: Number(process.env.CHROMIUM_VIEWPORT_WIDTH ?? 1280),
      height: Number(process.env.CHROMIUM_VIEWPORT_HEIGHT ?? 1080),
    },
  });
  isolatedMap.set(ctx, browser);
  ctx.on("close", () => {
    const b = isolatedMap.get(ctx);
    if (b) {
      b.close().catch(() => {});
      isolatedMap.delete(ctx);
    }
  });
  return ctx;
}

export async function releaseIsolatedContext(
  ctx: BrowserContext | null | undefined,
): Promise<void> {
  if (!ctx) return;
  try {
    await ctx.close();
  } finally {
    const b = isolatedMap.get(ctx);
    if (b) {
      await b.close().catch(() => {});
      isolatedMap.delete(ctx);
    }
  }
}