import { convexTest } from "convex-test";
import { anyApi } from "convex/server";
import { describe, expect, test } from "vitest";

import schema from "./schema";

const modules = import.meta.glob("./**/*.ts");
const api = anyApi;

describe("real work execution persistence", () => {
  test("records revisions, activity, diff, and terminal state atomically", async () => {
    const t = convexTest({ modules, schema });
    const seeded = await t.run(async (ctx) => {
      const organizationId = await ctx.db.insert("organizations", {
        createdAt: 1,
        createdBy: "user",
        kind: "personal",
        name: "Personal",
      });
      const projectId = await ctx.db.insert("projects", {
        createdAt: 1,
        name: "Zopu",
        normalizedSourceUrl: "https://example.com/zopu",
        organizationId,
        repositoryPath: "puter/zopu",
        sourceHost: "example.com",
        sourceUrl: "https://example.com/zopu",
        updatedAt: 1,
      });
      const workId = await ctx.db.insert("works", {
        createdAt: 1,
        objective: "Implement a real slice",
        organizationId,
        projectId,
        status: "executing",
        title: "Real execution",
        updatedAt: 1,
      });
      const sliceRowId = await ctx.db.insert("workSlices", {
        designVersion: 1,
        objective: "Change the repo",
        observableBehavior: "A diff exists",
        ordinal: 0,
        payloadJson: "{}",
        sliceId: "slice-1",
        status: "running",
        title: "Implementation",
        workId,
      });
      const runId = await ctx.db.insert("workRuns", {
        createdAt: 1,
        designVersion: 1,
        executionKind: "real",
        kitId: "coding-v0",
        kitVersion: "1",
        scenario: "success",
        sliceId: "slice-1",
        sliceRowId,
        status: "running",
        workId,
      });
      const attemptId = await ctx.db.insert("workAttempts", {
        number: 1,
        runId,
        status: "running",
        workId,
        workspaceKey: "workspace-1",
      });
      return { attemptId, runId, workId };
    });

    await t.mutation(api.workExecutionWorkflow.completeAttempt, {
      attemptId: seeded.attemptId,
      result: {
        baseRevision: "base123",
        candidateRevision: "candidate456",
        changedFiles: ["src/index.ts"],
        diff: "+export const ready = true;",
        environmentId: "workspace-1",
        events: [
          {
            kind: "runtime.completed",
            message: "completed",
            metadata: {},
            occurredAt: 2,
            sequence: 0,
          },
        ],
        summary: "Changed one file",
      },
    });

    const state = await t.run(async (ctx) => ({
      artifacts: await ctx.db.query("workArtifacts").collect(),
      attempt: await ctx.db.get(seeded.attemptId),
      run: await ctx.db.get(seeded.runId),
      work: await ctx.db.get(seeded.workId),
    }));
    expect(state.attempt?.classification).toBe("Succeeded");
    expect(state.run).toMatchObject({
      baseRevision: "base123",
      candidateRevision: "candidate456",
      terminalClassification: "Succeeded",
    });
    expect(state.work?.status).toBe("completed");
    expect(state.artifacts[0]).toMatchObject({
      kind: "diff",
      sourceRevision: "candidate456",
    });
  });
});