import type { StartStep, WorkflowDefinition } from "@uncaged/nerve-core";
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 { moderator } from "./moderator.js";
import type { WorkflowMeta } from "./moderator.js";
import { buildImplementRole } from "./roles/implement/index.js";
import { buildPlanRole } from "./roles/plan/index.js";
import { prepareMetaSchema } from "./roles/prepare/index.js";
import { preparePrompt } from "./roles/prepare/prompt.js";
import { buildPublishRole } from "./roles/publish/index.js";
import { readIssueMetaSchema } from "./roles/read-issue/index.js";
import { readIssuePrompt } from "./roles/read-issue/prompt.js";
import { reviewMetaSchema } from "./roles/review/index.js";
import { reviewPrompt } from "./roles/review/prompt.js";
import { testMetaSchema } from "./roles/test/index.js";
import { testPrompt } from "./roles/test/prompt.js";

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

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

  const agentRoles = {
    "read-issue": {
      adapter: hermesAdapter,
      prompt: async (start: StartStep) => readIssuePrompt({ threadId: start.meta.threadId }),
      meta: zodMeta(readIssueMetaSchema),
    },
    prepare: {
      adapter: hermesAdapter,
      prompt: async (start: StartStep) => preparePrompt({ threadId: start.meta.threadId }),
      meta: zodMeta(prepareMetaSchema),
    },
    review: {
      adapter: hermesAdapter,
      prompt: async (start: StartStep) =>
        reviewPrompt({ threadId: start.meta.threadId, nerveRoot }),
      meta: zodMeta(reviewMetaSchema),
    },
    test: {
      adapter: hermesAdapter,
      prompt: async (start: StartStep) => testPrompt({ threadId: start.meta.threadId }),
      meta: zodMeta(testMetaSchema),
    },
  };

  return {
    name: "solve-issue",
    roles: {
      "read-issue": compileRoleSpec(agentRoles["read-issue"], deps),
      prepare: compileRoleSpec(agentRoles.prepare, deps),
      plan: buildPlanRole({ provider, nerveRoot }),
      implement: buildImplementRole({ provider, nerveRoot }),
      review: compileRoleSpec(agentRoles.review, deps),
      test: compileRoleSpec(agentRoles.test, deps),
      publish: buildPublishRole({ provider, nerveRoot }),
    },
    moderator,
  };
}