import type { WatchInterval } from './squared';

import type { PermissionAction, PermissionReadWrite, PermittedDirectories } from './core';
import type { DbSource, PoolConfig, TimeoutAction } from './db';
import type { HttpOutgoingHeaders } from './http';
import type { BroadcastOutMethod, ErrorOutMethod, LoggerColor, LoggerFormat, LoggerStatus } from './logger';

import type { LookupAddress } from 'dns';
import type { SecureVersion } from 'tls';
import type { SpawnOptions } from 'child_process';
import type { BrotliOptions, ZlibOptions } from 'zlib';
import type { BinaryLike, CipherGCMTypes } from 'crypto';

// @ts-ignore
import type { Options as ZopfliOptions } from 'node-zopfli';
// @ts-ignore
import type { PicomatchOptions } from 'picomatch';
// @ts-ignore
import type { MinimatchOptions } from 'minimatch';
// @ts-ignore
import type { Unit } from 'bytes';

export interface HandlerModule<T = PlainObject> extends HandlerSettings<T> {
    handler?: string;
    extensions?: string[];
}

export interface HandlerSettings<T = PlainObject> {
    settings?: T & { broadcast_id?: StringOfArray };
}

export interface ClientModule<T = ClientSettings> extends HandlerModule<T>, PermissionAction {}

export interface ClientSettings<T = PlainObject> extends PlainObject {
    users?: ObjectMap<T>;
    cache_dir?: string;
}

export interface NodeModule<T = PlainObject> extends HandlerSettings<T> {
    process?: {
        cpu_usage?: boolean;
        memory_usage?: boolean;
        inline?: boolean;
    };
    require?: {
        ext?: StringOfArray | boolean;
        npm?: boolean;
        inline?: boolean;
    };
}

export interface ProcessModule<T = PlainObject> extends HandlerSettings<T> {
    env?: ProcessEnvConfig;
    thread?: {
        admin: {
            users?: string[];
            private?: boolean;
        };
        limit?: NumString;
        expires?: NumString;
        queue?: {
            limit?: NumString;
            expires?: NumString;
            priority: { bypass?: NumString } & MinMax<NumString>;
        };
    };
    cipher?: CipherConfig;
    password?: string;
}

export interface ProcessEnvConfig {
    apply?: boolean;
}

export interface TempModule<T = PlainObject> extends HandlerSettings<T> {
    dir?: string;
    write?: boolean;
}

export interface PermissionModule<T = PermissionSettings> extends PermittedDirectories, HandlerSettings<T> {
    home_read?: boolean;
    home_write?: boolean;
    process_exec?: (string | ExecOptions)[];
}

export interface PermissionSettings extends PlainObject {
    picomatch?: Null<PicomatchOptions>;
    minimatch?: Null<MinimatchOptions>;
}

export interface DownloadModule<T = PlainObject> extends HandlerSettings<T> {
    expires?: NumString;
    aria2?: {
        bin?: string | false;
        exec?: ExecAction;
        update_status?: NumString | { interval?: NumString; broadcast_only?: boolean };
        max_concurrent_downloads?: NumString;
        max_connection_per_server?: NumString;
        bt_stop_timeout?: NumString;
        bt_tracker_connect_timeout?: NumString;
        bt_tracker_timeout?: NumString;
        min_split_size?: string;
        disk_cache?: NumString;
        lowest_speed_limit?: NumString;
        always_resume?: boolean;
        file_allocation?: "none" | "prealloc" | "trunc" | "falloc";
        conf_path?: string;
    };
}

export interface DocumentModule<T = DocumentSettings, U = DbSettings> extends ClientModule<T> {
    eval?: DocumentEval;
    imports?: StringMap;
    versions?: StringMap;
    format?: AnyObject;
    db?: DbModule<U>;
}

export interface DocumentEval {
    function?: boolean;
    absolute?: boolean;
}

export interface DocumentGroup<T = { imports?: StringMap } & AnyObject, U = T> {
    transform?: T;
    view_engine?: U;
    pages?: ObjectMap<AnyObject>;
    imports?: StringMap;
}

export interface DocumentUserSettings<T = AnyObject, U = T> extends DocumentGroup<T, U>, PlainObject {
    extensions?: Null<string[]>;
    imports_strict?: boolean;
}

export interface DocumentComponent<T = boolean, U = T, V = U> extends Omit<DocumentGroup<T, U>, "pages"> {
    cloud?: V;
}

export interface DocumentComponentOption<T = unknown> {
    cache?: T;
    coerce?: boolean;
    abort?: boolean;
    local_file?: NumString;
}

export interface DocumentSettings extends DocumentGroup, PurgeAction, ClientSettings<DocumentUserSettings>, PlainObject {
    imports_strict?: boolean;
    directory?: DocumentDirectory;
    options?: DocumentComponentOptions;
}

