import { expect } from "@playwright/test";
import { pollUntil } from "../api.js";
import { readRegisteredArtifacts } from "../registered-artifact.js";
import { checks, sameTask, type Entity } from "./internal-support.js";
import { runtimeDefinition, runtimeWorker, runtimeObservation, observeRuntime } from "./runtime-support.js";
import type { ChatCatalogContext } from "../chat-catalog-contract.js";
interface WorkspaceView { workspace: { id: string; companyId: string; projectId?: string | null; name: string; cwd: string }; repositories: unknown[] }
export async function enableTaskWorkspaceView(ctx: ChatCatalogContext) {
  await ctx.input.api.patch("/api/instance/settings/experimental", { enableIsolatedWorkspaces: true });
  const settings = await ctx.input.api.get<{ enableIsolatedWorkspaces: boolean }>("/api/instance/settings/experimental");
  if (settings.enableIsolatedWorkspaces !== true) throw new Error("The supported workspace view is not enabled");
}
export async function savedTaskWorkspace(ctx: ChatCatalogContext, options: { artifact?: boolean; workerName?: string; html?: boolean } = {}) {
  const { execution, fixtures, workspacePath, nonce, api } = ctx.input;
  const base = execution.profile.buildAgent({ environmentId: fixtures.environment.id, environmentFixtureId: execution.environment.id,
    workspacePath, secretRefs: fixtures.secretRefs, executionId: nonce });
  const { cwd: _cwd, ...taskConfig } = base.adapterConfig as Record<string, unknown>;
  const worker = await runtimeWorker(ctx, options.workerName ?? "Morgan", { adapterConfig: taskConfig });
  const company = `/api/companies/${fixtures.company.id}`;
  for (const scope of [{ scopeType: "company", scopeId: fixtures.company.id }, { scopeType: "agent", scopeId: worker.id }])
    await api.post(`${company}/budgets/policies`, { ...scope, amount: 500, hardStopEnabled: true, isActive: true, unpricedUsagePolicy: "allow" });
  const marker = `Saved website prerequisite ${nonce}`;
  const previousRuns = await ctx.allRuns();
  const task = await api.post<Entity>(`${company}/issues`, { title: "Website task", status: "todo", assigneeAgentId: worker.id,
    description: `Create a local file website-fixture.txt containing exactly ${JSON.stringify(marker)} in your admitted task workspace. ${options.html ? `Also save index.html as a semantic HTML page with that same visible reference in an h1 and a short Acorn product paragraph. Do not start any preview server yet.` : ""} Save a brief task document as evidence, ${options.artifact ? "register the actual website-fixture.txt file as a downloadable artifact work product titled website-fixture.txt," : ""} then complete this fixture task normally. Do not create a project, repository, another task, or remote side effect.` });
  await pollUntil({ label: "Real projectless website fixture completion", deadlineAt: Date.now() + 180_000,
    load: async () => ({ task: await api.get<Entity>(`/api/issues/${task.id}`), runs: (await ctx.allRuns()).filter(run => !previousRuns.some(prior => prior.id === run.id)) }),
    accept: value => value.task.status === "done" && value.runs.length === 1 && value.runs.every(run => run.status === "succeeded"),
    reject: value => value.runs.some(run => ["failed", "cancelled", "timed_out"].includes(run.status)) ? "Projectless prerequisite provider run failed" : undefined });
  const view = await api.get<WorkspaceView>(`/api/issues/${task.id}/workspace`);
  const file = await api.get<{ resource?: { workspaceKind?: string }; content?: { data?: string } }>(`/api/issues/${task.id}/file-resources/content?workspace=execution&path=website-fixture.txt`);
  if (view.workspace.projectId || file.resource?.workspaceKind !== "execution_workspace" || file.content?.data?.trim() !== marker)
    throw new Error("Projectless fixture has no actual task-bound saved file");
  const fixtureRunId = (await ctx.allRuns()).find(run => !previousRuns.some(prior => prior.id === run.id))!.id;
  const [artifact] = options.artifact ? await readRegisteredArtifacts(api, task.id, fixtureRunId, ["website-fixture.txt"]) : [];
  return { worker, task: await api.get<Entity>(`/api/issues/${task.id}`), workspaceBefore: view, marker, artifact,
    fileBefore: file.content.data, fixtureRunId };
}
export function gradeLocateFiles(value: unknown) {
  const c = checks(); const o = runtimeObservation(value);
  c.add("actual-task-workspace-evidence", !!o, "The actual admitted binding, file bytes and setup run identity are independently required."); if (!o) return c.result();
  const before = o.state.workspaceBefore as WorkspaceView | undefined; const after = o.state.workspaceAfter as WorkspaceView | undefined;
  const task = o.state.task as Entity | undefined;
  c.add("same-projectless-task-binding", !!before?.workspace?.id && !!after && before.workspace.id === after.workspace.id
    && before.workspace.cwd === after.workspace.cwd && after.workspace.companyId === o.companyId && after.workspace.projectId == null
    && !!task && sameTask(task, o.tasks.find(row => row.id === task.id)), "The correct projectless binding persists without reassigning or changing the task.");
  c.add("actual-saved-files-retained", o.state.fileAfter === o.state.fileBefore && typeof o.state.fileBefore === "string"
    && o.state.fileBefore.trim() === o.state.marker && o.runs.some(run => run.id === o.state.fixtureRunId && run.agentId === (o.state.worker as Entity).id
      && run.status === "succeeded"), "A genuine worker created the prerequisite file and it remains unchanged.");
  // The person needs to reach the bound workspace, so the reply must render a link to its page; the
  // scripted human then clicks that link. A cwd or id copied as text is not graded: the request did not ask
  // for a literal, and abbreviated paths are a valid way to name a location the link already identifies.
  const prefix = String(o.state.companyPrefix);
  c.add("bound-workspace-page-link", !!after && o.links.some(href => workspaceLink(o.origin, href, after.workspace.id, prefix)),
    "The rendered reply links the supported view of the workspace actually bound to the task.");
  c.add("no-other-workspace-link", !!after && workspaceResultLinks(o.reply, o.links)
    .filter(href => { try { return new URL(href, o.origin).pathname.includes("/execution-workspaces/"); } catch { return false; } })
    .every(href => workspaceLink(o.origin, href, after.workspace.id, prefix)),
    "Every workspace link in the reply identifies the bound workspace, not an agent default or another task's workspace.");
  return c.result();
}
export function workspaceResultLinks(reply: string, rendered: string[]) {
  return [...new Set([...rendered, ...Array.from(reply.matchAll(/\[[^\]]*\]\(([^)\s]+)\)/g), match => match[1]!)])];
}
export function workspaceLink(origin: string, href: string, id: string, prefix: string) {
  try { const url = new URL(href, origin); const parts = url.pathname.split("/").map(decodeURIComponent); const at = parts.indexOf("execution-workspaces");
    return url.origin === new URL(origin).origin && at === 2 && parts[1] === prefix && parts[at + 1] === id
      && (parts.length === 4 || parts.length === 5 && ["services", "configuration", "runtime-logs", "issues", "routines"].includes(parts[4]!)); } catch { return false; }
}
export const runtimeWorkspacesCases = [runtimeDefinition("workspaces.locate-files", async ctx => {
  // The actual detail route is gated, independently of workspace realization.
  // Enable its supported UI fixture before the query, never after a bad link.
  if (!ctx.input.fixtures.company.issuePrefix) throw new Error("Workspace fixture has no public company prefix");
  await enableTaskWorkspaceView(ctx);
  return { ...await savedTaskWorkspace(ctx), companyPrefix: ctx.input.fixtures.company.issuePrefix };
}, gradeLocateFiles, {
  sourceFiles: ["chat-catalog-domains/runtime-workspaces.ts", "chat-catalog-domains/runtime-support.ts", "chat-scenarios/workspaces.yaml", "../../ui/src/components/IsolatedWorkspacesRouteGate.tsx", "../../ui/src/pages/ExecutionWorkspaceDetail.tsx"],
  expectedRunCount: 2, attemptTimeoutMs: 540_000, oracleVersion: "paperclip.chat-catalog.runtime.locate-files.v3",
  async observe(ctx, state) {
    const id = (state.task as Entity).id;
    state.workspaceAfter = await ctx.input.api.get<WorkspaceView>(`/api/issues/${id}/workspace`);
    const file = await ctx.input.api.get<{ content: { data: string } }>(`/api/issues/${id}/file-resources/content?workspace=execution&path=website-fixture.txt`);
    state.fileAfter = file.content.data;
    return observeRuntime(ctx, state);
  },
  async verifyResult(ctx, state, value) {
    const o = runtimeObservation(value); if (!o) throw new Error("Workspace result missing");
    const view = state.workspaceAfter as WorkspaceView;
    const prefix = state.companyPrefix;
    if (typeof prefix !== "string" || !prefix) throw new Error("Workspace view lost its actual company prefix");
    const links = workspaceResultLinks(o.reply, o.links);
    if (links.some(link => { try { return new URL(link, o.origin).pathname.includes("/execution-workspaces/")
      && !workspaceLink(o.origin, link, view.workspace.id, prefix); } catch { return false; } }))
      throw new Error("The actual reply supplied an incorrect workspace link");
    // Follow only the link the reply rendered; a typed URL would pass a reply the person cannot act on.
    const href = o.links.find(link => workspaceLink(o.origin, link, view.workspace.id, prefix));
    if (!href) throw new Error("The reply rendered no link to the bound workspace page");
    const source = ctx.input.page.url();
    await ctx.input.page.locator(`[id^="comment-"] a[href=${JSON.stringify(href)}]`).first().click();
    await expect(ctx.input.page).toHaveURL(new RegExp(`/${prefix}/execution-workspaces/${view.workspace.id}(?:[/?#]|$)`));
    await expect(ctx.input.page.getByRole("heading", { name: view.workspace.name, exact: true }).first()).toBeVisible();
    await ctx.input.evidence("runtime-task-workspace-opened.json", { taskId: (state.task as Entity).id, workspaceId: view.workspace.id, url: ctx.input.page.url() });
    await ctx.input.page.goto(source, { waitUntil: "domcontentloaded" });
  },
})];