import { Kysely, Transaction } from 'kysely'

import { KyselyDatabase } from './KyselyDatabase.js'
import { Database } from '../../Database.js'
import { DatabaseTransaction } from '../../DatabaseTransaction.js'

/**
 * Represents a transaction for querying a database with a specific schema.
 * @param DBSchema - The schema of the database.
 * @type {KyselyTransactionImpl<DBSchema> & Transaction<DBSchema>}
 */
export type KyselyTransaction<DBSchema> = KyselyTransactionImpl<DBSchema> & Transaction<DBSchema>
/**
 * Represents a transaction in a Postgres database.
 */
export class KyselyTransactionImpl<DBSchema> extends DatabaseTransaction {
  /**
   * A readonly property representing a writer for a Kysely object.
   * @type {Kysely<any>}
   */
  public readonly writer!: Kysely<any>
  /**
   * A readonly property representing a reader of type Kysely<any>.
   * This property allows reading data of any type using the Kysely interface.
   */
  public readonly reader!: Kysely<any>
  /**
   * A protected property representing a transaction of type any.
   */
  protected transaction!: Transaction<any>
  /**
   * A protected property representing a database instance.
   * @type {Database<KyselyTransaction<DBSchema>>}
   */
  protected database!: Database<KyselyTransaction<DBSchema>>
  /**
   * A private property that represents a deferred object.
   * @type {Deferred<any>}
   */
  private txWrapper!: Deferred<any>
  /**
   * Constructs a new instance of the class.
   * @param {Kysely<DBSchema>} delegate - The delegate object for the database query.
   * @param {KyselyDatabase<DBSchema>} database - The database object for the query.
   * @param {Kysely<DBSchema>} [reader] - An optional reader object for the query.
   * @returns None
   */
  private constructor(
    delegate: Kysely<DBSchema>,
    database: KyselyDatabase<DBSchema>,
    reader?: Kysely<DBSchema>
  ) {
    super(delegate, database, reader)
  }

  /**
   * Creates a new database transaction for the given database schema.
   * @param {Kysely<DBSchema>} connection - The connection object for the transaction.
   * @param {KyselyDatabase<DBSchema>} database - The database object for the transaction.
   * @param {Kysely<DBSchema>} [reader] - An optional reader object for the transaction.
   * @returns {Promise<KyselyTransaction<DBSchema>>} A promise that resolves to the created transaction.
   */
  public static async newTransaction<DBSchema>(
    connection: Kysely<DBSchema>,
    database: KyselyDatabase<DBSchema>,
    reader?: Kysely<DBSchema>
  ): Promise<KyselyTransaction<DBSchema>> {
    const tx = new KyselyTransactionImpl<DBSchema>(connection, database, reader)
    await tx.begin()
    return DatabaseTransaction.proxyInstance(tx) as any
  }

  /**
   * Asynchronously begins a transaction using a writer and resolves the transaction once it is executed.
   * @returns A Promise that resolves with the transaction object once the transaction is executed.
   */
  protected doBegin = async () => {
    this.txWrapper = new Deferred<any>()
    return new Promise(resolve => {
      this.writer
        .transaction()
        .execute(async trx => {
          this.transaction = trx
          resolve(trx) // resolve with tx
          return this.txWrapper.promise // wait for wrapper to be solved
        })
        .catch(() => {
          // Don't do anything here. Just swallow the exception.
        })
    })
  }

  /**
   * Executes the commit operation by resolving the transaction wrapper and returning a resolved Promise.
   * @returns A Promise that resolves to null.
   */
  protected doCommit = () => {
    this.txWrapper.resolve(null)
    return Promise.resolve()
  }

  /**
   * Performs a rollback operation by rejecting the transaction wrapper with an error.
   * @returns A resolved Promise after the rollback operation is completed.
   */
  protected doRollback = () => {
    this.txWrapper.reject(new Error('Rollback'))
    return Promise.resolve()
  }
}

/**
 * Represents a deferred promise that can be resolved or rejected at a later time.
 * @template T - The type of the value that the promise will resolve to.
 */
class Deferred<T> {
  /**
   * A private readonly Promise object that resolves to type T.
   */
  private readonly _promise: Promise<T>
  /**
   * A private property that holds a function to resolve a Promise with a value of type T.
   * @param {T | PromiseLike<T>} value - The value or promise to be resolved.
   */
  private _resolve?: (value: T | PromiseLike<T>) => void
  /**
   * A function that can be called to reject a promise with an optional reason.
   * @param {any} [reason] - An optional reason for rejecting the promise.
   */
  private _reject?: (reason?: any) => void

  /**
   * Constructor for creating a new Promise instance with resolve and reject functions.
   * @constructor
   */
  constructor() {
    this._promise = new Promise<T>((resolve, reject) => {
      this._reject = reject
      this._resolve = resolve
    })
  }

  /**
   * Getter method to retrieve the Promise object.
   * @returns {Promise<T>} A Promise object of type T.
   */
  public get promise(): Promise<T> {
    return this._promise
  }

  /**
   * Resolves the Promise with the given value.
   * @param {T | PromiseLike<T>} value - The value to resolve the Promise with.
   * @returns void
   */
  public resolve(value: T | PromiseLike<T>): void {
    if (this._resolve) {
      this._resolve(value)
    }
  }

  /**
   * Rejects the Promise with the given reason, if the reject function is available.
   * @param {any} reason - The reason for rejecting the Promise.
   * @returns void
   */
  public reject(reason?: any): void {
    if (this._reject) {
      this._reject(reason)
    }
  }
}