import type { DataSource, DbDataSource } from './squared';

import type { CacheOptions, IdentifierAction } from './core';

import type { DB_TYPE } from '../index.d';

export interface ExecuteAction<T = unknown> {
    params?: T;
}

export interface CascadeAction {
    cascade?: string;
    cacheObjectKey?: string;
    fallback?: unknown;
}

export interface ExecuteQueryOptions {
    checkObject?: CheckObjectCallback | string;
    checkObjectKey?: string;
    errorQuery?: ErrorQueryCallback;
    sessionKey?: string;
    outCacheMiss?: string[];
}

export interface ExecuteBatchQueryOptions extends ExecuteQueryOptions {
    parallel?: boolean;
    connectOnce?: boolean;
}

export interface ProcessRowsOptions {
    disconnect?: () => void;
    parallel?: boolean;
}

export interface DbConnection {
    hostname: string;
    password: string;
    pathname: string;
    port: string;
    protocol: string;
    search: string;
    username: string;
    database: string;
}

export interface HandleFailOptions {
    commandType?: number;
    errorQuery?: ErrorQueryCallback;
}

export interface ServerAuth<T = number> extends AuthValue, IdentifierAction {
    protocol?: string;
    server?: string;
    hostname?: string;
    port?: T;
    database?: string;
}

export interface IDbPool<T extends DbDataSource = DbDataSource, U = unknown, V = unknown> {
    client: U;
    lastAccessed: number;
    success: number;
    failed: number;
    poolKey: string;
    uuidKey: Null<AuthValue>;
    add(item: T, uuidKey?: string): this;
    has(item: T): boolean;
    getConnection(): Promise<V>;
    remove(): void;
    detach(force?: boolean): Promise<void>;
    close(): Promise<void>;
    isIdle(timeout: number): boolean;
    isEmpty(): boolean;
    set connected(value: boolean);
    get persist(): boolean;
    get closed(): boolean;
    get closeable(): boolean;
    set parent(value: ObjectMap<IDbPool<T>>);
}

export interface DbPoolConstructor<T extends DbDataSource = DbDataSource, U = unknown, V = unknown> {
    findKey<W extends IDbPool, X extends DbDataSource>(pools: ObjectMap<W>, uuidKey: unknown, poolKey: Undef<string>, ...items: X[]): Null<W>;
    validateKey<W extends IDbPool>(pools: ObjectMap<W>, username: string, uuidKey: unknown): [string, Null<W>];
    checkTimeout<W extends IDbPool>(pools: ObjectMap<W>, value: number, limit?: number): Promise<number>;
    readonly prototype: IDbPool<T, U, V>;
    new(pool: U, poolKey: string, uuidKey?: Null<AuthValue>): IDbPool<T, U, V>;
}

export interface PoolConfig<T = number> extends MinMax {
    idle?: T;
    queue_max?: number;
    queue_idle?: T;
    purge?: T;
    timeout?: number;
    socket_timeout?: number;
}

export interface TimeoutAction {
    timeout?: NumString;
}

export type DbSource = "mariadb" | "mongodb" | "mssql" | "mysql" | "oracle" | "postgres" | "redis";
export type QueryResult = unknown[];
export type BatchQueryResult = Null<QueryResult>[];
export type CheckObjectCallback = (item: DataSource, data: unknown) => Null<QueryResult>;
export type ErrorQueryCallback = (err: unknown, item: DbDataSource, commandType?: number) => boolean;

export interface SQL_COMMAND {
    SELECT: 1;
    INSERT: 2;
    UPDATE: 3;
    DELETE: 4;
}

export type { DB_TYPE, CacheOptions, IdentifierAction };