export interface DocumentDirectory extends StringMap {
    package?: string;
}

export type DocumentComponentOptions = DocumentComponent<DocumentComponentOption<DocumentTransform>, DocumentComponentOption<boolean>>;

export interface ClientDbSettings<T = PlainObject> extends ClientSettings<T>, PurgeAction {
    session_expires?: number;
    user_key?: ObjectMap<DbSourceOptions>;
    imports?: StringMap;
}

export interface MemoryModule<T = MemorySettings> extends HandlerSettings<T>, Record<string, Undef<T | ObjectMap<PurgeBase>>> {}

export interface MemorySettings extends PlainObject {
    users?: boolean | string[];
    cache_disk?: MemoryCacheDiskSettings;
}

export interface MemoryCacheDiskSettings<T = NumString> extends IncludeAction<Null<string[]>> {
    enabled?: boolean;
    min_size?: T;
    max_size?: T;
    expires?: T;
}

export interface DbModule<T = DbSettings> extends ClientModule<T>, DbSourceDataType<ObjectMap<StringMap>>, PlainObject {}

export interface DbSettings<T = DbUserSettings> extends ClientDbSettings<T>, DbSourceDataType<DbSourceOptions> {}

export interface DbUserSettings extends DbSourceDataType<{ commands?: ObjectMap<ObjectMap<PlainObject>> }>, PlainObject {}

export interface DbCacheSettings extends TimeoutAction {
    dir?: string;
    purge?: NumString;
    when_empty?: boolean;
}

export interface DbSourceOptions {
    pool?: PoolConfig<NumString>;
    cache?: DbCacheValue;
    coerce?: DbCoerceValue;
}

export interface DbCoerceSettings<T = boolean> {
    credential?: T;
    options?: T;
}

export interface PurgeBase<T = NumString> extends MinMax {
    enabled?: boolean;
    percent?: T;
    limit?: number;
}

export interface PurgeComponent extends PurgeBase {
    interval?: NumString;
    all?: boolean | number;
    log?: boolean;
    prefix?: string;
}

export type DbCacheValue = NumString | DbCacheSettings;
export type DbCoerceValue = boolean | DbCoerceSettings;

export type ImageModule<T = ImageSettings> = ClientModule<T>;

export interface ImageSettings extends PlainObject {
    cache?: boolean;
    webp?: {
        path?: string;
        cwebp?: string[];
        gif2webp?: string[];
    };
}

export interface RequestModule<T = RequestSettings> extends HandlerSettings<T> {
    timeout?: NumString;
    read_timeout?: NumString;
    agent?: {
        keep_alive?: boolean;
        timeout?: NumString;
    };
    disk?: HttpDiskSettings;
    buffer?: HttpMemorySettings;
    connect?: HttpConnectSettings;
    dns?: DnsLookupSettings;
    use?: {
        http_version?: NumString;
        accept_encoding?: boolean;
    };
    proxy?: AuthValue & IncludeAction & {
        address?: string;
        port?: NumString;
        keep_alive?: boolean;
    };
    headers?: HttpOutgoingHeaders;
    certs?: ObjectMap<SecureConfig<StringOfArray>>;
    localhost?: string[];
    protocol?: {
        "http/1.1": string[];
        h2c: string[];
        h2: string[];
    };
    post_limit?: NumString;
}

export interface RequestSettings extends PurgeAction, PlainObject {
    cache?: boolean | string[];
    time_format?: "readable" | "relative" | "none";
}

export interface WatchModule<T = WatchSettings> extends HandlerModule<T>, ServerInfo {
    interval?: NumString;
}

export interface WatchSettings<T = WatchUserSettings> extends ClientSettings<ObjectMap<T>>, PlainObject {}

export interface CompressModule<U = CompressSettings> extends HandlerSettings<U> {
    gzip?: ZlibOptions;
    brotli?: BrotliOptions;
    zopfli?: ZopfliOptions;
    tinify?: {
        api_key?: string;
        proxy?: string;
    };
}

export interface CompressSettings extends PlainObject {
    cache?: boolean;
    cache_expires?: NumString;
    gzip_level?: NumString;
    brotli_quality?: NumString;
    zopfli_iterations?: NumString;
    chunk_size?: NumString;
}

export interface TaskModule<T = PlainObject> extends ClientModule<T>, PlainObject {}

export interface CloudModule<T = CloudSettings> extends ClientModule<T>, CloudServiceDataType<ObjectMap<AnyObject>>, PlainObject {
    apiVersion?: string;
}

export interface CloudSettings extends ClientDbSettings, CloudServiceDataType<CloudServiceOptions> {}

