import { describe, it, afterEach, mock } from 'node:test';
import assert from 'node:assert/strict';
import { mkdtempSync, mkdirSync, rmSync } from 'fs';
import { tmpdir } from 'os';
import { join } from 'path';
import Database from 'better-sqlite3';
import { OpenCodeAdapter } from '../src/engine/opencode-adapter.js';

// ─── Helpers ──────────────────────────────────────────────────────────────────

/**
 * Create an ephemeral OpenCode-format SQLite DB under $XDG_DATA_HOME/opencode/
 * and snapshot the original XDG_DATA_HOME so we can restore it after the test.
 *
 * Returns { restoreEnv, dbDir, dbPath } where restoreEnv restores XDG_DATA_HOME
 * and cleans up the temp directory.
 */
function withTestDb({ sessions = [], messages = [], parts = [] } = {}) {
  const tmpDir = mkdtempSync(join(tmpdir(), 'oc-adapter-test-'));
  const opencodeDir = join(tmpDir, 'opencode');
  mkdirSync(opencodeDir, { recursive: true });
  const dbPath = join(opencodeDir, 'opencode.db');
  const db = new Database(dbPath, { timeout: 5000 });
  db.exec(`
    CREATE TABLE IF NOT EXISTS session (
      id TEXT PRIMARY KEY,
      parent_id TEXT,
      slug TEXT,
      directory TEXT,
      path TEXT,
      title TEXT,
      agent TEXT,
      model TEXT,
      version TEXT,
      cost REAL,
      tokens_input INTEGER,
      tokens_output INTEGER,
      tokens_reasoning INTEGER,
      tokens_cache_read INTEGER,
      tokens_cache_write INTEGER,
      time_created INTEGER,
      time_updated INTEGER,
      time_compacting INTEGER,
      time_archived INTEGER,
      summary_additions INTEGER,
      summary_deletions INTEGER,
      summary_files INTEGER,
      metadata TEXT
    );
    CREATE TABLE IF NOT EXISTS message (
      id TEXT PRIMARY KEY,
      session_id TEXT,
      time_created INTEGER,
      time_updated INTEGER,
      data TEXT
    );
    CREATE TABLE IF NOT EXISTS part (
      id TEXT PRIMARY KEY,
      message_id TEXT,
      session_id TEXT,
      time_created INTEGER,
      time_updated INTEGER,
      data TEXT
    );
  `);

  const insertSession = db.prepare(`
    INSERT INTO session (id, parent_id, slug, directory, path, title, agent, model, version,
                         cost, tokens_input, tokens_output, tokens_reasoning,
                         tokens_cache_read, tokens_cache_write,
                         time_created, time_updated, time_compacting, time_archived,
                         summary_additions, summary_deletions, summary_files, metadata)
    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
  `);

  for (const s of sessions) {
    insertSession.run(
      s.id, s.parent_id ?? null, s.slug ?? '', s.directory ?? '', s.path ?? '',
      s.title ?? '', s.agent ?? '', s.model ?? '', s.version ?? '',
      s.cost ?? 0, s.tokens_input ?? 0, s.tokens_output ?? 0,
      s.tokens_reasoning ?? 0, s.tokens_cache_read ?? 0, s.tokens_cache_write ?? 0,
      s.time_created ?? 0, s.time_updated ?? 0, s.time_compacting ?? null,
      s.time_archived ?? null, s.summary_additions ?? 0, s.summary_deletions ?? 0,
      s.summary_files ?? 0, s.metadata ?? null
    );
  }

  const insertMsg = db.prepare(`
    INSERT INTO message (id, session_id, time_created, time_updated, data)
    VALUES (?, ?, ?, ?, ?)
  `);
  for (const m of messages) {
    insertMsg.run(m.id, m.session_id, m.time_created ?? 0, m.time_updated ?? 0, m.data ?? '{}');
  }

  const insertPart = db.prepare(`
    INSERT INTO part (id, message_id, session_id, time_created, time_updated, data)
    VALUES (?, ?, ?, ?, ?, ?)
  `);
  for (const p of parts) {
    insertPart.run(p.id, p.message_id, p.session_id, p.time_created ?? 0, p.time_updated ?? 0, p.data ?? '{}');
  }

  db.close();

  const origXdg = process.env.XDG_DATA_HOME;
  process.env.XDG_DATA_HOME = tmpDir;

  return {
    restoreEnv() {
      if (origXdg === undefined) {
        delete process.env.XDG_DATA_HOME;
      } else {
        process.env.XDG_DATA_HOME = origXdg;
      }
      try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
    },
    dbDir: tmpDir,
    dbPath,
  };
}

