import { getChannel, addMessage, type Message } from './db';

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

import { runConductor } from './mastra';

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

import type { ModelId, OllamaModel } from './workers/types';

const MENTION_RE = /@(glm|claude|codex|ollama)(?::(\S+))?/gi;

export interface Mention { model: ModelId; ollamaModel?: string; }

export function parseMentions(text: string): Mention[] {

  const out: Mention[] = [];

  let m: RegExpExecArray | null;

  MENTION_RE.lastIndex = 0;

  while ((m = MENTION_RE.exec(text)) !== null) {

    out.push({ model: m[1].toLowerCase() as ModelId, ollamaModel: m[2] });

  }

  return out;

}

const stripMentions = (text: string) => text.replace(MENTION_RE, '').replace(/\s{2,}/g, ' ').trim();

export async function handleMessage(channelId: string, userText: string): Promise<Message[]> {

  const ch = getChannel(channelId);

  if (!ch) throw new Error('channel not found');

  const userMsg = addMessage(channelId, 'user', userText, null);

  const mentions = parseMentions(userText);

  const targets: Mention[] = mentions.length ? mentions : [{ model: ch.default_model as ModelId }];

  const task = mentions.length ? stripMentions(userText) || userText : userText;

  const needsMemory = targets.some((t) => t.model === 'glm');

  const memoryContext = needsMemory ? await queryMemory(userText) : '';

  const produced: Message[] = [];

  for (const target of targets) {

    let reply = '';

    let authorModel: string = target.model;

    try {

      if (target.model === 'glm') {

        const graphContext = await queryGraph(userText);

        reply = await runConductor(userText, { memoryContext, graphContext });

      } else {

        const r = await delegate({

          model: target.model,

          ollamaModel: target.ollamaModel as OllamaModel | undefined,

          task,

        });

        authorModel = r.model;

        reply = r.ok ? r.output : `(${r.model} unavailable: ${r.error})`;

      }

    } catch (e) {

      reply = `(${target.model} error: ${(e as Error).message})`;

    }

    produced.push(addMessage(channelId, 'assistant', reply || '(empty reply)', authorModel, userMsg.id));

  }

  return produced;

}