import { sql } from 'kysely';
import { afterEach, describe, expect, it } from 'vitest';

import { createDatabase } from '../src/adapters/dialect';
import { initializeSchema } from '../src/core/migrations';

const openConnections: Array<() => Promise<void>> = [];

afterEach(async () => {
  while (openConnections.length > 0) {
    const close = openConnections.pop();
    if (close) {
      await close();
    }
  }
});

describe('initializeSchema', () => {
  it('creates the topics, facts, and fact_topics tables', async () => {
    const connection = await createDatabase({ client: 'sqlite', filename: ':memory:' });
    openConnections.push(connection.destroy);

    await initializeSchema(connection.db);

    const tables = await sql<{ name: string }>`
      SELECT name
      FROM sqlite_master
      WHERE type = 'table'
      ORDER BY name
    `.execute(connection.db);

    const tableNames = tables.rows.map((row) => row.name);

    expect(tableNames).toContain('topics');
    expect(tableNames).toContain('facts');
    expect(tableNames).toContain('fact_topics');
  });

  it('creates the expected columns for each table', async () => {
    const connection = await createDatabase({ client: 'sqlite', filename: ':memory:' });
    openConnections.push(connection.destroy);

    await initializeSchema(connection.db);

    const topicsColumns = await sql<{ name: string }>`PRAGMA table_info(topics)`.execute(connection.db);
    const factsColumns = await sql<{ name: string }>`PRAGMA table_info(facts)`.execute(connection.db);
    const factTopicsColumns = await sql<{ name: string }>`PRAGMA table_info(fact_topics)`.execute(connection.db);

    expect(topicsColumns.rows.map((row) => row.name)).toEqual([
      'id',
      'name',
      'normalized_name',
      'category',
      'granularity',
      'description',
      'metadata',
      'created_at',
      'updated_at',
    ]);

    expect(factsColumns.rows.map((row) => row.name)).toEqual([
      'id',
      'statement',
      'summary',
      'source',
      'confidence',
      'metadata',
      'created_at',
      'updated_at',
    ]);

    expect(factTopicsColumns.rows.map((row) => row.name)).toEqual([
      'fact_id',
      'topic_id',
      'role',
      'position',
      'created_at',
    ]);
  });

  it('is idempotent when called more than once', async () => {
    const connection = await createDatabase({ client: 'sqlite', filename: ':memory:' });
    openConnections.push(connection.destroy);

    await initializeSchema(connection.db);
    await expect(initializeSchema(connection.db)).resolves.toBeUndefined();
  });
});