import { test, expect } from "../../fixtures/ssh-test-base";
import {
  execInContainer,
  listRemoteDir,
  readRemoteFile,
  remotePathExists,
} from "../../helpers/ssh";
import { waitForLatestSessionDone } from "../../helpers/session";

/**
 * Full end-to-end task launch on the real sshd container. The smoke test
 * for the SSH executor: upload agentctl, mkdir the per-task dir, clone the
 * repo, launch the per-session agentctl, port-forward, run the agent to
 * completion, observe the on-remote filesystem layout.
 *
 * Covers e2e-plan.md group H (H1–H8).
 */
test.describe("ssh executor — task launch", () => {
  test("launches a session and records ssh runtime on the task environment", async ({
    apiClient,
    seedData,
  }) => {
    test.setTimeout(180_000);
    const task = await apiClient.createTaskWithAgent(
      seedData.workspaceId,
      "H1 launch",
      seedData.agentProfileId,
      {
        description: "/e2e:simple-message",
        workflow_id: seedData.workflowId,
        workflow_step_id: seedData.startStepId,
        repository_ids: [seedData.repositoryId],
        executor_profile_id: seedData.sshExecutorProfileId,
      },
    );

    await waitForLatestSessionDone(apiClient, task.id, 1, "Wait for first SSH session");

    const env = await apiClient.getTaskEnvironment(task.id);
    expect(env).not.toBeNull();
    expect(env!.executor_type).toBe("ssh");

    const row = (await apiClient.listSSHSessions(seedData.sshExecutorId)).find(
      (session) => session.task_id === task.id,
    );
    expect(row?.remote_task_dir).toBeTruthy();
    const workspace = row!.remote_task_dir!;
    expect(
      execInContainer(seedData.sshTarget, [
        "git",
        "-c",
        "safe.directory=*",
        "-C",
        workspace,
        "rev-parse",
        "--show-toplevel",
      ]).trim(),
    ).toBe(workspace);
    expect(
      execInContainer(seedData.sshTarget, [
        "git",
        "-c",
        "safe.directory=*",
        "-C",
        workspace,
        "branch",
        "--show-current",
      ]).trim(),
    ).not.toBe("main");
    expect(readRemoteFile(seedData.sshTarget, `${workspace}/remote-source.txt`)).toBe(
      "e2e-ssh fixture\n",
    );
  });

  test("runs custom prepare and terminal cleanup hooks on the remote workspace", async ({
    apiClient,
    seedData,
  }) => {
    test.setTimeout(180_000);
    const profile = await apiClient.createExecutorProfile(seedData.sshExecutorId, {
      name: "E2E SSH hooks",
      config: {},
      prepare_script: `#!/bin/bash
set -euo pipefail
workspace={{workspace.path}}
repository_url={{repository.clone_url}}
repository_branch={{repository.branch}}
git init -q "$workspace"
git -C "$workspace" remote add origin "$repository_url"
git -C "$workspace" fetch --no-tags origin "+refs/heads/$repository_branch:refs/remotes/origin/$repository_branch"
git -C "$workspace" checkout -b "$repository_branch" "origin/$repository_branch"
printf 'prepared\\n' > "$workspace/custom-prepare-marker"
`,
      cleanup_script: "printf 'cleaned\\n' > {{workspace.path}}/custom-cleanup-marker",
      env_vars: [],
    });

    try {
      const task = await apiClient.createTaskWithAgent(
        seedData.workspaceId,
        "SSH custom hooks",
        seedData.agentProfileId,
        {
          description: 'e2e:delay(30000)\ne2e:message("still running")',
          workflow_id: seedData.workflowId,
          workflow_step_id: seedData.startStepId,
          repository_ids: [seedData.repositoryId],
          executor_profile_id: profile.id,
        },
      );
      let workspace = "";
      await expect
        .poll(
          async () => {
            const row = (await apiClient.listSSHSessions(seedData.sshExecutorId)).find(
              (session) => session.task_id === task.id,
            );
            workspace = row?.remote_task_dir ?? "";
            return (
              workspace !== "" &&
              (row?.remote_agentctl_port ?? 0) > 0 &&
              (await apiClient.getTask(task.id)).state === "IN_PROGRESS" &&
              readRemoteFile(seedData.sshTarget, `${workspace}/custom-prepare-marker`) ===
                "prepared\n"
            );
          },
          {
            timeout: 60_000,
            message: "Wait for custom SSH prepare hook",
          },
        )
        .toBe(true);
      expect(remotePathExists(seedData.sshTarget, `${workspace}/custom-cleanup-marker`)).toBe(
        false,
      );

      await apiClient.archiveTask(task.id);
      await expect
        .poll(() => remotePathExists(seedData.sshTarget, `${workspace}/custom-cleanup-marker`), {
          timeout: 30_000,
          message: "Wait for terminal SSH cleanup hook",
        })
        .toBe(true);
      expect(remotePathExists(seedData.sshTarget, workspace)).toBe(true);
    } finally {
      await apiClient.deleteExecutorProfile(profile.id).catch(() => undefined);
    }
  });

  test("agentctl is uploaded on first launch and sha256 sidecar lands", async ({
    apiClient,
    seedData,
  }) => {
    test.setTimeout(180_000);
    const task = await apiClient.createTaskWithAgent(
      seedData.workspaceId,
      "H2 upload agentctl",
      seedData.agentProfileId,
      {
        description: "/e2e:simple-message",
        workflow_id: seedData.workflowId,
        workflow_step_id: seedData.startStepId,
        repository_ids: [seedData.repositoryId],
        executor_profile_id: seedData.sshExecutorProfileId,
      },
    );
    await waitForLatestSessionDone(apiClient, task.id, 1, "Wait for upload");

    expect(remotePathExists(seedData.sshTarget, "/home/kandev/.kandev/bin/agentctl")).toBe(true);
    expect(remotePathExists(seedData.sshTarget, "/home/kandev/.kandev/bin/agentctl.sha256")).toBe(
      true,
    );
    const sha = readRemoteFile(seedData.sshTarget, "/home/kandev/.kandev/bin/agentctl.sha256");
    expect(sha.trim()).toMatch(/^[0-9a-f]{64}$/);
  });

  test("second launch on the same host skips the upload (sha matches)", async ({
    apiClient,
    seedData,
  }) => {
    test.setTimeout(240_000);
    // First launch primes the cache.
    const first = await apiClient.createTaskWithAgent(
      seedData.workspaceId,
      "H3 first launch",
      seedData.agentProfileId,
      {
        description: "/e2e:simple-message",
        workflow_id: seedData.workflowId,
        workflow_step_id: seedData.startStepId,
        repository_ids: [seedData.repositoryId],
        executor_profile_id: seedData.sshExecutorProfileId,
      },
    );
    await waitForLatestSessionDone(apiClient, first.id, 1, "First launch");

    // Inspect mtime BEFORE the second launch.
    const beforeMtime = readRemoteFile(
      seedData.sshTarget,
      "/home/kandev/.kandev/bin/agentctl.sha256",
    );

    const second = await apiClient.createTaskWithAgent(
      seedData.workspaceId,
      "H3 second launch",
      seedData.agentProfileId,
      {
        description: "/e2e:simple-message",
        workflow_id: seedData.workflowId,
        workflow_step_id: seedData.startStepId,
        repository_ids: [seedData.repositoryId],
        executor_profile_id: seedData.sshExecutorProfileId,
      },
    );
    await waitForLatestSessionDone(apiClient, second.id, 1, "Second launch");

    // The sha256 file should be byte-identical (same hash, content reused).
    const afterMtime = readRemoteFile(
      seedData.sshTarget,
      "/home/kandev/.kandev/bin/agentctl.sha256",
    );
    expect(afterMtime).toBe(beforeMtime);
  });

  test("per-task workdir lives at <workdir>/tasks/<task-dir>/", async ({ apiClient, seedData }) => {
    test.setTimeout(180_000);
    const task = await apiClient.createTaskWithAgent(
      seedData.workspaceId,
      "H4 task workdir",
      seedData.agentProfileId,
      {
        description: "/e2e:simple-message",
        workflow_id: seedData.workflowId,
        workflow_step_id: seedData.startStepId,
        repository_ids: [seedData.repositoryId],
        executor_profile_id: seedData.sshExecutorProfileId,
      },
    );
    await waitForLatestSessionDone(apiClient, task.id, 1, "Wait for workdir");

    const sessions = await apiClient.listSSHSessions(seedData.sshExecutorId);
    const row = sessions.find((s) => s.task_id === task.id);
    expect(row?.remote_task_dir).toMatch(/\/tasks\/[^/]+$/);
    expect(remotePathExists(seedData.sshTarget, row!.remote_task_dir!)).toBe(true);
  });

  test("per-session runtime dir holds the agentctl pid and port files", async ({
    apiClient,
    seedData,
  }) => {
    test.setTimeout(180_000);
    const task = await apiClient.createTaskWithAgent(
      seedData.workspaceId,
      "H5 session runtime",
      seedData.agentProfileId,
      {
        description: "/e2e:simple-message",
        workflow_id: seedData.workflowId,
        workflow_step_id: seedData.startStepId,
        repository_ids: [seedData.repositoryId],
        executor_profile_id: seedData.sshExecutorProfileId,
      },
    );
    await waitForLatestSessionDone(apiClient, task.id, 1, "Wait for session runtime");

    const sessions = await apiClient.listSSHSessions(seedData.sshExecutorId);
    const row = sessions.find((s) => s.task_id === task.id);
    expect(row).toBeDefined();

    const sessionDir = `${row!.remote_task_dir}/.kandev/sessions/${row!.session_id}`;
    expect(remotePathExists(seedData.sshTarget, sessionDir)).toBe(true);
    const entries = listRemoteDir(seedData.sshTarget, sessionDir);
    // The wrapper writes the pid file and the log; the port travels via the
    // AGENTCTL_PORT env var and the ExecutorRunning metadata, not a file.
    expect(entries).toEqual(expect.arrayContaining(["agentctl.pid", "agentctl.log"]));
    expect(row!.remote_agentctl_port).toBeGreaterThan(0);
  });

  test("uploads path-mode attachments into the remote executor workspace", async ({
    apiClient,
    seedData,
  }) => {
    test.setTimeout(180_000);
    const content = "remote attachment bytes";
    const task = await apiClient.createTaskWithAgent(
      seedData.workspaceId,
      "H6 attachment upload",
      seedData.agentProfileId,
      {
        description: "Inspect the attached file.",
        workflow_id: seedData.workflowId,
        workflow_step_id: seedData.startStepId,
        repository_ids: [seedData.repositoryId],
        executor_profile_id: seedData.sshExecutorProfileId,
        attachments: [
          {
            type: "resource",
            data: Buffer.from(content, "utf8").toString("base64"),
            mime_type: "text/plain",
            name: "remote-note.txt",
            delivery_mode: "path",
          },
        ],
      },
    );
    await waitForLatestSessionDone(apiClient, task.id, 1, "Wait for attachment upload");

    await expect
      .poll(
        async () => {
          const sessions = await apiClient.listSSHSessions(seedData.sshExecutorId);
          return sessions.find((s) => s.task_id === task.id)?.remote_task_dir ?? "";
        },
        { timeout: 60_000, message: "Wait for SSH session row" },
      )
      .not.toBe("");

    const sessions = await apiClient.listSSHSessions(seedData.sshExecutorId);
    const row = sessions.find((s) => s.task_id === task.id);
    expect(row?.remote_task_dir).toBeTruthy();
    const savedPath = execInContainer(seedData.sshTarget, [
      "sh",
      "-c",
      `find ${JSON.stringify(row!.remote_task_dir)}/.kandev/attachments -name remote-note.txt -type f -print -quit`,
    ]).trim();
    expect(savedPath).toContain("/.kandev/attachments/");
    expect(readRemoteFile(seedData.sshTarget, savedPath)).toBe(content);
  });

  test("uploads path-mode attachments queued while the remote task is running", async ({
    apiClient,
    seedData,
  }) => {
    test.setTimeout(180_000);
    const content = "remote follow-up attachment bytes";
    const task = await apiClient.createTaskWithAgent(
      seedData.workspaceId,
      "H6 running attachment upload",
      seedData.agentProfileId,
      {
        description: "/slow 20s",
        workflow_id: seedData.workflowId,
        workflow_step_id: seedData.startStepId,
        repository_ids: [seedData.repositoryId],
        executor_profile_id: seedData.sshExecutorProfileId,
      },
    );
    if (!task.session_id) throw new Error("createTaskWithAgent did not return a session_id");

    const queueIdentity = await apiClient.getQueueSessionIdentity(task.id, task.session_id);
    await apiClient.queueMessage(queueIdentity, "Inspect the follow-up file.", [
      {
        type: "resource",
        data: Buffer.from(content, "utf8").toString("base64"),
        mime_type: "text/plain",
        name: "remote-followup.txt",
        delivery_mode: "path",
      },
    ]);

    await expect
      .poll(
        async () => {
          const sessions = await apiClient.listSSHSessions(seedData.sshExecutorId);
          return sessions.find((s) => s.task_id === task.id)?.remote_task_dir ?? "";
        },
        { timeout: 60_000, message: "Wait for SSH session row" },
      )
      .not.toBe("");

    const sessions = await apiClient.listSSHSessions(seedData.sshExecutorId);
    const row = sessions.find((s) => s.task_id === task.id);
    const taskDir = row?.remote_task_dir;
    expect(taskDir).toBeTruthy();

    const findAttachment = () =>
      execInContainer(seedData.sshTarget, [
        "sh",
        "-c",
        `find ${JSON.stringify(taskDir)}/.kandev/attachments -name remote-followup.txt -type f -print -quit 2>/dev/null || true`,
      ]).trim();

    await expect
      .poll(findAttachment, {
        timeout: 120_000,
        message: "Wait for queued attachment to upload remotely",
      })
      .not.toBe("");

    const attachmentPath = findAttachment();
    expect(attachmentPath).toContain("/.kandev/attachments/");
    expect(readRemoteFile(seedData.sshTarget, attachmentPath)).toBe(content);
  });

  test("stopping the session cleans up the session runtime dir but leaves the task dir", async ({
    apiClient,
    seedData,
    backend,
  }) => {
    test.setTimeout(180_000);
    await backend.ensureReady();
    const task = await apiClient.createTaskWithAgent(
      seedData.workspaceId,
      "H7 stop cleanup",
      seedData.agentProfileId,
      {
        description: "/e2e:simple-message",
        workflow_id: seedData.workflowId,
        workflow_step_id: seedData.startStepId,
        repository_ids: [seedData.repositoryId],
        executor_profile_id: seedData.sshExecutorProfileId,
      },
    );
    await waitForLatestSessionDone(apiClient, task.id, 1, "Wait before stop");

    const sessions = await apiClient.listSSHSessions(seedData.sshExecutorId);
    const row = sessions.find((s) => s.task_id === task.id);
    expect(row).toBeDefined();
    const sessionDir = `${row!.remote_task_dir}/.kandev/sessions/${row!.session_id}`;

    // Archive (or otherwise end) the task to trigger StopInstance.
    await apiClient.archiveTask(task.id);

    await expect
      .poll(() => remotePathExists(seedData.sshTarget, sessionDir), { timeout: 30_000 })
      .toBe(false);
    // Task dir intact — v1 spec, no auto-clean on last session stop.
    expect(remotePathExists(seedData.sshTarget, row!.remote_task_dir!)).toBe(true);
  });
});