import { CheckException, CheckResult, EntityChecker, EntityRoot, MutationIntent, ObjectLocation, RuntimeModule, UserContext } from '../src';
import { AbstractSQLTeaQLClient, TeaQLSqlDriver } from '../src/sql/core';

class Driver implements TeaQLSqlDriver {
  readonly databaseKind = 'sqlite' as const;
  transactions = 0;
  statements: string[] = [];
  query = async (sql: string) => { this.statements.push(sql); return { rows: sql.startsWith('SELECT') ? [{ id: '1', version: 1, userEmail: 'a@b.test' }] : [], rowCount: 1 }; };
  stream = async function* () {};
  identifier = (value: string) => `"${value}"`;
  placeholder = () => '?';
  encode = (value: any) => value;
  contains = () => '';
  aggregateFunction = (name: string) => name;
  ensureSchema = async () => {};
  transaction = async <T>(work: (session: any) => Promise<T>) => { this.transactions++; return work(this); };
  nextId = async () => '1';
  ensureIdFloor = async () => {};
  close = async () => {};
}

class Client extends AbstractSQLTeaQLClient {
  constructor(driver: Driver) { super(driver, {}); }
}

test('checker failure is structured, save scoped, and runs before SQL transaction', async () => {
  const driver = new Driver();
  const context = new UserContext();
  let calls = 0;
  const checker: EntityChecker = {
    checkAndFix(ctx, mutation, results: CheckResult[]) {
      calls++;
      expect(ctx.getResource('fixTime')).toBeInstanceOf(Date);
      if (!mutation.payload.name) results.push({ ruleId: 'required', location: ObjectLocation.property('name') });
    },
  };
  const client = new Client(driver).setUserContext(context).install(new RuntimeModule({
    Task: { table: 'task', columns: {} },
  }, { Task: checker }));
  const mutation = { entity: 'Task', action: 'Create', payload: {}, comment: 'test' };

  for (let attempt = 0; attempt < 2; attempt++) {
    await expect(client.executeMutation(mutation)).rejects.toBeInstanceOf(CheckException);
  }
  expect(calls).toBe(2);
  expect(driver.transactions).toBe(0);
  expect(context.getResource('fixTime')).toBeUndefined();
});

test('canonical multiword mutation key reaches checker and native SQL schema', async () => {
  const driver = new Driver();
  const checker: EntityChecker = {
    checkAndFix(_context, mutation, results) {
      if (!mutation.payload.user_email) {
        results.push({ ruleId: 'required', location: ObjectLocation.property('user_email') });
      }
    },
  };
  const client = new Client(driver).setUserContext(new UserContext()).install(new RuntimeModule({
    User: { table: 'user_data', columns: {
      id: { columnName: 'id', logicalType: 'integer', decode: 'string' },
      version: { columnName: 'version', logicalType: 'integer', decode: 'number' },
      userEmail: { columnName: 'email_address', modelName: 'user_email', logicalType: 'text', decode: 'native' },
    } },
  }, { User: checker }));

  const result = await client.executeMutation({
    entity: 'User', action: 'Create', payload: { user_email: 'a@b.test' }, comment: 'test canonical key',
  });
  expect(result.persistedRecord?.userEmail).toBe('a@b.test');
  expect(driver.statements.some(sql => sql.includes('"email_address"'))).toBe(true);
});

test('update checker can add fixes to an immutable mutation ledger snapshot', async () => {
  const driver = new Driver();
  const context = new UserContext();
  const ledgerRoot = new EntityRoot();
  const ledgerKey = { entity: 'Task', id: '1' } as const;
  const checker: EntityChecker = {
    checkAndFix(ctx, mutation) {
      expect(ctx.getResource('fixTime')).toBeInstanceOf(Date);
      mutation.payload.update_time = ctx.getResource('fixTime');
    },
  };
  const client = new Client(driver).setUserContext(context).install(new RuntimeModule({
    Task: { table: 'task_data', columns: {
      id: { columnName: 'id', logicalType: 'integer', decode: 'string' },
      version: { columnName: 'version', logicalType: 'integer', decode: 'number' },
      name: { columnName: 'name', logicalType: 'text', decode: 'native' },
      updateTime: { columnName: 'update_time', modelName: 'update_time', logicalType: 'datetime', decode: 'date' },
    } },
  }, { Task: checker }));

  const immutableLedgerPayload = Object.freeze({ name: 'Updated task' });
  await expect(client.executeMutation({
    entity: 'Task', action: 'Update', payload: immutableLedgerPayload,
    id: '1', version: 1, comment: 'update task', ledgerKey, ledgerRoot,
  })).resolves.toBeDefined();

  expect(Object.isFrozen(immutableLedgerPayload)).toBe(true);
  expect((immutableLedgerPayload as Record<string, unknown>).update_time).toBeUndefined();
  expect(ledgerRoot.change(ledgerKey).update_time).toBeInstanceOf(Date);
  expect(driver.statements.some(sql => sql.includes('"update_time" = ?'))).toBe(true);
});

test('one graph captures one fix clock and clears it after commit', async () => {
  const driver = new Driver();
  const context = new UserContext();
  const observed: Date[] = [];
  const checker: EntityChecker = {
    checkAndFix(ctx, mutation) {
      const now = ctx.requireResource<Date>('fixTime');
      observed.push(now);
      mutation.payload.create_time = now;
    },
  };
  const client = new Client(driver).setUserContext(context).install(new RuntimeModule({
    Task: { table: 'task_data', columns: {
      id: { columnName: 'id', logicalType: 'integer', decode: 'string' },
      version: { columnName: 'version', logicalType: 'integer', decode: 'number' },
      createTime: { columnName: 'create_time', modelName: 'create_time', logicalType: 'datetime', decode: 'date' },
    } },
  }, { Task: checker }));

  await client.executeGraphSave(new MutationIntent('fix graph'), async graph => {
    await client.executeMutation(graph.request({ entity: 'Task', action: 'Create', payload: {} }));
    await new Promise(resolve => setTimeout(resolve, 5));
    await client.executeMutation(graph.request({ entity: 'Task', action: 'Create', payload: {} }));
  });

  expect(observed).toHaveLength(2);
  expect(observed[0]).toBe(observed[1]);
  expect(driver.transactions).toBe(1);
  expect(context.getResource('fixTime')).toBeUndefined();
});

test('independent concurrent graph saves are serialized instead of joining', async () => {
  const driver = new Driver();
  const client = new Client(driver).install(new RuntimeModule({
    Task: { table: 'task_data', columns: {
      id: { columnName: 'id', logicalType: 'integer', decode: 'string' },
      version: { columnName: 'version', logicalType: 'integer', decode: 'number' },
      name: { columnName: 'name', logicalType: 'text', decode: 'string' },
    } },
  }));
  const events: string[] = [];

  const first = client.executeGraphSave(new MutationIntent('first'), async graph => {
    events.push('first:start');
    await new Promise(resolve => setTimeout(resolve, 10));
    await client.executeMutation(graph.request({ entity: 'Task', action: 'Create', payload: { name: 'first' } }));
    events.push('first:end');
  });
  const second = client.executeGraphSave(new MutationIntent('second'), async graph => {
    events.push('second:start');
    await client.executeMutation(graph.request({ entity: 'Task', action: 'Create', payload: { name: 'second' } }));
    events.push('second:end');
  });

  await Promise.all([first, second]);
  expect(events).toEqual(['first:start', 'first:end', 'second:start', 'second:end']);
  expect(driver.transactions).toBe(2);
});