import "./styles.css";

import { createApiClient } from "./api.js";
import {
  type ApprovalDecisionAction,
  type DoctorCheck,
  type RunSummary,
  approvalDecisionActions,
  compactPath,
  formatDateTime,
  highestDoctorStatus,
  screenFromHash,
  screens,
  stateTone,
} from "./view-model.js";

interface TemplateSummary {
  id: string;
  name: string;
  version: number;
  hash: string;
  definition: { phases?: unknown[]; roles?: unknown[] };
}

interface PersonaSummary {
  id: string;
  name: string;
  version: number;
  hash: string;
  definition: { backend?: string; capabilities?: unknown[]; maxRiskLevel?: string };
}

interface RunStatus {
  run: RunSummary & {
    worktreeRoot: string;
    finalReportPath: string | null;
  };
  phases: Array<{ id: string; phaseKey: string; state: string; attempts: number }>;
  approvals: Array<{ id: string; gateKey: string; state: string; phaseId: string | null }>;
  eventsTail: Array<{ seq: string; type: string; ts: string; payload: unknown }>;
}

interface SessionSummary {
  id: string;
  roleId: string;
  backend: string;
  cwd: string;
  state: string;
  expectedArtifactPath: string | null;
  expectedSchema: string | null;
  lastPromptAt: string | null;
  recoveryAttempts: number;
  tmuxSession: string | null;
  tmuxWindow: string | null;
}

const api = createApiClient(import.meta.env.VITE_API_BASE);
const appRoot = document.querySelector<HTMLDivElement>("#app");

if (appRoot === null) {
  throw new Error("Missing #app root");
}
const app = appRoot;

let activeRunId: string | undefined;
let activeRunStatus: RunStatus | undefined;
let activeRunSessions: SessionSummary[] = [];
let connectedRunId: string | undefined;
let doctorChecks: DoctorCheck[] = [];
let eventSource: EventSource | undefined;
let liveEvents: string[] = [];
const approvalErrors = new Map<string, string>();
const approvalTokens = new Map<string, string>();

window.addEventListener("hashchange", () => {
  void render();
});

void render();

async function render(): Promise<void> {
  const screen = screenFromHash(window.location.hash);
  app.innerHTML = shell(screen, "Loading");
  try {
    doctorChecks = await loadDoctorChecks();
    if (screen === "dashboard") {
      await renderDashboard();
    } else if (screen === "run-detail") {
      await renderRunDetailScreen();
    } else if (screen === "approvals") {
      await renderApprovalsScreen();
    } else if (screen === "sessions") {
      await renderSessionsScreen();
    } else if (screen === "templates") {
      await renderTemplates();
    } else if (screen === "personas") {
      await renderPersonas();
    } else {
      await renderNewRun();
    }
  } catch (error) {
    app.innerHTML = shell(screen, errorBanner(error));
  }
}

async function renderDashboard(): Promise<void> {
  const { runs, sessions, status } = await loadActiveRunData();
  app.innerHTML = shell(
    "dashboard",
    `
      ${doctorPanel()}
      <section class="band split">
        <div>
          <div class="section-title">
            <h2>Runs</h2>
            <button class="small" data-action="refresh">Refresh</button>
          </div>
          ${runsTable(runs)}
        </div>
        <div>
          <div class="section-title">
            <h2>Run Detail</h2>
            ${activeRunId === undefined ? "" : `<span class="mono">${escapeHtml(activeRunId)}</span>`}
          </div>
          ${status === undefined ? empty("No run selected") : runDetail(status, sessions)}
        </div>
      </section>
    `,
  );
  bindDashboardActions();
  connectRunStream(activeRunId);
}

async function renderRunDetailScreen(): Promise<void> {
  const { runs, sessions, status } = await loadActiveRunData();
  app.innerHTML = shell(
    "run-detail",
    `
      <section class="band split">
        <div>
          <div class="section-title"><h2>Runs</h2><button class="small" data-action="refresh">Refresh</button></div>
          ${runsTable(runs)}
        </div>
        <div>
          <div class="section-title"><h2>Run Detail</h2>${activeRunId === undefined ? "" : `<span class="mono">${escapeHtml(activeRunId)}</span>`}</div>
          ${status === undefined ? empty("No run selected") : runDetail(status, sessions)}
        </div>
      </section>
    `,
  );
  bindDashboardActions();
  connectRunStream(activeRunId);
}

