/**
 * v0.3.2 功能测试
 * @module tests/sql-ext3
 *
 * 覆盖：CASE WHEN 用于 WHERE/聚合 / JOIN 哈希连接 / 多标签页同步
 */
import { MetonaSqlark } from '../src/core';

async function createDb(mode: 'memory' | 'hybrid' = 'memory', extra: Record<string, unknown> = {}) {
  const db = new MetonaSqlark({
    name: `sql-ext3-${mode}-${Date.now()}-${Math.random()}`,
    mode,
    diskEngine: 'opfs',
    ...extra,
  });
  await db.init();
  await db.defineTable('users', {
    id: { type: 'string', primaryKey: true },
    name: { type: 'string' },
    age: { type: 'number' },
    city: { type: 'string' },
  });
  await db.defineTable('orders', {
    id: { type: 'string', primaryKey: true },
    user_id: { type: 'string' },
    amount: { type: 'number' },
  });
  await db.query(`INSERT INTO users VALUES ('u1', 'Alice', 30, 'Beijing')`);
  await db.query(`INSERT INTO users VALUES ('u2', 'Bob', 17, 'Shanghai')`);
  await db.query(`INSERT INTO users VALUES ('u3', 'Carol', 42, 'Beijing')`);
  await db.query(`INSERT INTO orders VALUES ('o1', 'u1', 100)`);
  await db.query(`INSERT INTO orders VALUES ('o2', 'u1', 200)`);
  await db.query(`INSERT INTO orders VALUES ('o3', 'u2', 50)`);
  return db;
}

// ===================================================================
//  CASE WHEN 用于 WHERE
// ===================================================================

describe('[v0.3.2] CASE WHEN 用于 WHERE', () => {
  test('WHERE CASE 等值比较', async () => {
    const db = await createDb();
    const rows = await db.query(
      `SELECT name FROM users WHERE CASE WHEN age >= 18 THEN 'adult' ELSE 'minor' END = 'adult'`,
    ) as Record<string, unknown>[];
    expect(rows.map((r) => r.name).sort()).toEqual(['Alice', 'Carol']);
    await db.close();
  });

  test('WHERE CASE 与 AND 组合', async () => {
    const db = await createDb();
    const rows = await db.query(
      `SELECT name FROM users WHERE CASE WHEN age >= 18 THEN 'adult' ELSE 'minor' END = 'adult' AND city = 'Beijing'`,
    ) as Record<string, unknown>[];
    expect(rows.map((r) => r.name).sort()).toEqual(['Alice', 'Carol']);
    await db.close();
  });

  test('WHERE CASE 数字比较', async () => {
    const db = await createDb();
    const rows = await db.query(
      `SELECT name FROM users WHERE CASE WHEN city = 'Beijing' THEN 1 ELSE 0 END = 1`,
    ) as Record<string, unknown>[];
    expect(rows.map((r) => r.name).sort()).toEqual(['Alice', 'Carol']);
    await db.close();
  });

  test('WHERE NOT CASE 组合', async () => {
    const db = await createDb();
    const rows = await db.query(
      `SELECT name FROM users WHERE NOT (CASE WHEN age >= 18 THEN 'adult' ELSE 'minor' END = 'adult')`,
    ) as Record<string, unknown>[];
    expect(rows.map((r) => r.name)).toEqual(['Bob']);
    await db.close();
  });

  test('Aria 引擎 WHERE CASE 可用', async () => {
    const db = await createDb('hybrid');
    const rows = await db.query(
      `SELECT name FROM users WHERE CASE WHEN age >= 18 THEN 'adult' ELSE 'minor' END = 'minor'`,
    ) as Record<string, unknown>[];
    expect(rows.map((r) => r.name)).toEqual(['Bob']);
    await db.close();
  });
});

// ===================================================================
//  CASE WHEN 用于聚合
// ===================================================================

