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

import type { IExternalConfig, IExternalFunction, IHost, IModule, ModuleConstructor } from './index';
import type { QueryResult, TimeoutAction } from './db';
import type { Settings } from './node';
import type { ClientDbSettings, ClientModule, DbCacheValue, DbCoerceSettings, DbSourceOptions } from './settings';

export interface IdentifierAction {
    uuidKey?: string;
}

export interface AddEventListenerOptions {
    capture?: boolean;
    once?: boolean;
    passive?: boolean;
    signal?: AbortSignal;
}

export interface IClient<T extends IHost, U extends ClientModule, V extends FunctionType<any, any> = FunctionType> extends IModule<T>, IExternalConfig<U, U extends ClientModule<infer W> ? W : unknown>, IExternalFunction<V> {
    init(...args: unknown[]): this;
    getUserSettings<X>(): Null<X>;
    set cacheDir(value: string);
    get cacheDir(): string;
}

export interface ClientConstructor<T extends IHost = IHost, U extends ClientModule = ClientModule> extends ModuleConstructor {
    readonly prototype: IClient<T, U>;
    new(module?: U): IClient<T, U>;
}

export interface IClientDb<T extends IHost, U extends ClientModule<ClientDbSettings>, V extends DataSource = DataSource, W extends DbSourceOptions = DbSourceOptions, X extends DbCoerceSettings = DbCoerceSettings> extends IClient<T, U> {
    database: V[];
    cacheExpires: number;
    add(item: V, state?: number): void;
    hasCache(source: string, sessionKey?: string): boolean;
    hasCoerce(source: string, component: keyof DbCoerceSettings, uuidKey: Undef<string>): boolean;
    hasCoerce(source: string, component: keyof DbCoerceSettings, credential?: unknown): boolean;
    getQueryResult(source: string, credential: unknown, queryString: string, renewCache: boolean): Undef<QueryResult>;
    getQueryResult(source: string, credential: unknown, queryString: string, sessionKey?: string, renewCache?: boolean): Undef<QueryResult>;
    getQueryResult(source: string, credential: unknown, queryString: string, options?: CacheOptions | string, renewCache?: boolean): Undef<QueryResult>;
    setQueryResult(source: string, credential: unknown, queryString: string, result: unknown, sessionKey?: string): QueryResult;
    setQueryResult(source: string, credential: unknown, queryString: string, result: unknown, options?: CacheOptions | string): QueryResult;
    getCacheResult(source: string, credential: unknown, queryString: string, cacheValue: CacheOptions, ignoreCache?: IntBool | FirstOf<number, number>): Undef<QueryResult>;
    applyState(items: ArrayOf<V>, value: number, as?: boolean): void;
    commit(items?: V[]): Promise<boolean>;
    valueOfKey(credential: unknown, name: keyof W, component?: keyof X): unknown;
    settingsOf(source: string, name: keyof W, component?: keyof X): unknown;
    settingsKey(uuidKey: string, name: keyof W, component?: keyof X): unknown;
    get pending(): V[];
    get committed(): V[];
    get failed(): V[];
}

export interface ClientDbConstructor<T extends IHost = IHost, U extends ClientModule = ClientModule, V extends DataSource = DataSource> extends ClientConstructor<T, U> {
    STORE_RESULT_PARTITION_SIZE: number;
    STORE_RESULT_PARTITION_MULT: number;
    readonly TRANSACTION_ACTIVE: number;
    readonly TRANSACTION_PARTIAL: number;
    readonly TRANSACTION_COMMIT: number;
    readonly TRANSACTION_TERMINATE: number;
    readonly TRANSACTION_ABORT: number;
    readonly TRANSACTION_FAIL: number;
    loadSettings(settings: Pick<Settings, "process" | "memory">, password?: string): boolean;
    getTimeout(value: Undef<number | string | TimeoutAction>): number;
    convertTime(value: number | string): number;
    findResult(source: string, credential: unknown, queryString: string, timeout: number, sessionKey?: string | boolean, renewCache?: boolean): Undef<QueryResult>;
    storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, options: StoreResultOptions): QueryResult;
    storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, sessionKey: string, sessionExpires: number): QueryResult;
    storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, cache: DbCacheValue): QueryResult;
    storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, cache: Undef<DbCacheValue>, options: StoreResultOptions): QueryResult;
    purgeResult(prefix?: string): Promise<number>;
    extractUUID(credential: unknown): string;
    setPoolConfig(value: unknown): void;
    getPoolConfig(source: string): unknown;
    keyOfResult(source: string, credential: unknown, uuidOnly?: boolean): string;
    readonly prototype: IClientDb<T, U, V>;
    new(module?: U, database?: V[]): IClientDb<T, U, V>;
}

