import { UserContext } from '../src/core/context';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { SelectQuery } from '../src/core/ast';
import { RuntimeModule } from '../src/core/runtime-module';
import { EntitySchema, SQLExecutionEvidenceStore } from '../src/sql/core';
import { MutationRequest } from '../src/core/request-intent';
import { SQLiteTeaQLClient } from '../src/sql/sqlite';
import {
  DelegatingMutationPolicyApprovalProvider,
  DelegatingMutationPolicyRegistry,
} from '../src/core/mutation-policy';

function assertProviderSchemaAPIIsHidden(client: SQLiteTeaQLClient): void {
  // @ts-expect-error Ensure Schema is intentionally available only through UserContext.
  void client.ensureSchema;
}

void assertProviderSchemaAPIIsHidden;

const schemas: Record<string, EntitySchema> = {
  Platform: {
    table: 'platform_data',
    columns: {
      id: { columnName: 'id', logicalType: 'integer', decode: 'string' },
      version: { columnName: 'version', logicalType: 'integer', decode: 'number' },
      name: { columnName: 'name', logicalType: 'text', decode: 'native' },
    },
  },
  OrderStatus: {
    table: 'order_status_data',
    columns: {
      id: { columnName: 'id', logicalType: 'integer', decode: 'string' },
      version: { columnName: 'version', logicalType: 'integer', decode: 'number' },
      name: { columnName: 'name', logicalType: 'text', decode: 'native' },
      code: { columnName: 'code', logicalType: 'text', decode: 'native' },
    },
  },
};

function moduleWithStatus(name: string): RuntimeModule {
  return new RuntimeModule(schemas, {}, {
    defaultDomainRoot: { entity: 'Platform', id: '1', values: { name: 'Default Platform' } },
    constants: [{ entity: 'OrderStatus', id: '1001', values: { name, code: 'PENDING' } }],
  });
}

function read(entity: string): SelectQuery {
  return new SelectQuery(entity).comment('read bootstrap evidence').purpose('verify Ensure Schema');
}

it.each([false, true])('metadata bootstrap owns request intent and committed audit with logging=%p', async logging => {
  const client = new SQLiteTeaQLClient(':memory:', {}).install(moduleWithStatus('Pending')) as SQLiteTeaQLClient;
  const evidence = new SQLExecutionEvidenceStore();
  client.setRuntimeTelemetrySink(evidence);
  client.setQueryLoggingEnabled(logging).setMutationLoggingEnabled(logging);
  const mutate = jest.spyOn(client, 'executeMutation');
  const context = new UserContext().insertResource('dataService', client)
    .insertResource('bootstrapActor', 'prior actor').insertResource('bootstrapCategory', 'prior category');
  try {
    await context.ensureSchema();
    await context.ensureSchema();
    expect(context.getResource('bootstrapActor')).toBe('prior actor');
    expect(context.getResource('bootstrapCategory')).toBe('prior category');
    expect(mutate).toHaveBeenCalledTimes(2);
    for (const [request] of mutate.mock.calls) {
      expect(request).toBeInstanceOf(MutationRequest);
      expect(request.comment).toBe('reconcile model bootstrap data');
    }
    const events = client.auditTrace;
    expect(events).toHaveLength(2);
    expect(events.map(event => event.entity)).toEqual(['Platform', 'OrderStatus']);
    for (const event of events) {
      expect(event.actor).toBe('teaql-generated-bootstrap');
      expect(event.category).toBe('runtime-bootstrap');
    }
    const entries = evidence.snapshot();
    expect(entries).toHaveLength(8); // two lookup/insert/readback triples, then two no-op lookups
    expect(entries.filter(entry => entry.comment === 'inspect model bootstrap record')).toHaveLength(4);
    for (const entry of entries) {
      expect((entry.comment ?? entry.auditReason)?.trim()).toBeTruthy();
      if (entry.operation === 'select') expect(entry.purpose?.trim()).toBeTruthy();
      expect(entry.tracePath.map(node => node.kind)).toEqual([
        'operation', entry.operation === 'select' ? 'request' : 'entity', 'provider', 'sql',
      ]);
    }
  } finally { await client.close(); }
});

it('preflights the complete bootstrap graph before a customer policy reviews it', async () => {
  const client = new SQLiteTeaQLClient(':memory:', {}).install(moduleWithStatus('Pending')) as SQLiteTeaQLClient;
  const identity = Object.freeze({ policyId: 'bootstrap-review', version: '1', fingerprint: 'sha256:test' });
  const review = jest.fn((_context, plan) => ({ verdict: 'allow' as const }));
  const context = new UserContext().insertResource('dataService', client)
    .withMutationPolicyRegistry(new DelegatingMutationPolicyRegistry(() => ({ identity, review })))
    .withMutationPolicyApprovalProvider(new DelegatingMutationPolicyApprovalProvider(
      policy => ({ policy, approvedBy: 'test', approvedAt: new Date(0) }),
    ));
  try {
    await context.ensureSchema();
    expect(review).toHaveBeenCalledTimes(1);
    expect(review.mock.calls[0][1].operations.map((operation: { entity: string }) => operation.entity))
      .toEqual(['Platform', 'OrderStatus']);
  } finally { await client.close(); }
});