describe('[v0.3.2] CASE WHEN 用于聚合', () => {
  test('SUM(CASE WHEN...) 条件计数', async () => {
    const db = await createDb();
    const rows = await db.query(
      `SELECT SUM(CASE WHEN age >= 18 THEN 1 ELSE 0 END) AS adults FROM users`,
    ) as Record<string, unknown>[];
    expect(rows[0].adults).toBe(2);
    await db.close();
  });

  test('COUNT(CASE WHEN...) 与 AVG', async () => {
    const db = await createDb();
    const rows = await db.query(
      `SELECT COUNT(CASE WHEN city = 'Beijing' THEN 1 END) AS bj_count, AVG(CASE WHEN age >= 18 THEN age END) AS adult_avg FROM users`,
    ) as Record<string, unknown>[];
    expect(rows[0].bj_count).toBe(2);
    expect(rows[0].adult_avg).toBe(36); // (30 + 42) / 2
    await db.close();
  });

  test('GROUP BY + SUM(CASE WHEN...)', async () => {
    const db = await createDb();
    const rows = await db.query(
      `SELECT city, SUM(CASE WHEN age >= 18 THEN 1 ELSE 0 END) AS adults FROM users GROUP BY city`,
    ) as Record<string, unknown>[];
    const byCity = Object.fromEntries(rows.map((r) => [r.city, r.adults]));
    expect(byCity['Beijing']).toBe(2); // Alice + Carol
    expect(byCity['Shanghai']).toBe(0); // Bob 17 岁
    await db.close();
  });

  test('GROUP BY + CASE 非聚合列', async () => {
    const db = await createDb();
    const rows = await db.query(
      `SELECT city, CASE WHEN age >= 18 THEN 'adult' ELSE 'minor' END AS status FROM users GROUP BY city`,
    ) as Record<string, unknown>[];
    const byCity = Object.fromEntries(rows.map((r) => [r.city, r.status]));
    expect(byCity['Beijing']).toBe('adult'); // 组内第一行 Alice
    expect(byCity['Shanghai']).toBe('minor');
    await db.close();
  });
});

// ===================================================================
//  JOIN 哈希连接
// ===================================================================

describe('[v0.3.2] JOIN 哈希连接', () => {
  test('INNER JOIN 主键等值走哈希连接（结果正确）', async () => {
    const db = await createDb();
    const rows = await db.query(
      `SELECT o.id FROM orders o INNER JOIN users u ON u.id = o.user_id`,
    ) as Record<string, unknown>[];
    // orders 全有匹配用户
    expect(rows.map((r) => r['o.id']).sort()).toEqual(['o1', 'o2', 'o3']);
    await db.close();
  });

  test('LEFT JOIN 哈希连接保留未匹配行（null 填充）', async () => {
    const db = await createDb();
    await db.query(`INSERT INTO users VALUES ('u9', 'Zoe', 20, 'Guangzhou')`);
    const rows = await db.query(
      `SELECT u.name, o.id FROM users u LEFT JOIN orders o ON o.user_id = u.id`,
    ) as Record<string, unknown>[];
    // Zoe 无订单 → 保留（null 填充）；Alice 有 2 个订单 → 展开 2 行（LEFT JOIN 语义）
    expect(rows.map((r) => r['u.name']).sort()).toEqual(['Alice', 'Alice', 'Bob', 'Carol', 'Zoe']);
    const zoe = rows.find((r) => r['u.name'] === 'Zoe');
    expect(zoe).toBeDefined();
    expect(zoe!['o.id']).toBeNull();
    await db.close();
  });

  test('INNER JOIN 哈希连接过滤无匹配行', async () => {
    const db = await createDb();
    await db.query(`INSERT INTO users VALUES ('u9', 'Zoe', 20, 'Guangzhou')`);
    const rows = await db.query(
      `SELECT u.name FROM users u INNER JOIN orders o ON o.user_id = u.id`,
    ) as Record<string, unknown>[];
    // Alice 2 个订单 → 2 行；Bob 1 行；Carol 无订单被过滤
    expect(rows.map((r) => r['u.name']).sort()).toEqual(['Alice', 'Alice', 'Bob']);
    await db.close();
  });

  test('哈希连接一次 $in 查询（不再全表拉取）', async () => {
    const db = await createDb();
    const engine = db.getEngine() as any;
    let rightTableFinds = 0;
    const origFind = engine.find.bind(engine);
    engine.find = async (table: string, query: any) => {
      if (table === 'orders') {
        rightTableFinds++;
        if (query.where?.user_id?.$in) {
          // 哈希连接：$in 一次查询
          expect(query.where.user_id.$in).toEqual(expect.arrayContaining(['u1', 'u2']));
        }
      }
      return origFind(table, query);
    };
    await db.query(`SELECT u.name FROM users u INNER JOIN orders o ON o.user_id = u.id`);
    // orders.user_id 无索引 → 哈希回退；仍应恰有一次右表查询
    expect(rightTableFinds).toBe(1);
    await db.close();
  });

  test('哈希连接不适用于非索引右列（回退嵌套循环）', async () => {
    const db = await createDb();
    // orders.user_id 无索引 → 回退；结果仍正确
    const rows = await db.query(
      `SELECT o.id FROM orders o INNER JOIN users u ON u.id = o.user_id`,
    ) as Record<string, unknown>[];
    expect(rows).toHaveLength(3);
    await db.close();
  });
});