async function renderApprovalsScreen(): Promise<void> {
  const { runs, status } = await loadActiveRunData();
  app.innerHTML = shell(
    "approvals",
    `
      <section class="band split">
        <div>
          <div class="section-title"><h2>Runs</h2><button class="small" data-action="refresh">Refresh</button></div>
          ${runsTable(runs)}
        </div>
        <div>
          <div class="section-title"><h2>Approvals</h2>${activeRunId === undefined ? "" : `<span class="mono">${escapeHtml(activeRunId)}</span>`}</div>
          ${
            status === undefined || status.approvals.length === 0
              ? empty("No approvals")
              : `<table><tbody>${status.approvals.map(approvalRow).join("")}</tbody></table>`
          }
        </div>
      </section>
    `,
  );
  bindDashboardActions();
  connectRunStream(activeRunId);
}

async function renderSessionsScreen(): Promise<void> {
  const { runs, sessions } = await loadActiveRunData();
  app.innerHTML = shell(
    "sessions",
    `
      <section class="band split">
        <div>
          <div class="section-title"><h2>Runs</h2><button class="small" data-action="refresh">Refresh</button></div>
          ${runsTable(runs)}
        </div>
        <div>
          <div class="section-title"><h2>TUI Sessions</h2>${activeRunId === undefined ? "" : `<span class="mono">${escapeHtml(activeRunId)}</span>`}</div>
          ${sessions.length === 0 ? empty("No sessions") : sessionsTable(sessions)}
        </div>
      </section>
    `,
  );
  bindDashboardActions();
  connectRunStream(activeRunId);
}

async function renderTemplates(): Promise<void> {
  const { templates } = await api.get<{ templates: TemplateSummary[] }>("/api/templates");
  app.innerHTML = shell(
    "templates",
    `
      <section class="band">
        <div class="section-title"><h2>Templates</h2><span>${templates.length} loaded</span></div>
        <table>
          <thead><tr><th>Name</th><th>Version</th><th>Roles</th><th>Phases</th><th>Hash</th></tr></thead>
          <tbody>
            ${templates
              .map(
                (template) => `
                  <tr>
                    <td>${escapeHtml(template.name)}</td>
                    <td>${template.version}</td>
                    <td>${arrayLength(template.definition.roles)}</td>
                    <td>${arrayLength(template.definition.phases)}</td>
                    <td class="mono">${escapeHtml(template.hash.slice(0, 16))}</td>
                  </tr>
                `,
              )
              .join("")}
          </tbody>
        </table>
      </section>
    `,
  );
}

async function renderPersonas(): Promise<void> {
  const { personas } = await api.get<{ personas: PersonaSummary[] }>("/api/personas");
  app.innerHTML = shell(
    "personas",
    `
      <section class="band">
        <div class="section-title"><h2>Personas</h2><span>${personas.length} loaded</span></div>
        <table>
          <thead><tr><th>Name</th><th>Version</th><th>Backend</th><th>Risk</th><th>Capabilities</th></tr></thead>
          <tbody>
            ${personas
              .map(
                (persona) => `
                  <tr>
                    <td>${escapeHtml(persona.name)}</td>
                    <td>${persona.version}</td>
                    <td>${escapeHtml(persona.definition.backend ?? "")}</td>
                    <td>${escapeHtml(persona.definition.maxRiskLevel ?? "")}</td>
                    <td>${arrayLength(persona.definition.capabilities)}</td>
                  </tr>
                `,
              )
              .join("")}
          </tbody>
        </table>
      </section>
    `,
  );
}

async function renderNewRun(): Promise<void> {
  const [{ templates }, { personas }] = await Promise.all([
    api.get<{ templates: TemplateSummary[] }>("/api/templates"),
    api.get<{ personas: PersonaSummary[] }>("/api/personas"),
  ]);
  app.innerHTML = shell(
    "new-run",
    `
      <section class="band new-run">
        <div class="section-title">
          <h2>New Run</h2>
          <span>${templates.length} templates · ${personas.length} personas</span>
        </div>
        <form id="new-run-form">
          <label>Requirements<textarea name="requirementsMd" rows="8" required></textarea></label>
          <div class="form-grid">
            <label>Repository path<input name="repoPath" required /></label>
            <label>Base branch<input name="baseBranch" value="main" required /></label>
            <label>Template name<input name="templateName" value="development" /></label>
            <label>Template version<input name="templateVersion" type="number" value="1" min="1" /></label>
          </div>
          <label>Scenarios JSON<textarea name="scenarios" rows="5" placeholder='{"spec":"ok","phase_plan":"ok"}'></textarea></label>
          <div class="actions"><button type="submit">Start Run</button><span id="form-status"></span></div>
        </form>
      </section>
    `,
  );
  bindNewRunForm();
}