export interface IAbortComponent extends AbortController {
    reset(): void;
    get aborted(): boolean;
}

export interface AbortComponentConstructor {
    attach(instance: IAbortComponent, signal: AbortSignal, options?: AddEventListenerOptions): void;
    detach(instance: IAbortComponent, signal: AbortSignal): void;
    readonly prototype: IAbortComponent;
    new(): IAbortComponent;
}

export interface IPermission {
    setDiskRead(pathname?: ArrayOf<string>, enabled?: boolean): void;
    setDiskWrite(pathname?: ArrayOf<string>, enabled?: boolean): void;
    setUNCRead(pathname?: ArrayOf<string>, enabled?: boolean): void;
    setUNCWrite(pathname?: ArrayOf<string>, enabled?: boolean): void;
    getDiskRead(): ArrayOf<string>;
    getDiskWrite(): ArrayOf<string>;
    getUNCRead(): ArrayOf<string>;
    getUNCWrite(): ArrayOf<string>;
    hasDiskRead(pathname: string): boolean;
    hasDiskWrite(pathname: string): boolean;
    hasUNCRead(pathname: string): boolean;
    hasUNCWrite(pathname: string): boolean;
    get diskRead(): boolean;
    get diskWrite(): boolean;
    get uncRead(): boolean;
    get uncWrite(): boolean;
}

export interface PermissionConstructor {
    create(settings: PermittedDirectories, freeze?: boolean): Null<IPermission>;
    create(settings: PermittedDirectories, parent: Null<IPermission>, freeze?: boolean): Null<IPermission>;
    validate(settings: unknown): settings is PermittedDirectories;
    clone(permission: IPermission, freeze?: boolean): IPermission;
    match(pathname: string, pattern: ArrayOf<string>): boolean;
    toPosix(value: unknown): ArrayOf<string>;
    readonly prototype: IPermission;
    new(freeze?: boolean): IPermission;
}

export interface PermissionReadWrite<T = boolean> {
    disk_read?: T;
    disk_write?: T;
    unc_read?: T;
    unc_write?: T;
}

export interface PermissionAction {
    permission?: PermittedDirectories;
}

export interface HostInitConfig<T extends HostInitLog = HostInitLog> extends PlainObject, RequestBase<T> {
    username?: string;
    ignoreModules?: string[];
}

export interface HostInitLog {
    enabled?: boolean;
    level?: number | string;
    exclude?: ArrayOf<string>;
    useColor?: boolean;
    silent?: boolean;
    showProgress?: boolean;
}

export interface PermittedDirectories extends PermissionReadWrite<ArrayOf<string>> {
    inherit?: boolean;
}

export interface StoreResultOptions {
    cache?: DbCacheValue;
    cacheDir?: string;
    sessionKey?: string;
    sessionExpires?: number;
}

export interface CacheOptions {
    value?: DbCacheValue;
    renewCache?: boolean;
    exclusiveOf?: FirstOf<number, number>;
    sessionKey?: string;
}

export interface ThreadInfo {
    pid: number;
    startTime: number;
    username?: string;
    sessionId?: string;
    broadcastId?: ArrayOf<string>;
}

export interface ThreadCountStat {
    count: number;
    pending: number;
    opened?: number;
    closed?: number;
    queued?: number;
    rejected?: number;
    killed?: number;
    startTime?: number;
    previousTime?: number;
    max?: number;
    admin?: ThreadInfo[];
}

export interface JoinQueueOptions {
    args?: unknown[];
    reject?: boolean;
}

export interface ResumeThreadOptions {
    args: unknown[];
    startTime: number;
    aborted?: boolean;
}