import {
  AbstractSQLTeaQLClient,
  assertSafeIdentifier,
  ColumnSchema,
  EntitySchema,
  LogicalColumnType,
  SqlQueryResult,
  SqlSession,
  standardAggregateFunction,
  ensureOptimisticIdFloor,
  TeaQLSqlDriver,
  canonicalRelationIndexes,
} from './core';

export type ExpoSQLiteBindValue = null | number | string | Uint8Array;

export interface ExpoSQLiteExecuteResult<T = Record<string, unknown>>
  extends AsyncIterableIterator<T> {
  changes: number;
  getAllAsync(): Promise<T[]>;
}

export interface ExpoSQLiteStatement {
  executeAsync<T = Record<string, unknown>>(
    params: ExpoSQLiteBindValue[],
  ): Promise<ExpoSQLiteExecuteResult<T>>;
  finalizeAsync(): Promise<void>;
}

export interface ExpoSQLiteDatabaseLike {
  execAsync(sql: string): Promise<void>;
  prepareAsync(sql: string): Promise<ExpoSQLiteStatement>;
  withExclusiveTransactionAsync(
    work: (transaction: ExpoSQLiteDatabaseLike) => Promise<void>,
  ): Promise<void>;
  closeAsync(): Promise<void>;
}

class ExpoSQLiteSession implements SqlSession {
  constructor(private readonly database: ExpoSQLiteDatabaseLike) {}

  async query(sql: string, values: any[] = []): Promise<SqlQueryResult> {
    const statement = await this.database.prepareAsync(sql);
    try {
      const result = await statement.executeAsync(values as ExpoSQLiteBindValue[]);
      const rows = await result.getAllAsync();
      return { rows, rowCount: rows.length || Number(result.changes || 0) };
    } finally {
      await statement.finalizeAsync();
    }
  }
}

/**
 * TeaQL SQL driver for an opened `expo-sqlite` database.
 *
 * The structural database type keeps `teaql-ts` importable in Node and browser
 * profiles. A React Native application opens the database with
 * `expo-sqlite.openDatabaseAsync()` and injects it here through UserContext.
 */
export class ExpoSQLiteDriver implements TeaQLSqlDriver {
  readonly databaseKind = 'sqlite' as const;
  private initialized?: Promise<void>;

  constructor(private readonly database: ExpoSQLiteDatabaseLike) {
    if (!database) throw new Error('opened Expo SQLite database is required');
  }

  identifier(value: string): string {
    return `"${assertSafeIdentifier(value)}"`;
  }

  placeholder(_index: number): string {
    return '?';
  }

  encode(value: any, column?: ColumnSchema): ExpoSQLiteBindValue {
    if (value === null || value === undefined) return value as ExpoSQLiteBindValue;
    if (column?.logicalType === 'json' && typeof value !== 'string') {
      return JSON.stringify(value);
    }
    if (column?.logicalType === 'boolean') return value ? 1 : 0;
    if (value instanceof Date) return value.toISOString();
    return value as ExpoSQLiteBindValue;
  }

  contains(columnSql: string, placeholder: string): string {
    return `CAST(${columnSql} AS TEXT) LIKE '%' || ${placeholder} || '%'`;
  }

  aggregateFunction(name: string): string {
    return standardAggregateFunction(name);
  }

  private sqlType(type: LogicalColumnType): string {
    const types: Record<LogicalColumnType, string> = {
      boolean: 'INTEGER',
      double: 'REAL',
      decimal: 'NUMERIC',
      date: 'TEXT',
      datetime: 'TEXT',
      json: 'TEXT',
      integer: 'INTEGER',
      text: 'TEXT',
    };
    return types[type];
  }

  private initialize(): Promise<void> {
    if (!this.initialized) {
      this.initialized = this.database.execAsync(
        'PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON;',
      );
    }
    return this.initialized;
  }

