import type { DelegateParams, DelegateResult, ModelId } from './types';

import { claudeAdapter } from './claude';

import { codexAdapter } from './codex';

import { ollamaAdapter } from './ollama';

import { getCap, touchCap, addMessage } from '../db';

const TIER: ModelId[] = ['claude', 'codex', 'ollama'];

const ADAPTERS: Record<Exclude<ModelId, 'glm'>, (p: DelegateParams) => Promise<DelegateResult>> = {

  claude: claudeAdapter,

  codex: codexAdapter,

  ollama: ollamaAdapter,

};

function nextAvailable(from: ModelId): ModelId | null {

  const startIdx = Math.max(0, TIER.indexOf(from));

  for (let i = startIdx; i < TIER.length; i++) {

    const m = TIER[i];

    const cap = getCap(m);

    if (cap && cap.available === 1) return m;

  }

  return null;

}

export async function delegate(

  params: DelegateParams,

  opts: { channelId?: string; allowFallback?: boolean } = {}

): Promise<DelegateResult & { model: ModelId }> {

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

    return { ok: false, output: '', artifacts: [], error: 'glm is the conductor, not a worker', durationMs: 0, model: 'glm' };

  }

  let model: ModelId = params.model;

  const cap = getCap(model);

  if (!cap || cap.available !== 1) {

    if (opts.allowFallback === false) {

      return { ok: false, output: '', artifacts: [], error: `${model} unavailable and fallback disabled`, durationMs: 0, model };

    }

    const fb = nextAvailable(model);

    if (!fb) {

      return { ok: false, output: '', artifacts: [], error: 'no available worker in tier', durationMs: 0, model };

    }

    model = fb;

  }

  const adapter = ADAPTERS[model as Exclude<ModelId, 'glm'>];

  const result = await adapter({ ...params, model });

  touchCap(model);

  if (opts.channelId && result.output) {

    addMessage(opts.channelId, 'assistant', result.output, model);

  }

  return { ...result, model };

}