import type { StartStep, WorkflowDefinition } from "@uncaged/nerve-core";
import { createCursorAdapter } from "@uncaged/nerve-adapter-cursor";
import { hermesAdapter } from "@uncaged/nerve-adapter-hermes";
import type { LlmProvider } from "@uncaged/nerve-workflow-utils";

import { compileRoleSpec, defaultAgentCreateContext, zodMeta } from "../_shared/rfc003-compile.js";
import { createAskCursorAdapter } from "../_shared/cursor-ask-adapter.js";

import { coderPrompt } from "./roles/coder/prompt.js";
import { coderMetaSchema } from "./roles/coder/index.js";
import { plannerPrompt } from "./roles/planner/prompt.js";
import { plannerMetaSchema } from "./roles/planner/index.js";
import { reviewerPrompt } from "./roles/reviewer/prompt.js";
import { reviewerMetaSchema } from "./roles/reviewer/index.js";
import { testerPrompt } from "./roles/tester/prompt.js";
import { testerMetaSchema } from "./roles/tester/index.js";
import { buildCommitterRole } from "./roles/committer/index.js";
import { moderator } from "./moderator.js";
import type { WorkflowMeta } from "./moderator.js";

export type BuildWorkflowGeneratorDeps = {
  provider: LlmProvider;
  nerveRoot: string;
};

const CURSOR_TIMEOUT_MS = 300_000;

export function buildWorkflowGenerator({
  provider,
  nerveRoot,
}: BuildWorkflowGeneratorDeps): WorkflowDefinition<WorkflowMeta> {
  const createContext = defaultAgentCreateContext(nerveRoot);
  const deps = { provider, createContext };

  const agentRoles = {
    planner: {
      adapter: createAskCursorAdapter({ model: "auto", timeout: CURSOR_TIMEOUT_MS }),
      prompt: async (start: StartStep) => plannerPrompt({ threadId: start.meta.threadId }),
      meta: zodMeta(plannerMetaSchema),
    },
    coder: {
      adapter: createCursorAdapter({
        type: "cursor",
        model: "auto",
        timeout: CURSOR_TIMEOUT_MS,
      }),
      prompt: async (start: StartStep) => coderPrompt({ threadId: start.meta.threadId }),
      meta: zodMeta(coderMetaSchema),
    },
    reviewer: {
      adapter: hermesAdapter,
      prompt: async (start: StartStep) =>
        reviewerPrompt({ threadId: start.meta.threadId, nerveRoot }),
      meta: zodMeta(reviewerMetaSchema),
    },
    tester: {
      adapter: hermesAdapter,
      prompt: async (start: StartStep) =>
        testerPrompt({ threadId: start.meta.threadId, nerveRoot }),
      meta: zodMeta(testerMetaSchema),
    },
  };

  return {
    name: "develop-workflow",
    roles: {
      planner: compileRoleSpec(agentRoles.planner, deps),
      coder: compileRoleSpec(agentRoles.coder, deps),
      reviewer: compileRoleSpec(agentRoles.reviewer, deps),
      tester: compileRoleSpec(agentRoles.tester, deps),
      committer: buildCommitterRole({ nerveRoot }),
    },
    moderator,
  };
}