import type { CloudConstructor, FileManagerConstructor, ICloud, IFileManager, IHost, IImage, IModule, ImageConstructor, ModuleConstructor, WatchConstructor } from './index';

import type { ExternalAsset, IFileThread } from './asset';
import type { CacheOptions } from './core';
import type { QueryResult } from './db';
import type { ITransformSeries, OutV3, TransformSeriesConstructor } from './document';
import type { IHttpMemoryCache } from './filemanager';
import type { HttpAgentSettings, HttpProtocolVersion, HttpRequestClient, InternetProtocolVersion } from './http';
import type { CloneObjectOptions, GetFunctionsOptions } from './module';
import type { LogFailOptions, LogType, LogValue } from './logger';
import type { HostConfig, OpenOptions, ProxySettings } from './request';
import type { DbCoerceSettings, DnsLookupSettings, HttpMemorySettings, HttpSettings, ImageModule } from './settings';

import type { Readable, Writable } from 'stream';
import type { OutgoingHttpHeaders } from 'http';
import type { LookupFunction } from 'net';

// @ts-ignore
import type { BytesOptions } from 'bytes';

type CpuUsage = NodeJS.CpuUsage;

export interface IModuleLibV4 {
    isString(value: unknown): value is string;
    isObject<T = object>(value: unknown): value is T;
    isPlainObject<T = PlainObject>(value: unknown): value is T;
    escapePattern(value: unknown, lookBehind?: boolean): string;
    generateUUID(format?: string, dictionary?: string): string;
    validateUUID(value: unknown): boolean;
    cloneObject<T, U = unknown>(data: T, options?: boolean | WeakSet<object> | CloneObjectOptions<U>): T;
    coerceObject<T = unknown>(data: T, parseString?: FunctionType<unknown, string> | boolean, cache?: boolean): T;
    asFunction<T = unknown, U = FunctionType<Promise<T> | T>>(value: unknown, sync?: boolean): Null<U>;
    isFileHTTP(value: string | URL): boolean;
    isFileUNC(value: string | URL): boolean;
    isPathUNC(value: string | URL): boolean;
    toTimeMs(hrtime: HighResolutionTime, format?: boolean): NumString;
    renameExt(value: string, ext: string, when?: string): string;
    existsSafe(value: string, isFile?: boolean): boolean;
    readFileSafe(value: string, encoding: BufferEncoding | "buffer", cache?: boolean): Null<BufferContent>;
    getFunctions<T extends FunctionType>(values: unknown[], absolute?: boolean | GetFunctionsOptions, sync?: boolean, outFailed?: string[]): T[];
    formatSize(value: NumString, options?: BytesOptions): NumString;
    hasSameStat(src: string, dest: string, keepEmpty?: boolean): boolean;
    hasSize(value: string, keepEmpty?: boolean): boolean;
    getSize(value: string, diskUsed?: boolean): number;
    byteLength(value: BufferContent, encoding?: BufferEncoding): number;
    cleanupStream(target: Readable | Writable, pathname?: string): void;
    allSettled<U>(values: readonly (U | PromiseLike<U>)[], rejected?: LogValue, options?: LogFailOptions | LogType): Promise<PromiseSettledResult<U>[]>;
}

export interface IModuleCompatV4<T extends IHost = IHost> extends IModule<T> {
    set startCPU(value);
    get startCPU(): Null<CpuUsage>;
}

export interface ModuleCompatV4Constructor extends ModuleConstructor, IModuleLibV4 {
    readonly prototype: IModuleCompatV4;
    new(...args: unknown[]): IModuleCompatV4;
}

export interface IFileManagerCompatV4<T extends ExternalAsset = ExternalAsset> extends IFileManager<T> {
    archiving: boolean;
    cacheHttpRequest: boolean | FirstOf<string>;
    cacheHttpRequestBuffer: IHttpMemoryCache<T>;
    fetchTimeout: number;
    httpProxy: Null<ProxySettings>;
    acceptEncoding: boolean;
    keepAliveTimeout: number;
    addDns(hostname: string, address: string, family?: NumString): void;
    lookupDns(hostname: string): LookupFunction;
    getHttpProxy(uri: string, localhost?: boolean): Null<ProxySettings>;
    getHttpHeaders(uri: string): Undef<OutgoingHttpHeaders>;
    createHttpRequest(uri: string | URL, options?: OpenOptions): HostConfig;
    getHttpClient(uri: string | URL, options: OpenOptions): HttpRequestClient;
    set httpVersion(value);
    get httpVersion(): Null<HttpProtocolVersion>;
    set ipVersion(value);
    get ipVersion(): InternetProtocolVersion;
}

export interface FileManagerCompatV4Constructor<T extends ExternalAsset = ExternalAsset> extends FileManagerConstructor<T> {
    fromHttpStatusCode(value: NumString): string;
    resetHttpHost(version?: HttpProtocolVersion): void;
    defineHttpBuffer(options: HttpMemorySettings): void;
    defineHttpSettings(options: HttpSettings): void;
    defineHttpAgent(options: HttpAgentSettings): void;
    defineDnsLookup(options: DnsLookupSettings, clear?: boolean): void;
    clearDnsLookup(): void;
    getAria2Path(): string;
    clearHttpBuffer(percent?: number, limit?: number): void;
    readonly prototype: IFileManagerCompatV4<T>;
    new(...args: unknown[]): IFileManagerCompatV4<T>;
}

export interface ImageCompatV4Constructor<T extends IHost = IHost, U extends ImageModule = ImageModule> extends ImageConstructor<T, U> {
    using<V extends ExternalAsset>(this: T, instance: IImage<T, U>, data: IFileThread<V>, command: string): Promise<unknown>;
}

export interface ICloudCompatV4<T extends IHost = IHost> extends ICloud<T> {
    getDatabaseResult(service: string, credential: unknown, queryString: string, options?: CacheOptions | boolean | string): Undef<QueryResult>;
    setDatabaseResult(service: string, credential: unknown, queryString: string, result: unknown, options?: CacheOptions | string): QueryResult;
    hasDatabaseCache(service: string, sessionKey?: string): boolean;
    hasDatabaseCoerce(service: string, component: keyof DbCoerceSettings, credential?: unknown): boolean;
}

export interface CloudCompatV4Constructor extends CloudConstructor {
    readonly prototype: ICloudCompatV4;
    new(...args: unknown[]): ICloudCompatV4;
}

export interface WatchCompatV4Constructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset> extends WatchConstructor<T, U> {
    readCACert(value: string, cache?: boolean): string;
    readTLSKey(value: string, cache?: boolean): string;
    readTLSCert(value: string, cache?: boolean): string;
    isCert(value: string): boolean;
    parseExpires(value: NumString, start?: number): number;
}

export interface ITransformSeriesCompatV4<T = AnyObject, U = T> extends ITransformSeries<T, U>, PropertyAction<OutV3, "out"> {}

export interface TransformSeriesCompatV4Constructor extends TransformSeriesConstructor {
    readonly prototype: ITransformSeriesCompatV4;
    new(...args: unknown[]): ITransformSeriesCompatV4;
}