// ─── Tests ────────────────────────────────────────────────────────────────────

describe('OpenCodeAdapter health state', () => {
  let env;

  afterEach(() => {
    if (env) env.restoreEnv();
  });

  it('reports session_source_available=true after successful empty-DB refresh', async () => {
    env = withTestDb({ sessions: [] });
    const adapter = new OpenCodeAdapter();

    await adapter.refresh();

    const health = adapter.getHealthInfo();
    assert.equal(health.session_source_available, true,
      'empty DB with correct schema should report available');
    assert.equal(health.session_count, 0);
  });

  it('reports session_source_available=false when no DB file exists', async () => {
    const adapter = new OpenCodeAdapter();

    // Mock _findDataDir so it sets null paths without falling through to the real DB
    mock.method(adapter, '_findDataDir', function () {
      this._dataDir = null;
      this._dbPath = null;
      this._reason = 'Mocked: no DB file';
    });

    await adapter.refresh();

    const health = adapter.getHealthInfo();
    assert.equal(health.session_source_available, false);
    assert.equal(health.session_count, 0);

    mock.restoreAll();
  });
});

describe('OpenCodeAdapter production tool fixture', () => {
  let env;

  afterEach(() => {
    if (env) env.restoreEnv();
  });

  it('parses production type=tool parts and returns correct timeline and count', async () => {
    const sessionId = 'ses_prod_tool_test_001';
    const msgId = 'msg_prod_001';
    const now = Date.now();

    env = withTestDb({
      sessions: [{
        id: sessionId,
        title: 'Production Tool Test',
        time_created: now - 60000,
        time_updated: now,
        tokens_input: 150,
        tokens_output: 300,
      }],
      messages: [{
        id: msgId,
        session_id: sessionId,
        time_created: now - 50000,
        time_updated: now - 50000,
        data: JSON.stringify({ role: 'assistant' }),
      }],
      parts: [
        {
          id: 'part_prod_001',
          message_id: msgId,
          session_id: sessionId,
          time_created: now - 50000,
          time_updated: now - 50000,
          data: JSON.stringify({ type: 'text', text: 'Let me search the codebase…' }),
        },
        {
          id: 'part_prod_002',
          message_id: msgId,
          session_id: sessionId,
          time_created: now - 49000,
          time_updated: now - 49000,
          data: JSON.stringify({
            type: 'tool',
            tool: 'codebaseSearch',
            state: {
              input: { query: 'findSessions' },
              status: 'completed',
              output: 'Found 3 results\n- session1\n- session2\n- session3',
            },
          }),
        },
        {
          id: 'part_prod_003',
          message_id: msgId,
          session_id: sessionId,
          time_created: now - 48000,
          time_updated: now - 48000,
          data: JSON.stringify({
            type: 'tool',
            tool: 'readFile',
            state: {
              input: { path: '/tmp/test.txt' },
              status: 'completed',
              output: 'file content line 1\nfile content line 2',
            },
          }),
        },
        {
          id: 'part_prod_004',
          message_id: msgId,
          session_id: sessionId,
          time_created: now - 47000,
          time_updated: now - 47000,
          data: JSON.stringify({ type: 'text', text: 'Here are the results…' }),
        },
      ],
    });

    const adapter = new OpenCodeAdapter();
    await adapter.refresh();

    // Check session-level tool_call_count
    const session = adapter.getSession(sessionId);
    assert.ok(session, 'session should be found');
    assert.equal(session.tool_call_count, 2, 'should count both tool parts');
    assert.deepEqual(session.tool_calls, { codebaseSearch: 1, readFile: 1 });

    // Check getMessages returns full timeline with correct ordering
    const messages = await adapter.getMessages(sessionId);
    assert.ok(Array.isArray(messages));

    // Expected ordering: text("Let me search…"), tool_call(codebaseSearch),
    //   tool_output(Fount 3 results…), tool_call(readFile),
    //   tool_output("file content…"), text("Here are the results…")
    assert.equal(messages.length, 6,
      'timeline: text + tool_call + tool_output + tool_call + tool_output + text');

    // Verify types and content in order
    assert.equal(messages[0].type, 'assistant_message');
    assert.ok(messages[0].message.includes('Let me search'));

    assert.equal(messages[1].type, 'tool_call');
    assert.equal(messages[1].name, 'codebaseSearch');

    assert.equal(messages[2].type, 'tool_output');
    assert.ok(messages[2].output_preview.includes('Found 3 results'));

    assert.equal(messages[3].type, 'tool_call');
    assert.equal(messages[3].name, 'readFile');

    assert.equal(messages[4].type, 'tool_output');
    assert.ok(messages[4].output_preview.includes('file content'));

    assert.equal(messages[5].type, 'assistant_message');
    assert.ok(messages[5].message.includes('results'));
  });
});

