import { jest } from '@jest/globals'
import { PostgresDialect } from 'kysely'
import * as pg from 'pg'

import type { DbConfig } from '../../../../src/Database/index.js'
import { KyselyDatabase } from '../../../../src/Database/integrations/kysely/KyselyDatabase.js'

const config: DbConfig<'kysely'> = {
  type: 'kysely',
  username: 'username',
  password: 'password',
  host: 'host',
  port: 1234,
  database: 'database',
  maxConnections: 1,
  autoCommit: true,
}

const config2: DbConfig<'kysely'> = {
  ...config,
  readReplica: config,
}

const expectedImplConfig = {
  host: config.host,
  port: config.port,
  user: config.username,
  password: config.password,
  database: config.database,
  max: config.maxConnections,
}

describe('KyselyDatabase', () => {
  let mockTrans
  let mockClient
  let mockDriver
  let mockDialect
  let mockPgTrans
  let mockPgClient
  beforeEach(() => {
    mockTrans = {
      execute: jest.fn(async (cb: any) => {
        cb(mockTrans)
      }),
    } as any
    mockClient = jest.fn(
      () =>
        ({
          transaction: () => mockTrans,
        }) as any as PostgresDialect
    )
    KyselyDatabase['kyselyProvider'] = mockClient as any

    mockDriver = {
      execute: jest.fn(async () => {}),
    } as any
    mockDialect = jest.fn(
      () =>
        ({
          createDriver: () => mockDriver,
        }) as any as PostgresDialect
    )
    KyselyDatabase['kyselyPgProvider'] = mockDialect as any

    mockPgTrans = {
      query: jest.fn(() => {}),
    } as any
    mockPgClient = jest.fn(
      () =>
        ({
          connect: async () => mockPgTrans,
        }) as pg.PoolClient
    )
    KyselyDatabase['pgProvider'] = mockPgClient as any
  })

  test('KyselyDatabase', async () => {
    const underTest = new KyselyDatabase(config)
    expect(mockPgClient).toHaveBeenNthCalledWith(1, expectedImplConfig)
    expect(mockDialect).toHaveBeenCalledTimes(1)
    expect(mockClient).toHaveBeenCalledTimes(1)
    expect(mockClient.mock.calls[0][0].dialect).toEqual(underTest['pgClient'])
    expect(mockClient.mock.calls[0][0].plugins).toBeInstanceOf(Array)
    const trans = await underTest.transaction()

    expect(mockTrans.execute).toHaveBeenCalledTimes(1)
    expect(trans.reader).toBeUndefined()
    expect(trans.writer).toBeInstanceOf(Object)
    expect(trans.writer.transaction).toBeInstanceOf(Function)
    expect(trans).toBeInstanceOf(Function)
    expect(trans['transaction']).toBe(mockTrans)
  })

  test('KyselyDatabase -  read replica', async () => {
    const underTest = new KyselyDatabase(config2)
    expect(mockPgClient).toHaveBeenNthCalledWith(2, expectedImplConfig)
    expect(mockDialect).toHaveBeenCalledTimes(2)
    expect(mockClient).toHaveBeenCalledTimes(2)
    expect(mockClient.mock.calls[0][0].dialect).toEqual(underTest['pgClient'])
    expect(mockClient.mock.calls[0][0].plugins).toBeInstanceOf(Array)
    expect(mockClient.mock.calls[1][0].dialect).toEqual(underTest['pgReadClient'])
    expect(mockClient.mock.calls[1][0].plugins).toBeInstanceOf(Array)

    const trans = await underTest.transaction()

    expect(mockTrans.execute).toHaveBeenCalledTimes(1)
    expect(trans.writer).toBeInstanceOf(Object)
    expect(trans.writer.transaction).toBeInstanceOf(Function)
    expect(trans.reader).toBeInstanceOf(Object)
    expect(trans).toBeInstanceOf(Function)
    expect(trans['transaction']).toBe(mockTrans)
  })
})