  async ensureSchema(schemas: Record<string, EntitySchema>): Promise<void> {
    await this.initialize();
    for (const schema of Object.values(schemas)) {
      const table = this.identifier(schema.table);
      await this.query(
        `CREATE TABLE IF NOT EXISTS ${table} (` +
        '"id" INTEGER PRIMARY KEY, "version" INTEGER NOT NULL)',
      );
      const columns = await this.query(`PRAGMA table_info(${table})`);
      const existing = new Set(columns.rows.map(row => String(row.name)));
      for (const [field, column] of Object.entries(schema.columns)) {
        if (field === 'id' || field === 'version' ||
            existing.has(column.columnName)) continue;
        await this.query(
          `ALTER TABLE ${table} ADD COLUMN ` +
          `${this.identifier(column.columnName)} ${this.sqlType(column.logicalType)}` +
          `${column.nullable === false ? ' NOT NULL' : ''}`,
        );
      }
    }
    for (const index of canonicalRelationIndexes(schemas)) {
      await this.query(
        `CREATE INDEX IF NOT EXISTS ${this.identifier(index.name)} ON ` +
        `${this.identifier(index.table)} (` +
        `${this.identifier(index.foreignColumn)}, ${this.identifier(index.idColumn)} DESC)`,
      );
    }
    await this.query(
      'CREATE TABLE IF NOT EXISTS teaql_id_space (' +
      'type_name TEXT PRIMARY KEY, current_level INTEGER NOT NULL)',
    );
  }

  async transaction<T>(work: (session: SqlSession) => Promise<T>): Promise<T> {
    let value: T | undefined;
    await this.database.withExclusiveTransactionAsync(async transaction => {
      value = await work(new ExpoSQLiteSession(transaction));
    });
    return value as T;
  }

  async nextId(session: SqlSession, entity: string): Promise<string> {
    for (let attempt = 1; attempt <= 100; attempt += 1) {
      const current = await session.query(
        'SELECT current_level AS id FROM teaql_id_space WHERE type_name = ?',
        [entity],
      );
      if (!current.rowCount) {
        try {
          const inserted = await session.query(
            'INSERT INTO teaql_id_space(type_name, current_level) VALUES (?, 1)',
            [entity],
          );
          if (inserted.rowCount === 1) return '1';
        } catch (error) {
          const winner = await session.query(
            'SELECT current_level AS id FROM teaql_id_space WHERE type_name = ?',
            [entity],
          );
          if (!winner.rowCount) throw error;
        }
        continue;
      }
      const previous = Number(current.rows[0].id);
      const next = previous + 1;
      const updated = await session.query(
        'UPDATE teaql_id_space SET current_level = ? WHERE type_name = ? AND current_level = ?',
        [next, entity, previous],
      );
      if (updated.rowCount === 1) return String(next);
      if (updated.rowCount !== 0) {
        throw new Error(`ID space update for ${entity} changed ${updated.rowCount} rows`);
      }
    }
    throw new Error(
      `Unable to allocate ID for ${entity} after 100 optimistic-lock attempts`,
    );
  }

  ensureIdFloor(session: SqlSession, entity: string, floor: string): Promise<void> {
    return ensureOptimisticIdFloor(session, index => this.placeholder(index), entity, floor);
  }

  async query(sql: string, values: any[] = []): Promise<SqlQueryResult> {
    return new ExpoSQLiteSession(this.database).query(sql, values);
  }

  async *stream(sql: string, values: any[] = []): AsyncIterable<any> {
    const statement = await this.database.prepareAsync(sql);
    try {
      const result = await statement.executeAsync(
        values as ExpoSQLiteBindValue[],
      );
      for await (const row of result) yield row;
    } finally {
      await statement.finalizeAsync();
    }
  }

  async close(): Promise<void> {
    await this.database.closeAsync();
  }
}

export class ExpoSQLiteTeaQLClient extends AbstractSQLTeaQLClient {
  constructor(
    database: ExpoSQLiteDatabaseLike,
    schemas: Record<string, EntitySchema>,
  ) {
    super(new ExpoSQLiteDriver(database), schemas);
  }
}