describe('OpenCodeAdapter session filtering (child/archived)', () => {
  let env;

  afterEach(() => {
    if (env) env.restoreEnv();
  });

  it('getSession returns null for child sessions', async () => {
    const parentId = 'ses_parent_001';
    const childId = 'ses_child_001';
    const now = Date.now();

    env = withTestDb({
      sessions: [
        {
          id: parentId, parent_id: null,
          title: 'Parent', time_created: now - 100000, time_updated: now,
        },
        {
          id: childId, parent_id: parentId,
          title: 'Child', time_created: now - 50000, time_updated: now,
        },
      ],
    });

    const adapter = new OpenCodeAdapter();
    await adapter.refresh();

    // After refresh, only parent should be in the sessions list
    assert.ok(adapter.getSession(parentId), 'parent session should be found');
    assert.equal(adapter.getSession(childId), null, 'child session should not be found in list');

    // Fallback getSession also rejects children (direct DB lookup filters parent_id)
    const fromDb = adapter.getSession(childId);
    assert.equal(fromDb, null, 'getSession fallback should reject child');
  });

  it('getSession returns null for archived sessions', async () => {
    const activeId = 'ses_active_001';
    const archivedId = 'ses_archived_001';
    const now = Date.now();

    env = withTestDb({
      sessions: [
        {
          id: activeId, parent_id: null, time_archived: null,
          title: 'Active', time_created: now - 100000, time_updated: now,
        },
        {
          id: archivedId, parent_id: null, time_archived: now - 10000,
          title: 'Archived', time_created: now - 200000, time_updated: now - 10000,
        },
      ],
    });

    const adapter = new OpenCodeAdapter();
    await adapter.refresh();

    assert.ok(adapter.getSession(activeId), 'active session should be found');
    assert.equal(adapter.getSession(archivedId), null, 'archived session should not be found');
  });
});

describe('OpenCodeAdapter CLI-based deletion (isolated, no real CLI)', () => {
  let env;

  afterEach(() => {
    if (env) env.restoreEnv();
  });

  it('can_delete is false when CLI is unavailable', async () => {
    const now = Date.now();
    env = withTestDb({
      sessions: [{
        id: 'ses_del_test_001',
        title: 'Delete Test',
        time_created: now - 60000,
        time_updated: now,
      }],
    });

    const adapter = new OpenCodeAdapter();

    // Mock _detectCli so it does not find the CLI
    mock.method(adapter, '_detectCli', function () {
      this.cliAvailable = false;
      this._reason = 'Mocked: no CLI';
    });

    await adapter.refresh();

    const session = adapter.getSession('ses_del_test_001');
    assert.ok(session);
    assert.equal(session.can_delete, false, 'can_delete should be false when CLI is unavailable');

    mock.restoreAll();
  });
});