/**
 * Smoke tests: Agent resource CRUD + thread management against a live mcpd.
 *
 * Validates Stages 1-5 end-to-end without requiring a live LLM upstream:
 *   1. Create a secret + Llm referencing it.
 *   2. Create an Agent pinned to that Llm with defaultParams.
 *   3. `mcpctl get agents` shows the row; describe pretty-prints it.
 *   4. `mcpctl get agent foo -o yaml | apply -f -` round-trips identically.
 *   5. POST /api/v1/agents/:name/threads creates a thread; GET lists it.
 *   6. Cleanup leaves the underlying Llm/Secret intact.
 *
 * Actual chat turns (which require a live LLM) live in agent-chat.smoke.test.ts
 * and are gated on MCPCTL_SMOKE_LLM_URL being set.
 */
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import http from 'node:http';
import https from 'node:https';
import { execSync } from 'node:child_process';
import { writeFileSync, unlinkSync, mkdtempSync } from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';

const MCPD_URL = process.env.MCPD_URL ?? 'https://mcpctl.ad.itaz.eu';
const SUFFIX = Date.now().toString(36);
const SECRET_NAME = `smoke-agent-sec-${SUFFIX}`;
const LLM_NAME = `smoke-agent-llm-${SUFFIX}`;
const AGENT_NAME = `smoke-agent-${SUFFIX}`;

interface CliResult { code: number; stdout: string; stderr: string }

function run(args: string): CliResult {
  try {
    const stdout = execSync(`mcpctl --direct ${args}`, {
      encoding: 'utf-8',
      timeout: 30_000,
      stdio: ['ignore', 'pipe', 'pipe'],
    });
    return { code: 0, stdout: stdout.trim(), stderr: '' };
  } catch (err) {
    const e = err as { status?: number; stdout?: Buffer | string; stderr?: Buffer | string };
    return {
      code: e.status ?? 1,
      stdout: e.stdout ? (typeof e.stdout === 'string' ? e.stdout : e.stdout.toString('utf-8')) : '',
      stderr: e.stderr ? (typeof e.stderr === 'string' ? e.stderr : e.stderr.toString('utf-8')) : '',
    };
  }
}

function healthz(url: string, timeoutMs = 5000): Promise<boolean> {
  return new Promise((resolve) => {
    const parsed = new URL(`${url.replace(/\/$/, '')}/healthz`);
    const driver = parsed.protocol === 'https:' ? https : http;
    const req = driver.get(
      {
        hostname: parsed.hostname,
        port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
        path: parsed.pathname,
        timeout: timeoutMs,
      },
      (res) => { resolve((res.statusCode ?? 500) < 500); res.resume(); },
    );
    req.on('error', () => resolve(false));
    req.on('timeout', () => { req.destroy(); resolve(false); });
  });
}

let mcpdUp = false;

