import { Agent } from '@mastra/core/agent';

import { createTool } from '@mastra/core/tools';

import { z } from 'zod';

import { glmModel, PM_BRAIN_MODEL } from './glm';

import { queryMemory, queryGraph } from './memory';

import { delegate } from './workers/delegate';

import { createTask, updateTask, draftOutbox } from './db';

const delegateTool = createTool({

  id: 'delegate',

  description: 'Delegate a self-contained task to a worker model (claude=strong/CT215, codex=strong/CT241, ollama=local/free). Use for heavy or parallel work. Returns the worker output.',

  inputSchema: z.object({

    model: z.enum(['claude', 'codex', 'ollama']).describe('worker model'),

    task: z.string().describe('self-contained work envelope'),

    ollamaModel: z.string().optional().describe('required iff model=ollama, e.g. mistral-nemo:12b'),

    context: z.string().optional().describe('RAG/graph snippets to inject'),

  }),

  execute: async ({ context }) => {

    const c = context as unknown as { model: 'claude' | 'codex' | 'ollama'; task: string; ollamaModel?: string; context?: string };

    const r = await delegate({ model: c.model, task: c.task, ollamaModel: c.ollamaModel, context: c.context });

    return { ok: r.ok, model: r.model, output: r.output, error: r.error };

  },

});

const createTaskTool = createTool({

  id: 'createTask',

  description: 'Create a Board task (kanban card).',

  inputSchema: z.object({

    title: z.string(),

    status: z.enum(['todo', 'doing', 'done', 'blocked']).optional(),

    assignedModel: z.string().optional(),

    channelId: z.string().optional(),

  }),

  execute: async ({ context }) => {

    const c = context as unknown as { title: string; status?: string; assignedModel?: string; channelId?: string };

    const t = createTask(c.title, { status: c.status, assignedModel: c.assignedModel ?? null, channelId: c.channelId ?? null });

    return { id: t.id, title: t.title, status: t.status };

  },

});

const updateTaskTool = createTool({

  id: 'updateTask',

  description: 'Update a Board task status/assignment.',

  inputSchema: z.object({

    id: z.string(),

    status: z.enum(['todo', 'doing', 'done', 'blocked']).optional(),

    assignedModel: z.string().optional(),

    title: z.string().optional(),

  }),

  execute: async ({ context }) => {

    const c = context as unknown as { id: string; status?: string; assignedModel?: string; title?: string };

    const t = updateTask(c.id, { status: c.status, assignedModel: c.assignedModel, title: c.title });

    return t ? { id: t.id, status: t.status } : { error: 'task not found' };

  },

});

const draftApprovalTool = createTool({

  id: 'draftApproval',

  description: 'Draft an OUTWARD action (email|deploy|publish|infra) into the approval outbox. NEVER auto-sends - Zion approves in the UI. Use for anything leaving the homelab.',

  inputSchema: z.object({

    actionType: z.enum(['email', 'deploy', 'publish', 'infra']),

    payload: z.record(z.string(), z.any()).describe('action details'),

  }),

  execute: async ({ context }) => {

    const c = context as unknown as { actionType: string; payload: Record<string, unknown> };

    const o = draftOutbox(c.actionType, c.payload);

    return { id: o.id, status: o.status, note: 'drafted, awaiting human approval' };

  },

});

const queryMemoryTool = createTool({

  id: 'queryMemory',

  description: 'RAG-first: query the homelab memory (docs, configs, infra, project history) BEFORE reading files.',

  inputSchema: z.object({ query: z.string() }),

  execute: async ({ context }) => ({ context: await queryMemory((context as unknown as { query: string })?.query ?? '') }),

});

const queryGraphTool = createTool({

  id: 'queryGraph',

  description: 'Query the code-architecture graph (cbm-homelab): structure, call graph, blast radius.',

  inputSchema: z.object({ query: z.string() }),

  execute: async ({ context }) => ({ graph: await queryGraph((context as unknown as { query: string })?.query ?? '') }),

});

const INSTRUCTIONS = `You are the Zion PM conductor - the project-manager brain for Zion's homelab, running on GLM (${PM_BRAIN_MODEL}).

Your job: take any task, decompose it, delegate work to the worker fleet, supervise, and gate every OUTWARD action behind the approval outbox.

Operating rules (non-negotiable):

- GROUNDING: base every homelab/architecture fact STRICTLY on the "Homelab memory" and "Code graph" context provided in the message. NEVER invent services, tech, or infra. If the context does not cover something, say "not in memory" rather than guessing.

- Delegate heavy/parallel work via the delegate tool: claude (strong, CT215), codex (strong, CT241), ollama (local, free). You are the brain - you do NOT do worker execution yourself.

- Every OUTWARD action (email, deploy, publish, infra change) MUST go through draftApproval - it drafts only, never sends. Internal delegation and task edits are full-auto.

- OUTPUT: answer directly in the exact format requested (e.g. exactly N bullets). No preamble, no narration of your reasoning or tools - only the final answer.

- Track real work as Board tasks via createTask/updateTask when it helps.`;

void queryMemoryTool;

void queryGraphTool;

export const pmConductor = new Agent({

  name: 'pmConductor',

  instructions: INSTRUCTIONS,

  model: glmModel,

  tools: { delegate: delegateTool, createTask: createTaskTool, updateTask: updateTaskTool, draftApproval: draftApprovalTool },

});

export async function runConductor(

  userText: string,

  opts: { memoryContext?: string; graphContext?: string } = {}

): Promise<string> {

  const parts: string[] = [];

  if (opts.memoryContext) parts.push(`# Homelab memory (queryMemory)\n${opts.memoryContext}`);

  if (opts.graphContext) parts.push(`# Code graph (queryGraph)\n${opts.graphContext}`);

  parts.push(`# Task from Zion\n${userText}`);

  parts.push('Answer using ONLY the context above. Output only the final answer in the exact format requested - no preamble, no tool/reasoning narration.');

  const prompt = parts.join('\n\n');

  const res = await pmConductor.generate(prompt, { maxSteps: 3 });

  return ((res as { text?: string }).text ?? '').trim();

}