function shell(active: string, content: string): string {
  return `
    <header>
      <div>
        <h1>Devflow</h1>
        <p>Local workflow control plane</p>
      </div>
      <nav>
        ${screens
          .map(
            (screen) =>
              `<a class="${screen === active ? "active" : ""}" href="#/${screen}">${screenLabel(screen)}</a>`,
          )
          .join("")}
      </nav>
    </header>
    <main>${content}</main>
  `;
}

function doctorPanel(): string {
  const status = highestDoctorStatus(doctorChecks);
  const visible = doctorChecks.filter((check) => check.status !== "pass");
  return `
    <section class="doctor ${status}">
      <strong>Doctor</strong>
      ${
        visible.length === 0
          ? "<span>All visible checks pass</span>"
          : visible
              .map((check) => `<span>${escapeHtml(check.name)}: ${escapeHtml(check.detail)}</span>`)
              .join("")
      }
    </section>
  `;
}

function runsTable(runs: RunSummary[]): string {
  if (runs.length === 0) {
    return empty("No runs yet");
  }
  return `
    <table>
      <thead><tr><th>State</th><th>Repo</th><th>Branch</th><th>Created</th><th></th></tr></thead>
      <tbody>
        ${runs
          .map(
            (run) => `
              <tr class="${run.id === activeRunId ? "selected" : ""}">
                <td><span class="pill ${stateTone(run.state)}">${escapeHtml(run.state)}</span></td>
                <td title="${escapeHtml(run.repoPath)}">${escapeHtml(compactPath(run.repoPath))}</td>
                <td>${escapeHtml(run.baseBranch)}</td>
                <td>${escapeHtml(formatDateTime(run.createdAt))}</td>
                <td><button class="small" data-run-id="${escapeHtml(run.id)}">Open</button></td>
              </tr>
            `,
          )
          .join("")}
      </tbody>
    </table>
  `;
}

function runDetail(status: RunStatus, sessions: SessionSummary[]): string {
  return `
    <div class="detail-grid">
      <div><span>State</span><strong class="pill ${stateTone(status.run.state)}">${escapeHtml(status.run.state)}</strong></div>
      <div><span>Worktree</span><strong title="${escapeHtml(status.run.worktreeRoot)}">${escapeHtml(compactPath(status.run.worktreeRoot))}</strong></div>
      <div><span>Final report</span><strong>${escapeHtml(status.run.finalReportPath ?? "")}</strong></div>
    </div>
    <h3>Phases</h3>
    <table>
      <thead><tr><th>Phase</th><th>State</th><th>Attempts</th></tr></thead>
      <tbody>
        ${status.phases
          .map(
            (phase) =>
              `<tr><td>${escapeHtml(phase.phaseKey)}</td><td>${escapeHtml(phase.state)}</td><td>${phase.attempts}</td></tr>`,
          )
          .join("")}
      </tbody>
    </table>
    <h3>Approvals</h3>
    ${
      status.approvals.length === 0
        ? empty("No approvals")
        : `<table><tbody>${status.approvals.map(approvalRow).join("")}</tbody></table>`
    }
    <h3>TUI Sessions</h3>
    ${sessions.length === 0 ? empty("No sessions") : sessionsTable(sessions)}
    <h3>Event Tail</h3>
    <pre>${escapeHtml([...status.eventsTail.map((event) => `${event.seq} ${event.type}`), ...liveEvents].slice(-40).join("\n"))}</pre>
  `;
}

function sessionsTable(sessions: SessionSummary[]): string {
  return `<table>
    <thead><tr><th>Role</th><th>Backend</th><th>State</th><th>CWD</th><th>Artifact</th><th>Recovery</th></tr></thead>
    <tbody>${sessions.map(sessionRow).join("")}</tbody>
  </table>`;
}