describe('agent smoke', () => {
  beforeAll(async () => {
    mcpdUp = await healthz(MCPD_URL);
    if (!mcpdUp) {
      // eslint-disable-next-line no-console
      console.warn(`\n  ○ agent smoke: skipped — ${MCPD_URL}/healthz unreachable.\n`);
    }
  }, 20_000);

  afterAll(() => {
    if (!mcpdUp) return;
    run(`delete agent ${AGENT_NAME}`);
    run(`delete llm ${LLM_NAME}`);
    run(`delete secret ${SECRET_NAME}`);
  });

  it('creates a secret to back the Llm api key', () => {
    if (!mcpdUp) return;
    run(`delete secret ${SECRET_NAME}`);
    const result = run(`create secret ${SECRET_NAME} --data API_KEY=sk-fake-smoke`);
    expect(result.code, result.stderr).toBe(0);
  });

  it('creates an Llm pinned to that secret', () => {
    if (!mcpdUp) return;
    run(`delete llm ${LLM_NAME}`);
    const result = run([
      `create llm ${LLM_NAME}`,
      '--type openai',
      '--model gpt-4o-mini',
      '--url http://localhost:9999',
      `--api-key-ref ${SECRET_NAME}/API_KEY`,
    ].join(' '));
    expect(result.code, result.stderr).toBe(0);
  });

  it('creates an agent pinned to that Llm with sampling defaults', () => {
    if (!mcpdUp) return;
    run(`delete agent ${AGENT_NAME}`);
    const result = run([
      `create agent ${AGENT_NAME}`,
      `--llm ${LLM_NAME}`,
      `--description "smoke agent for end-to-end CRUD"`,
      `--system-prompt "You are a smoke-test agent."`,
      '--default-temperature 0.2',
      '--default-max-tokens 512',
    ].join(' '));
    expect(result.code, result.stderr || result.stdout).toBe(0);
    expect(result.stdout).toMatch(new RegExp(`agent '${AGENT_NAME}'`));
  });

  it('lists the agent in `get agents`', () => {
    if (!mcpdUp) return;
    const result = run('get agents -o json');
    expect(result.code).toBe(0);
    const rows = JSON.parse(result.stdout) as Array<{ name: string; llm: { name: string }; defaultParams: { temperature?: number } }>;
    const row = rows.find((r) => r.name === AGENT_NAME);
    expect(row, `agent ${AGENT_NAME} must be present`).toBeDefined();
    expect(row!.llm.name).toBe(LLM_NAME);
    expect(row!.defaultParams.temperature).toBe(0.2);
  });

  it('round-trips yaml output through apply -f without diff', () => {
    if (!mcpdUp) return;
    const yaml = run(`get agent ${AGENT_NAME} -o yaml`);
    expect(yaml.code).toBe(0);
    expect(yaml.stdout).toMatch(/kind:\s+agent/i);
    expect(yaml.stdout).toContain(`name: ${AGENT_NAME}`);

    const dir = mkdtempSync(join(tmpdir(), 'mcpctl-agent-smoke-'));
    const path = join(dir, 'agent.yaml');
    const amended = yaml.stdout.replace(
      'smoke agent for end-to-end CRUD',
      'smoke agent (amended)',
    );
    writeFileSync(path, amended);
    try {
      const applied = run(`apply -f ${path}`);
      expect(applied.code, applied.stderr || applied.stdout).toBe(0);
      const second = run(`get agent ${AGENT_NAME} -o json`);
      // `mcpctl get <resource> <name> -o json` always returns an array (one
      // element when fetching a single item) — formatted via toApplyDocs so it
      // round-trips through `apply -f`.
      const parsed = JSON.parse(second.stdout) as Array<{ description: string }>;
      expect(parsed[0]!.description).toBe('smoke agent (amended)');
    } finally {
      unlinkSync(path);
    }
  });

  it('creates a chat thread and the agent lists it', async () => {
    if (!mcpdUp) return;
    const create = await httpRequest('POST', `${MCPD_URL}/api/v1/agents/${AGENT_NAME}/threads`, {
      title: 'smoke thread',
    });
    expect(create.status).toBe(201);
    const created = JSON.parse(create.body) as { id: string };
    expect(created.id).toMatch(/^c[a-z0-9]+/);

    const list = await httpRequest('GET', `${MCPD_URL}/api/v1/agents/${AGENT_NAME}/threads`, undefined);
    expect(list.status).toBe(200);
    const threads = JSON.parse(list.body) as Array<{ id: string; title: string }>;
    expect(threads.some((t) => t.id === created.id && t.title === 'smoke thread')).toBe(true);

    const messages = await httpRequest('GET', `${MCPD_URL}/api/v1/threads/${created.id}/messages`, undefined);
    expect(messages.status).toBe(200);
    expect(JSON.parse(messages.body)).toEqual([]);
  });

  it('deletes the agent and leaves the underlying Llm + secret intact', () => {
    if (!mcpdUp) return;
    const del = run(`delete agent ${AGENT_NAME}`);
    expect(del.code, del.stderr).toBe(0);

    const llm = run(`describe llm ${LLM_NAME}`);
    expect(llm.code).toBe(0);
  });
});

interface HttpResponse { status: number; body: string }

/**
 * Async HTTP helper. Authenticates using the same token the CLI carries via
 * `mcpctl --direct` (read from ~/.mcpctl/credentials.json).
 */
function httpRequest(method: string, urlStr: string, body: unknown): Promise<HttpResponse> {
  return new Promise((resolve, reject) => {
    const tokenRaw = readToken();
    const parsed = new URL(urlStr);
    const driver = parsed.protocol === 'https:' ? https : http;
    const headers: Record<string, string> = {
      Accept: 'application/json',
      ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
      ...(tokenRaw !== null ? { Authorization: `Bearer ${tokenRaw}` } : {}),
    };
    const req = driver.request({
      hostname: parsed.hostname,
      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
      path: parsed.pathname + parsed.search,
      method,
      headers,
      timeout: 15_000,
    }, (res) => {
      const chunks: Buffer[] = [];
      res.on('data', (c: Buffer) => chunks.push(c));
      res.on('end', () => {
        resolve({ status: res.statusCode ?? 0, body: Buffer.concat(chunks).toString('utf-8') });
      });
    });
    req.on('error', reject);
    req.on('timeout', () => { req.destroy(); reject(new Error(`httpRequest timeout: ${method} ${urlStr}`)); });
    if (body !== undefined) req.write(JSON.stringify(body));
    req.end();
  });
}

function readToken(): string | null {
  try {
    const home = process.env.HOME ?? '';
    const path = `${home}/.mcpctl/credentials`;
    // eslint-disable-next-line @typescript-eslint/no-require-imports
    const fs = require('node:fs') as typeof import('node:fs');
    if (!fs.existsSync(path)) return null;
    const raw = fs.readFileSync(path, 'utf-8');
    const parsed = JSON.parse(raw) as { token?: string };
    return parsed.token ?? null;
  } catch {
    return null;
  }
}