it.each([false, true])('metadata bootstrap cannot bypass Checker with logging=%p', async logging => {
  const checkAndFix = jest.fn(() => { throw new Error('constant checker refused'); });
  const client = new SQLiteTeaQLClient(':memory:', {}).install(new RuntimeModule(
    schemas, { OrderStatus: { checkAndFix } }, moduleWithStatus('Pending').bootstrap,
  )) as SQLiteTeaQLClient;
  client.setQueryLoggingEnabled(logging).setMutationLoggingEnabled(logging);
  const context = new UserContext().insertResource('dataService', client);
  try {
    await expect(context.ensureSchema())
      .rejects.toThrow('constant checker refused');
    expect(checkAndFix).toHaveBeenCalledTimes(1);
    expect(client.auditTrace).toEqual([]);
    expect(context.getResource('bootstrapActor')).toBeUndefined();
    expect(context.getResource('bootstrapCategory')).toBeUndefined();
    expect(await client.executeQuery(read('Platform'))).toEqual([]);
    expect(await client.executeQuery(read('OrderStatus'))).toEqual([]);
  } finally { await client.close(); }
});

it('serializes bootstrap callers without losing the active bootstrap actor', async () => {
  const client = new SQLiteTeaQLClient(':memory:', {}).install(moduleWithStatus('Pending')) as SQLiteTeaQLClient;
  const callers = [new UserContext(), new UserContext()]
    .map(context => context.insertResource('dataService', client));
  try {
    await Promise.all(callers.map(context => context.ensureSchema()));
    expect(client.auditTrace).toHaveLength(2);
    for (const event of client.auditTrace) expect(event.actor).toBe('teaql-generated-bootstrap');
    for (const caller of callers) expect(caller.getResource('bootstrapActor')).toBeUndefined();
    expect(await client.executeQuery(read('OrderStatus'))).toEqual([
      expect.objectContaining({ id: '1001', version: 1, code: 'PENDING' }),
    ]);
  } finally { await client.close(); }
});

it('does not mistake a soft-deleted constant for a missing primary key', async () => {
  const client = new SQLiteTeaQLClient(':memory:', {}).install(moduleWithStatus('Pending')) as SQLiteTeaQLClient;
  const context = new UserContext().insertResource('dataService', client);
  try {
    await context.ensureSchema();
    await client.executeMutation({ entity: 'OrderStatus', action: 'Delete', id: '1001',
      version: 1, comment: 'retire a constant for the bootstrap identity regression' });
    const audits = client.auditTrace.length;
    await context.ensureSchema();
    expect(client.auditTrace).toHaveLength(audits);
    expect(await client.executeQuery(read('OrderStatus'))).toEqual([]);
  } finally { await client.close(); }
});

it('reconciles bootstrap data idempotently and advances ID spaces', async () => {
  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'teaql-ts-bootstrap-'));
  const database = path.join(directory, 'bootstrap.sqlite');
  try {
    const first = new SQLiteTeaQLClient(database, {}).install(moduleWithStatus('Pending')) as SQLiteTeaQLClient;
    await new UserContext().insertResource('dataService', first).ensureSchema();
    await new UserContext().insertResource('dataService', first).ensureSchema();

    expect(await first.executeQuery(read('Platform'))).toEqual([
      expect.objectContaining({ id: '1', version: 1, name: 'Default Platform' }),
    ]);
    expect(await first.executeQuery(read('OrderStatus'))).toEqual([
      expect.objectContaining({ id: '1001', version: 1, name: 'Pending', code: 'PENDING' }),
    ]);

    const isolated = await first.executeMutation({
      entity: 'Platform', action: 'Create', payload: { name: 'Isolated Platform' },
      comment: 'create an isolated data graph',
    });
    expect(isolated.id).not.toBe('1');
    await first.close();

    const second = new SQLiteTeaQLClient(database, {}).install(
      moduleWithStatus('Awaiting Payment'),
    ) as SQLiteTeaQLClient;
    await new UserContext().insertResource('dataService', second).ensureSchema();
    expect(await second.executeQuery(read('Platform'))).toHaveLength(2);
    expect(await second.executeQuery(read('OrderStatus'))).toEqual([
      expect.objectContaining({
        id: '1001', version: 2, name: 'Awaiting Payment', code: 'PENDING',
      }),
    ]);
    await second.close();
  } finally {
    fs.rmSync(directory, { recursive: true, force: true });
  }
});