function sessionRow(session: SessionSummary): string {
  const artifact =
    session.expectedArtifactPath === null
      ? ""
      : `${session.expectedSchema ?? ""} ${compactPath(session.expectedArtifactPath)}`;
  return `
    <tr>
      <td>${escapeHtml(session.roleId)}</td>
      <td>${escapeHtml(session.backend)}</td>
      <td><span class="pill ${stateTone(session.state)}">${escapeHtml(session.state)}</span></td>
      <td title="${escapeHtml(session.cwd)}">${escapeHtml(compactPath(session.cwd))}</td>
      <td title="${escapeHtml(session.expectedArtifactPath ?? "")}">${escapeHtml(artifact)}</td>
      <td>${session.recoveryAttempts}</td>
    </tr>
  `;
}

function approvalRow(approval: RunStatus["approvals"][number]): string {
  const disabled = approval.state !== "pending" ? "disabled" : "";
  const actionCells = approvalDecisionActions
    .map((action) => approvalButton(approval.id, action, disabled))
    .join("");
  const error = approvalDecisionActions
    .map((action) => approvalErrors.get(approvalActionKey(approval.id, action)))
    .find((message) => message !== undefined);
  return `
    <tr>
      <td>${escapeHtml(approval.gateKey)}</td>
      <td>${escapeHtml(approval.state)}</td>
      <td class="approval-actions">
        ${actionCells}
      </td>
    </tr>
    ${error === undefined ? "" : `<tr><td colspan="3" class="error">${escapeHtml(error)}</td></tr>`}
  `;
}

function approvalButton(
  approvalId: string,
  action: ApprovalDecisionAction,
  disabled: string,
): string {
  const danger = action === "reject" || action === "abort" ? " danger" : "";
  return `<button class="small${danger}" data-approval="${escapeHtml(approvalId)}" data-action="${action}" ${disabled}>${approvalActionLabel(action)}</button>`;
}

function approvalActionLabel(action: ApprovalDecisionAction): string {
  if (action === "request_changes") {
    return "Request Changes";
  }
  return action.slice(0, 1).toUpperCase() + action.slice(1);
}

function bindDashboardActions(): void {
  document.querySelector('[data-action="refresh"]')?.addEventListener("click", () => {
    void render();
  });
  for (const button of document.querySelectorAll<HTMLButtonElement>("[data-run-id]")) {
    button.addEventListener("click", () => {
      activeRunId = button.dataset.runId;
      liveEvents = [];
      void render();
    });
  }
  for (const button of document.querySelectorAll<HTMLButtonElement>("[data-approval]")) {
    button.addEventListener("click", async () => {
      const action = parseApprovalAction(button.dataset.action);
      if (activeRunId === undefined || button.dataset.approval === undefined || action === null) {
        return;
      }
      const key = approvalActionKey(button.dataset.approval, action);
      const clientToken = approvalTokens.get(key) ?? crypto.randomUUID();
      approvalTokens.set(key, clientToken);
      disableApprovalButtons(button.dataset.approval);
      try {
        await api.post(`/api/runs/${activeRunId}/approvals/${button.dataset.approval}`, {
          action,
          clientToken,
        });
        approvalTokens.delete(key);
        approvalErrors.delete(key);
        await render();
      } catch (error) {
        approvalErrors.set(key, error instanceof Error ? error.message : String(error));
        await render();
      }
    });
  }
}

function parseApprovalAction(value: string | undefined): ApprovalDecisionAction | null {
  return approvalDecisionActions.includes(value as ApprovalDecisionAction)
    ? (value as ApprovalDecisionAction)
    : null;
}

function approvalActionKey(approvalId: string, action: ApprovalDecisionAction): string {
  return `${approvalId}:${action}`;
}

function disableApprovalButtons(approvalId: string): void {
  for (const button of document.querySelectorAll<HTMLButtonElement>("[data-approval]")) {
    if (button.dataset.approval === approvalId) {
      button.disabled = true;
    }
  }
}

function bindNewRunForm(): void {
  document
    .querySelector<HTMLFormElement>("#new-run-form")
    ?.addEventListener("submit", async (event) => {
      event.preventDefault();
      const form = event.currentTarget as HTMLFormElement;
      const data = new FormData(form);
      const status = document.querySelector("#form-status");
      try {
        const scenariosText = stringFormValue(data, "scenarios");
        const body = {
          baseBranch: stringFormValue(data, "baseBranch"),
          repoPath: stringFormValue(data, "repoPath"),
          requirementsMd: stringFormValue(data, "requirementsMd"),
          templateName: stringFormValue(data, "templateName"),
          templateVersion: Number(stringFormValue(data, "templateVersion")),
          ...(scenariosText.length === 0
            ? {}
            : { scenarios: JSON.parse(scenariosText) as unknown }),
        };
        const result = await api.post<{ runId: string }>("/api/runs", body);
        activeRunId = result.runId;
        window.location.hash = "#/dashboard";
      } catch (error) {
        if (status !== null) {
          status.textContent = error instanceof Error ? error.message : String(error);
        }
      }
    });
}