// ===================================================================
//  多标签页同步
// ===================================================================

describe('[v0.3.2] 多标签页同步', () => {
  // BroadcastChannel mock：模拟同源标签页间消息传递
  class MockBroadcastChannel {
    static instances: MockBroadcastChannel[] = [];
    name: string;
    onmessage: ((event: { data: unknown }) => void) | null = null;
    closed = false;
    constructor(name: string) {
      this.name = name;
      MockBroadcastChannel.instances.push(this);
    }
    postMessage(data: unknown): void {
      if (this.closed) return;
      for (const other of MockBroadcastChannel.instances) {
        if (other !== this && other.name === this.name && !other.closed && other.onmessage) {
          other.onmessage({ data });
        }
      }
    }
    close(): void {
      this.closed = true;
    }
    static reset(): void {
      MockBroadcastChannel.instances = [];
    }
  }

  const origBC = (globalThis as any).BroadcastChannel;
  beforeAll(() => {
    (globalThis as any).BroadcastChannel = MockBroadcastChannel;
  });
  afterAll(() => {
    (globalThis as any).BroadcastChannel = origBC;
  });
  beforeEach(() => {
    MockBroadcastChannel.reset();
  });

  test('SQL 写语句广播表变更，其他标签页订阅收到 external 事件', async () => {
    // 先建表（DDL 版本升级会触发其他标签页 onversionchange 关闭连接，故先建表再开第二连接）
    const setup = new MetonaSqlark({ name: 'mt-a', mode: 'hybrid', diskEngine: 'opfs' });
    await setup.init();
    await setup.defineTable('t', { id: { type: 'string', primaryKey: true }, v: { type: 'number' } });
    await setup.close();

    const dbA = new MetonaSqlark({ name: 'mt-a', version: 2, mode: 'hybrid', diskEngine: 'opfs', multiTabSync: true });
    const dbB = new MetonaSqlark({ name: 'mt-a', version: 2, mode: 'hybrid', diskEngine: 'opfs', multiTabSync: true });
    await dbA.init();
    await dbB.init();

    const events: { type: string; table?: string }[] = [];
    dbB.subscribe('t', (e) => { events.push(e); });

    await dbA.query(`INSERT INTO t VALUES ('1', 10)`);

    // 等待广播送达（同步 mock 已即时）
    expect(events.length).toBeGreaterThan(0);
    expect(events[0].type).toBe('external');
    expect(events[0].table).toBe('t');

    await dbA.close();
    await dbB.close();
  });

  test('Hybrid 标签页收到广播后内存重载（读到其他标签页的新数据）', async () => {
    const setup = new MetonaSqlark({ name: 'mt-b', mode: 'hybrid', diskEngine: 'opfs' });
    await setup.init();
    await setup.defineTable('t', { id: { type: 'string', primaryKey: true }, v: { type: 'number' } });
    await setup.close();

    const dbA = new MetonaSqlark({ name: 'mt-b', version: 2, mode: 'hybrid', diskEngine: 'opfs', multiTabSync: true });
    const dbB = new MetonaSqlark({ name: 'mt-b', version: 2, mode: 'hybrid', diskEngine: 'opfs', multiTabSync: true });
    await dbA.init();
    await dbB.init();

    // B 订阅外部变更后等待 reload 完成
    let reloadDone: Promise<void> = Promise.resolve();
    dbB.subscribe('t', async () => {
      reloadDone = reloadDone.then(async () => {
        // Hybrid reload 由 onmessage 触发（异步），订阅回调后再等一拍
        await new Promise((r) => setTimeout(r, 30));
      });
    });

    await dbA.query(`INSERT INTO t VALUES ('1', 100)`);
    await new Promise((r) => setTimeout(r, 80));

    const rows = await dbB.query('SELECT * FROM t') as Record<string, unknown>[];
    expect(rows).toHaveLength(1);
    expect(rows[0].v).toBe(100);

    await dbA.close();
    await dbB.close();
  });

  test('未启用 multiTabSync 不广播', async () => {
    const setup = new MetonaSqlark({ name: 'mt-c', mode: 'hybrid', diskEngine: 'opfs' });
    await setup.init();
    await setup.defineTable('t', { id: { type: 'string', primaryKey: true }, v: { type: 'number' } });
    await setup.close();

    const dbA = new MetonaSqlark({ name: 'mt-c', version: 2, mode: 'hybrid', diskEngine: 'opfs' });
    const dbB = new MetonaSqlark({ name: 'mt-c', version: 2, mode: 'hybrid', diskEngine: 'opfs', multiTabSync: true });
    await dbA.init();
    await dbB.init();

    const events: unknown[] = [];
    dbB.subscribe('t', (e) => { events.push(e); });

    await dbA.query(`INSERT INTO t VALUES ('1', 10)`);
    await new Promise((r) => setTimeout(r, 30));
    expect(events).toHaveLength(0); // dbA 未启用 → 无广播

    await dbA.close();
    await dbB.close();
  });

  test('Table API 写入也广播', async () => {
    const setup = new MetonaSqlark({ name: 'mt-d', mode: 'hybrid', diskEngine: 'opfs' });
    await setup.init();
    await setup.defineTable('t', { id: { type: 'string', primaryKey: true }, v: { type: 'number' } });
    await setup.close();

    const dbA = new MetonaSqlark({ name: 'mt-d', version: 2, mode: 'hybrid', diskEngine: 'opfs', multiTabSync: true });
    const dbB = new MetonaSqlark({ name: 'mt-d', version: 2, mode: 'hybrid', diskEngine: 'opfs', multiTabSync: true });
    await dbA.init();
    await dbB.init();

    const events: unknown[] = [];
    dbB.subscribe('t', (e) => { events.push(e); });

    await dbA.table('t').insert({ id: '1', v: 10 });
    expect(events.length).toBeGreaterThan(0);

    await dbA.close();
    await dbB.close();
  });
});

