// URL-first new-channel onboarding (editor/app/channels/components/ChannelForm).
// Pasting a URL derives platform / handling / slug and the download queue OFFLINE
// (no network); an opt-in "Fetch details" runs a one-entry yt-dlp probe that
// fills the name and can register a host unknown to the app. On create it stores
// the playlist and can jump the channel to the top of the auto-download queue.
//
// The fake yt-dlp (e2e/fixtures/bin/fake-ytdlp.mjs) answers the probe with the
// deterministic name "Fake Probe Channel".
//
// getByLabel("URL") is always { exact: true } here. getByLabel matches by
// SUBSTRING, and three other controls on this form wrap descriptions ending
// "Requires a URL." inside their <label>, which puts "URL" in their accessible
// names — so the bare locator resolves to four elements (the url textbox, the
// fetchPlaylist and prioritizeDownload checkboxes, and the syncIntervalMinutes
// select). Only the textbox has the exact accessible name "URL".

import { test, expect } from "@playwright/test";
import { resetData, readJson, pathExists, generateReport } from "./helpers";

test("derives platform, handling, slug and queue from a YouTube URL offline", async ({
  page,
}) => {
  await resetData("empty");
  await generateReport(page, "new");
  await page.goto("/channels/new");

  await page
    .getByLabel("URL", { exact: true })
    .fill("https://www.youtube.com/@Veritasium/videos");

  await expect(page.getByLabel("platform")).toHaveValue("youtube");
  await expect(
    page.locator('input[name="handling"][value="youtube"]'),
  ).toBeChecked();
  await expect(page.locator('input[name="slug"]')).toHaveValue("veritasium");
  const queue = page.getByLabel("derived queue");
  await expect(queue).toContainText("platform:youtube");
  await expect(queue).not.toContainText("(new)");
});

test("an unknown host is offered its own per-domain queue, marked (new)", async ({
  page,
}) => {
  await resetData("empty");
  await generateReport(page, "new");
  await page.goto("/channels/new");

  await page.getByLabel("URL", { exact: true }).fill("https://vimeo.com/someuser");

  // detectPlatform doesn't recognize vimeo → platform stays Auto, handling
  // falls to transcribe, and the queue is the per-domain fallback marked new.
  await expect(page.getByLabel("platform")).toHaveValue("");
  await expect(
    page.locator('input[name="handling"][value="transcribe"]'),
  ).toBeChecked();
  const queue = page.getByLabel("derived queue");
  await expect(queue).toContainText("platform:vimeo.com");
  await expect(queue).toContainText("(new)");
});

test("Fetch details fills the name from the yt-dlp probe", async ({ page }) => {
  await resetData("empty");
  await generateReport(page, "new");
  await page.goto("/channels/new");

  await page
    .getByLabel("URL", { exact: true })
    .fill("https://www.youtube.com/@testchan/videos");
  await page.getByRole("button", { name: "fetch details" }).click();

  await expect(page.locator('input[name="name"]')).toHaveValue(
    "Fake Probe Channel",
  );
  await expect(page.getByLabel("probe result")).toContainText(
    "Fake Probe Channel",
  );
});

test("creating with 'Fetch playlist now' stores the playlist", async ({
  page,
}) => {
  await resetData("empty");
  await generateReport(page, "new");
  await page.goto("/channels/new");

  await page
    .getByLabel("URL", { exact: true })
    .fill("https://www.youtube.com/@testchan/videos");
  await page.getByRole("button", { name: "fetch details" }).click();
  await expect(page.locator('input[name="name"]')).toHaveValue(
    "Fake Probe Channel",
  );
  // Pin the slug so the assertion path is deterministic.
  await page.locator('input[name="slug"]').fill("playlist-chan");

  // "Fetch playlist now" is checked by default.
  await expect(page.locator('input[name="fetchPlaylist"]')).toBeChecked();
  await page.getByRole("button", { name: "Create channel" }).click();

  await expect(page).toHaveURL(/\/channels\/playlist-chan(\?|$)/);
  // The store-playlist job runs async on create; wait for the playlist file.
  await expect
    .poll(
      () =>
        pathExists("test-transcripts/channels/playlist-chan/playlist"),
      { timeout: 15000 },
    )
    .toBe(true);
});

test("'Add to top of auto-queue' takes the first rank and enables the runner", async ({
  page,
}) => {
  await resetData("empty");
  await generateReport(page, "new");
  await page.goto("/channels/new");

  await page
    .getByLabel("URL", { exact: true })
    .fill("https://www.youtube.com/@testchan/videos");
  await page.getByRole("button", { name: "fetch details" }).click();
  await expect(page.locator('input[name="name"]')).toHaveValue(
    "Fake Probe Channel",
  );
  await page.locator('input[name="slug"]').fill("prio-chan");
  await page.locator('input[name="prioritizeDownload"]').check();

  await page.getByRole("button", { name: "Create channel" }).click();
  await expect(page).toHaveURL(/\/channels\/prio-chan(\?|$)/);

  // The download policy is enabled and the channel has the FIRST RANK in the
  // priority document, which is what "top of the auto-queue" means now.
  //
  // It used to prepend a `prioritize-<slug>` leaf straight into the stored
  // tree. While a priority model exists that tree is COMPILED and the runner
  // does not dispatch from a hand-written one — so the gesture is a priority
  // edit, and the tree it produces is the compiler's: `prio-normal` first,
  // this channel at the head of it, the catch-all last.
  await expect
    .poll(
      async () => {
        const s = await readJson<{
          channelPriority?: { channels?: Record<string, { rank?: number }> };
          autoQueue?: {
            download?: {
              enabled?: boolean;
              root?: { children?: { id?: string; children?: { id?: string }[] }[] };
            };
          };
        }>("test-settings.json");
        const dl = s.autoQueue?.download;
        return {
          enabled: dl?.enabled ?? false,
          groups: dl?.root?.children?.map((c) => c.id) ?? null,
          head: dl?.root?.children?.[0]?.children?.[0]?.id ?? null,
          rank: s.channelPriority?.channels?.["prio-chan"]?.rank ?? null,
        };
      },
      { timeout: 15000 },
    )
    .toEqual({
      enabled: true,
      groups: ["prio-normal", "prio-all"],
      head: "prio-normal-prio-chan",
      rank: 0,
    });
});