function connectRunStream(runId: string | undefined): void {
  if (eventSource !== undefined && connectedRunId === runId) {
    return;
  }
  eventSource?.close();
  eventSource = undefined;
  connectedRunId = undefined;
  if (runId === undefined) {
    return;
  }
  const source = new EventSource(api.sseUrl(`/sse/runs/${runId}`));
  source.addEventListener("run.event_appended", (event) => {
    const payload = JSON.parse(String((event as MessageEvent).data)) as { type?: string };
    liveEvents.push(`live ${payload.type ?? "event"}`);
    if (liveEvents.length > 50) {
      liveEvents = liveEvents.slice(-50);
    }
    void Promise.all([loadRunStatus(runId), loadRunSessions(runId)]).then(([status, sessions]) => {
      activeRunStatus = status;
      activeRunSessions = sessions;
      const main = document.querySelector("main");
      const screen = screenFromHash(window.location.hash);
      if (
        main !== null &&
        (screen === "dashboard" ||
          screen === "run-detail" ||
          screen === "approvals" ||
          screen === "sessions")
      ) {
        void render();
      }
    });
  });
  source.addEventListener("transcript.chunk_appended", (event) => {
    const payload = JSON.parse(String((event as MessageEvent).data)) as { content?: string };
    liveEvents.push(`transcript ${payload.content ?? ""}`);
  });
  eventSource = source;
  connectedRunId = runId;
}

async function loadDoctorChecks(): Promise<DoctorCheck[]> {
  try {
    const response = await api.get<{ checks: DoctorCheck[] }>("/api/doctor");
    return response.checks;
  } catch {
    return [
      {
        detail: "API doctor endpoint unavailable",
        name: "api",
        remediation: "Start apps/api or configure VITE_API_BASE.",
        status: "warn",
      },
    ];
  }
}

async function loadRunStatus(runId: string): Promise<RunStatus> {
  return api.get<RunStatus>(`/api/runs/${runId}`);
}

async function loadActiveRunData(): Promise<{
  runs: RunSummary[];
  sessions: SessionSummary[];
  status: RunStatus | undefined;
}> {
  const { runs } = await api.get<{ runs: RunSummary[] }>("/api/runs");
  if (activeRunId === undefined && runs[0] !== undefined) {
    activeRunId = runs[0].id;
  }
  if (activeRunId === undefined) {
    activeRunStatus = undefined;
    activeRunSessions = [];
    return { runs, sessions: [], status: undefined };
  }
  const [status, sessions] = await Promise.all([
    loadRunStatus(activeRunId),
    loadRunSessions(activeRunId),
  ]);
  activeRunStatus = status;
  activeRunSessions = sessions;
  return { runs, sessions, status };
}

async function loadRunSessions(runId: string): Promise<SessionSummary[]> {
  const response = await api.get<{ sessions: SessionSummary[] }>(`/api/runs/${runId}/sessions`);
  return response.sessions;
}

function screenLabel(screen: string): string {
  if (screen === "new-run") {
    return "New Run";
  }
  if (screen === "run-detail") {
    return "Run Detail";
  }
  if (screen === "sessions") {
    return "TUI Sessions";
  }
  return screen
    .split("-")
    .map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`)
    .join(" ");
}

function stringFormValue(data: FormData, key: string): string {
  const value = data.get(key);
  return typeof value === "string" ? value : "";
}

function arrayLength(value: unknown): number {
  return Array.isArray(value) ? value.length : 0;
}

function empty(text: string): string {
  return `<div class="empty">${escapeHtml(text)}</div>`;
}

function errorBanner(error: unknown): string {
  return `<section class="doctor fail"><strong>Error</strong><span>${escapeHtml(error instanceof Error ? error.message : String(error))}</span></section>`;
}

function escapeHtml(value: string): string {
  return value
    .replaceAll("&", "&amp;")
    .replaceAll("<", "&lt;")
    .replaceAll(">", "&gt;")
    .replaceAll('"', "&quot;")
    .replaceAll("'", "&#39;");
}