// ===================================================================
//  回归：IndexedDB reopen 后 schema 持久化（v0.3.2 修复）
// ===================================================================

describe('[v0.3.2] KVStore reopen schema 持久化', () => {
  test('close 后重新 open 表结构与数据完整', async () => {
    const setup = new MetonaSqlark({ name: 'reopen-a', mode: 'hybrid', diskEngine: 'opfs' });
    await setup.init();
    await setup.defineTable('t', {
      id: { type: 'string', primaryKey: true },
      name: { type: 'string' },
      v: { type: 'number' },
    });
    await setup.query(`INSERT INTO t VALUES ('1', 'Alice', 42)`);
    await setup.close();

    // 重新打开（模拟页面刷新）
    const db = new MetonaSqlark({ name: 'reopen-a', version: 2, mode: 'hybrid', diskEngine: 'opfs' });
    await db.init();

    const schema = await db.getEngine().getTableSchema('t');
    expect(schema?.columns.v).toBeDefined(); // 持久化 schema 保留完整列

    const rows = await db.query('SELECT * FROM t') as Record<string, unknown>[];
    expect(rows).toHaveLength(1);
    expect(rows[0].name).toBe('Alice');
    expect(rows[0].v).toBe(42);

    // 重新打开后仍可写入并校验类型
    await db.query(`INSERT INTO t VALUES ('2', 'Bob', 30)`);
    await expect(db.query(`INSERT INTO t VALUES ('3', 'Bad', 'not-a-number')`)).rejects.toBeDefined();
    await db.close();
  });

  test('reopen 后 UPDATE 全列生效', async () => {
    const setup = new MetonaSqlark({ name: 'reopen-b', mode: 'hybrid', diskEngine: 'opfs' });
    await setup.init();
    await setup.defineTable('t', {
      id: { type: 'string', primaryKey: true },
      name: { type: 'string' },
      v: { type: 'number' },
    });
    await setup.query(`INSERT INTO t VALUES ('1', 'Alice', 42)`);
    await setup.close();

    const db = new MetonaSqlark({ name: 'reopen-b', version: 2, mode: 'hybrid', diskEngine: 'opfs' });
    await db.init();
    await db.query(`UPDATE t SET name = 'Renamed', v = 99 WHERE id = '1'`);

    const rows = await db.query('SELECT * FROM t') as Record<string, unknown>[];
    expect(rows[0].name).toBe('Renamed');
    expect(rows[0].v).toBe(99);
    await db.close();
  });

});