import { describe, it, expect } from 'vitest';
import { createRegistry } from '../../../lib/ai/agent/registry.js';
import { runTurn } from '../../../lib/ai/agent/runtime.js';

function scriptedCallModel(steps) {
  let i = 0;
  return async ({ onTextDelta }) => {
    const step = steps[i++];
    if (step.text) for (const ch of step.text) onTextDelta?.(ch);
    return { text: step.text || '', toolUses: step.toolUses || [], stopReason: step.toolUses ? 'tool_use' : 'end_turn', usage: { output_tokens: 1 } };
  };
}

describe('runTurn', () => {
  it('runs a tool then produces a final answer', async () => {
    const reg = createRegistry();
    reg.registerTool({ name: 'search', description: 's', input_schema: { type: 'object', properties: {} },
      handler: async () => ({ results: [{ title: 'Hit' }] }) });

    const callModel = scriptedCallModel([
      { toolUses: [{ id: 'tu1', name: 'search', input: { q: 'x' } }] },
      { text: 'Found it.' }
    ]);

    const events = [];
    const out = await runTurn({
      callModel, registry: reg, system: 'sys',
      messages: [{ role: 'user', content: 'find x' }],
      ctx: { agent: { id: 'a' }, space_id: 's' },
      onEvent: e => events.push(e)
    });

    expect(out.text).toBe('Found it.');
    expect(events.filter(e => e.type === 'tool').map(e => e.tool)).toEqual(['search']);
    expect(events.some(e => e.type === 'delta' && e.text)).toBe(true);
    expect(out.toolTrace[0]).toMatchObject({ tool: 'search' });
  });

  it('emits a draft event when propose_change runs', async () => {
    const reg = createRegistry();
    reg.registerTool({ name: 'propose_change', description: 'p', input_schema: { type: 'object', properties: {} },
      handler: async () => ({ pending_change_id: 'pc1', applied: false, summary: 'create task "X"' }) });

    const callModel = scriptedCallModel([
      { toolUses: [{ id: 'tu1', name: 'propose_change', input: {} }] },
      { text: 'Drafted.' }
    ]);

    const events = [];
    const out = await runTurn({ callModel, registry: reg, system: 's',
      messages: [{ role: 'user', content: 'make a task' }],
      ctx: { agent: { id: 'a' } }, onEvent: e => events.push(e) });

    expect(out.draftIds).toEqual(['pc1']);
    expect(events.find(e => e.type === 'draft')).toMatchObject({ pending_change_id: 'pc1' });
  });

  it('stops at the iteration guard', async () => {
    const reg = createRegistry();
    reg.registerTool({ name: 'search', description: 's', input_schema: { type: 'object', properties: {} },
      handler: async () => ({ results: [] }) });
    const always = async () => ({ text: '', toolUses: [{ id: 't', name: 'search', input: {} }], stopReason: 'tool_use', usage: {} });
    const out = await runTurn({ callModel: always, registry: reg, system: 's',
      messages: [{ role: 'user', content: 'loop' }], ctx: { agent: { id: 'a' } }, onEvent: () => {}, maxIterations: 3 });
    expect(out.toolTrace.length).toBe(3);
    expect(out.stoppedOnGuard).toBe(true);
  });
});