export interface CloudServiceDataType<T = unknown> {
    atlas?: T;
    aws?: T;
    "aws-v3"?: T;
    az?: T;
    azure?: T;
    gcp?: T;
    gcloud?: T;
    ibm?: T;
    oci?: T;
    minio?: T;
}

export type CloudServiceOptions = Omit<DbSourceOptions, "pool">;

export interface ErrorModule extends HandlerModule {
    out?: string | ErrorOutMethod;
    abort?: string[];
    fatal?: boolean;
    recursion_limit?: NumString;
}

export interface LoggerModule<T = NumString, U = boolean | T, V = LoggerFormat<T>> {
    enabled?: boolean;
    level?: NumString;
    production?: string[];
    format?: LoggerFormatSettings<V>;
    meter?: LoggerMeterSettings<T>;
    broadcast?: BroadcastServer & { color?: boolean };
    status?: boolean | LoggerStatus;
    color?: boolean;
    session_id?: U;
    message?: boolean;
    stack_trace?: boolean | T;
    abort?: boolean;
    stdout?: boolean;
    unknown?: boolean | LoggerColor;
    system?: boolean | LoggerColor;
    node?: boolean | LoggerColor;
    process?: boolean | LoggerColor & { cpu?: boolean; cpu_bar?: boolean | ArrayOf<number>; cpu_single_core?: boolean; mem?: boolean; mem_format?: "%" | Unit };
    image?: boolean | LoggerColor;
    compress?: boolean | LoggerColor;
    watch?: boolean | LoggerColor;
    file?: boolean | LoggerColor;
    cloud?: boolean | LoggerColor;
    db?: boolean | LoggerColor;
    time_elapsed?: boolean | LoggerColor;
    time_process?: boolean | LoggerColor;
    exec?: boolean | LoggerColor;
    http?: boolean | LoggerColor;
}

export interface LoggerFormatSettings<T = PlainObject> {
    title?: T;
    value?: T;
    hint?: T & { unit?: "auto" | "s" | "ms" };
    session_id?: T;
    message?: T;
    meter?: T;
}

export interface LoggerMeterSettings<T = NumString> {
    http?: T;
    image?: T;
    compress?: T;
    process?: T;
}

export interface HttpSettings {
    version?: NumString;
    timeout?: NumString;
    headers?: HttpOutgoingHeaders;
    certs?: ObjectMap<SecureConfig<StringOfArray>>;
}

export interface HttpDiskSettings extends IncludeAction {
    enabled?: boolean;
    limit?: NumString;
    expires?: NumString;
}

export interface HttpMemorySettings extends HttpDiskSettings {
    limit_all?: NumString;
    to_disk?: NumString | [NumString, NumString?];
    purge_amount?: NumString;
}

export interface HttpConnectSettings {
    timeout?: NumString;
    retry_wait?: NumString;
    retry_after?: NumString;
    retry_limit?: NumString;
    redirect_limit?: NumString;
}

export interface DnsLookupSettings {
    family?: NumString;
    expires?: NumString;
    resolve?: ObjectMap<Partial<LookupAddress>>;
}

export interface HashConfig extends IncludeAction<ObjectMap<string[] | "*">> {
    enabled?: boolean;
    algorithm?: HashAlgorithm;
    etag?: boolean;
    expires?: NumString;
    renew?: boolean;
    limit?: NumString;
}

export interface SecureConfig<T = string, U = T> {
    ca?: T;
    key?: U;
    cert?: T;
    passphrase?: U;
    version?: SecureVersion;
}

export interface ServerPort<T = NumString> {
    port?: T;
}

export interface ServerInfo<T = NumString> extends ServerPort<T> {
    enabled?: boolean;
    secure?: SecureConfig & ServerPort<T>;
}

export interface ServerSecure extends SecureConfig, ServerPort {}

export interface BroadcastServer extends ServerInfo<ArrayOf<NumString>> {
    out?: string | BroadcastOutMethod;
}

export interface ExecOptions extends SpawnOptions {
    command?: string;
    warn?: StringOfArray;
}

export interface ExecAction {
    uid?: NumString;
    gid?: NumString;
}

export interface PurgeAction {
    purge?: PurgeComponent;
}

export interface IncludeAction<T = string[]> {
    include?: T;
    exclude?: T;
}

export interface CipherConfig {
    algorithm?: CipherGCMTypes;
    key?: BinaryLike;
    iv?: BinaryLike;
}

export type DbSourceDataType<T = unknown> = {
    [K in DbSource]?: T;
};

export type WatchUserSettings = ObjectMap<WatchInterval>;
export type DocumentTransform = Null<boolean | "etag" | HashAlgorithm | HashConfig>;
export type HashAlgorithm = "md5" | "sha1" | "sha256" | "sha224" | "sha384" | "sha512";

export type { PermissionReadWrite };