/**
 * MCP project-resolution regression tests (issue #196).
 *
 * When an MCP client launches the server outside the project directory AND
 * doesn't pass a `rootUri`/`workspaceFolders` in `initialize`, the server used
 * to fall straight back to `process.cwd()` — which for many IDE clients is the
 * wrong directory. Every tool call without an explicit `projectPath` then
 * failed with a misleading "CodeGraph not initialized. Run 'codegraph init'."
 *
 * The fix: when no explicit path is provided, the server asks the client for
 * its workspace root via the spec-blessed `roots/list` request (if the client
 * advertised the `roots` capability), and only falls back to cwd otherwise.
 * When it still can't resolve, the error now says exactly how to fix it.
 *
 * These tests drive the real stdio transport via a spawned subprocess — no
 * mocking — so they also exercise the new bidirectional request/response path.
 */
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { spawn, ChildProcessWithoutNullStreams } from 'child_process';
import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
import { CodeGraph } from '../src';

const BIN = path.resolve(__dirname, '../dist/bin/codegraph.js');

function spawnServer(cwd: string): ChildProcessWithoutNullStreams {
  // --no-watch keeps the test deterministic and avoids watcher startup noise.
  return spawn(process.execPath, [BIN, 'serve', '--mcp', '--no-watch'], {
    cwd,
    stdio: ['pipe', 'pipe', 'pipe'],
  }) as ChildProcessWithoutNullStreams;
}

/** Parse every JSON-RPC message the server writes to stdout into an array. */
function collectMessages(child: ChildProcessWithoutNullStreams): Array<Record<string, any>> {
  const messages: Array<Record<string, any>> = [];
  let buf = '';
  child.stdout.on('data', (chunk) => {
    buf += chunk.toString('utf8');
    let idx;
    while ((idx = buf.indexOf('\n')) !== -1) {
      const line = buf.slice(0, idx).trim();
      buf = buf.slice(idx + 1);
      if (!line) continue;
      try { messages.push(JSON.parse(line)); } catch { /* ignore non-JSON */ }
    }
  });
  return messages;
}

function waitForMessage(
  messages: ReadonlyArray<Record<string, any>>,
  predicate: (m: Record<string, any>) => boolean,
  timeoutMs: number,
): Promise<Record<string, any>> {
  return new Promise((resolve, reject) => {
    const started = Date.now();
    const tick = () => {
      const hit = messages.find(predicate);
      if (hit) return resolve(hit);
      if (Date.now() - started > timeoutMs) {
        return reject(new Error(`Timed out. Messages so far: ${JSON.stringify(messages)}`));
      }
      setTimeout(tick, 20);
    };
    tick();
  });
}

function send(child: ChildProcessWithoutNullStreams, msg: object): void {
  child.stdin.write(JSON.stringify(msg) + '\n');
}

const CLIENT_INFO = { name: 'test', version: '0.0.0' };

describe('MCP project resolution via roots/list (issue #196)', () => {
  let cwdDir: string;     // where the server is launched — has NO .codegraph
  let projectDir: string; // the real indexed project the client reports
  let child: ChildProcessWithoutNullStreams | null = null;

  beforeEach(() => {
    cwdDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-mcp-cwd-'));
    projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-mcp-proj-'));
  });

  afterEach(() => {
    if (child && !child.killed) {
      child.kill('SIGKILL');
      child = null;
    }
    fs.rmSync(cwdDir, { recursive: true, force: true });
    fs.rmSync(projectDir, { recursive: true, force: true });
  });

  it('resolves the project from the client roots/list when no rootUri is sent', async () => {
    const cg = await CodeGraph.init(projectDir);
    cg.close();

    child = spawnServer(cwdDir);
    const messages = collectMessages(child);

    // Advertise the roots capability but pass NO rootUri/workspaceFolders.
    send(child, {
      jsonrpc: '2.0', id: 0, method: 'initialize',
      params: { protocolVersion: '2025-11-25', capabilities: { roots: {} }, clientInfo: CLIENT_INFO },
    });
    await waitForMessage(messages, (m) => m.id === 0 && !!m.result, 5000);
    send(child, { jsonrpc: '2.0', method: 'notifications/initialized' });

    // First tool call (no projectPath) drives the server to ask us for roots.
    send(child, { jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'codegraph_status', arguments: {} } });

    const rootsReq = await waitForMessage(messages, (m) => m.method === 'roots/list', 5000);
    expect(typeof rootsReq.id).toBe('string'); // server-initiated id
    send(child, {
      jsonrpc: '2.0', id: rootsReq.id,
      result: { roots: [{ uri: `file://${projectDir}`, name: 'proj' }] },
    });

    // The status call now succeeds against the resolved project.
    const resp = await waitForMessage(messages, (m) => m.id === 1, 8000);
    const text = resp.result.content[0].text as string;
    expect(text).toContain('CodeGraph Status');
    expect(text).not.toContain('No CodeGraph project is loaded');
  }, 20000);

  it('returns an actionable error when there is no rootUri and no roots capability', async () => {
    child = spawnServer(cwdDir);
    const messages = collectMessages(child);

    send(child, {
      jsonrpc: '2.0', id: 0, method: 'initialize',
      params: { protocolVersion: '2025-11-25', capabilities: {}, clientInfo: CLIENT_INFO },
    });
    await waitForMessage(messages, (m) => m.id === 0 && !!m.result, 5000);
    send(child, { jsonrpc: '2.0', method: 'notifications/initialized' });

    send(child, { jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'codegraph_status', arguments: {} } });
    const resp = await waitForMessage(messages, (m) => m.id === 1, 8000);
    const text = resp.result.content[0].text as string;

    expect(text).toContain('No CodeGraph project is loaded');
    expect(text).toContain('projectPath');
    expect(text).toContain('--path');
    // Names the directory it actually searched (the wrong cwd) so the user can
    // see why detection missed. basename survives any symlink realpath-ing.
    expect(text).toContain(path.basename(cwdDir));
    // It must not have hung waiting on roots/list — the client never offered it.
    expect(messages.some((m) => m.method === 'roots/list')).toBe(false);
  }, 20000);

  it('honors an explicit rootUri without asking the client for roots', async () => {
    const cg = await CodeGraph.init(projectDir);
    cg.close();

    child = spawnServer(cwdDir);
    const messages = collectMessages(child);

    send(child, {
      jsonrpc: '2.0', id: 0, method: 'initialize',
      params: {
        protocolVersion: '2025-11-25',
        capabilities: { roots: {} },
        clientInfo: CLIENT_INFO,
        rootUri: `file://${projectDir}`,
      },
    });
    await waitForMessage(messages, (m) => m.id === 0 && !!m.result, 5000);
    send(child, { jsonrpc: '2.0', method: 'notifications/initialized' });

    send(child, { jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'codegraph_status', arguments: {} } });
    const resp = await waitForMessage(messages, (m) => m.id === 1, 8000);
    const text = resp.result.content[0].text as string;

    expect(text).toContain('CodeGraph Status');
    // rootUri is a stronger signal than roots — we never needed to ask.
    expect(messages.some((m) => m.method === 'roots/list')).toBe(false);
  }, 20000);
});