import { Database } from './Database.js'
import { DATABASES } from './DatabaseManager.js'
import { DynamoDatabase } from './integrations/dynamo/DynamoDatabase.js'
import { KnexDatabase } from './integrations/knex/KnexDatabase.js'
import { KyselyDatabase } from './integrations/kysely/KyselyDatabase.js'
import { PostgresDatabase } from './integrations/pgsql/PostgresDatabase.js'

/**
 * Represents the possible types of databases available in the system.
 * @typedef {keyof typeof DATABASES} DatabaseType
 */
export type DatabaseType = keyof typeof DATABASES

/**
 * Defines a type for a database class that includes instances for Knex, Postgres, and Kysely databases.
 * @template T - The type of data the KyselyDatabase instance will handle.
 * @property {new (...args: any[]) => KnexDatabase} knex - Constructor for KnexDatabase instances.
 * @property {new (...args: any[]) => PostgresDatabase} pg - Constructor for PostgresDatabase instances.
 * @property {new (...args: any[]) => KyselyDatabase<T>} kysely - Constructor for KyselyDatabase instances with type T.
 */
export type DatabaseClass<T> = {
  knex: new (...args: any[]) => KnexDatabase
  pg: new (...args: any[]) => PostgresDatabase
  kysely: new (...args: any[]) => KyselyDatabase<T>
  dynamo: new (...args: any[]) => DynamoDatabase
}

/**
 * Represents a specific implementation type for a database based on the provided DatabaseType.
 * @param {DatabaseType} Type - The type of database to implement.
 * @param {T} T - The generic type for the database implementation.
 * @returns An instance of the specified database class for the given type.
 */
export type DatabaseImplType<Type extends DatabaseType, T> = InstanceType<DatabaseClass<T>[Type]>

/**
 * Defines the type of transaction for a specific database type and schema.
 * @param {DatabaseType} Type - The type of the database.
 * @param {DBSchema} DBSchema - The schema of the database.
 * @returns The transaction type associated with the database type and schema.
 */
export type DatabaseTransactionType<Type extends DatabaseType, DBSchema> =
  DatabaseImplType<Type, DBSchema> extends Database<infer TransactionType> ? TransactionType : never

/**
 * Defines the configuration options for different types of databases.
 * @typedef {Object} DbBaseConfig
 * @property {string} host - The host of the database.
 * @property {number} port - The port number of the database.
 * @property {string} username - The username for accessing the database.
 * @property {string} password - The password for accessing the database.
 * @property {string} database - The name of the database.
 * @property {boolean} autoCommit - Flag indicating whether auto-commit is enabled.
 * @property {number} maxConnections - The maximum number of connections allowed.
 *
 * @typedef {Object} DbConfig
 * @property {string} type - The type of
 */
export type DbBaseConfig = {
  host: string
  port: number
  username: string
  password: string
  database: string
  autoCommit: boolean
  maxConnections: number
}
/**
 * Defines the configuration options for different types of databases.
 * @template S - The type of database (e.g., 'knex', 'pg', 'kysely')
 * @typedef {Object} DbConfig
 * @property {DbBaseConfig} DbBaseConfig - The base configuration for the database.
 * @property {S} type - The type of the database.
 * @property {string} [driver] - The driver for the 'knex' database type.
 * @property {boolean} [convertCamelToSnake] - Whether to convert camel case to snake case for 'knex' database type.
 * @property {DbBaseConfig} [readReplica] - The read replica configuration for '
 */
export type DbConfig<S extends DatabaseType> = { type: S } & (S extends 'knex'
  ? DbBaseConfig & {
      driver?: string
      convertCamelToSnake?: boolean
    }
  : unknown) &
  (S extends 'pg' | 'kysely'
    ? DbBaseConfig & {
        readReplica?: DbBaseConfig
      }
    : unknown) &
  (S extends 'dynamo'
    ? {
        region: string
        tableName: string
        maxAttempts?: number
        connectionTimeout?: number
      }
    : unknown)