import type { BinaryAction } from './asset';
import type { HttpProtocolVersion, InternetProtocolVersion } from './http';

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

interface KeepAliveAction {
    keepAlive?: boolean;
    agentTimeout?: number;
}

interface SilentAction {
    silent?: boolean;
}

interface ProtocolAction {
    httpVersion?: HttpProtocolVersion;
    ipVersion?: InternetProtocolVersion;
}

export interface IHttpHost {
    localhost: boolean;
    hasProtocol(version: HttpProtocolVersion): Promise<number>;
    upgrade(version: HttpProtocolVersion, altSvc: Undef<string>): void;
    success(version: HttpProtocolVersion, status?: boolean): number;
    failed(version: HttpProtocolVersion, status?: boolean): number;
    error(version: HttpProtocolVersion, status?: boolean): number;
    didAltSvc(version: HttpProtocolVersion): boolean;
    nextAltSvc(): boolean;
    closeAltSvc(error?: boolean): boolean;
    clearAltSvc(version?: HttpProtocolVersion): void;
    flagAltSvc(version: HttpProtocolVersion, value: number): void;
    reset(): void;
    v2(): boolean;
    set version(value);
    get version(): HttpProtocolVersion;
    get protocol(): string;
    get secure(): boolean;
    get hostname(): string;
    get port(): string;
    get origin(): string;
}

export interface HttpHostConstructor {
    normalizeOrigin(value: string): string;
    formatBasicAuth(url: URL): string;
    getBasicAuth(url: URL): Undef<OutgoingHttpHeaders>;
    defineLocalHost(value: string[]): void;
    defineProtocolNegotiation(value: ObjectMap<string[]>): void;
    readonly prototype: IHttpHost;
    new(url: URL, httpVersion?: HttpProtocolVersion): IHttpHost;
}

export interface OpenOptions extends KeepAliveAction, SilentAction {
    host?: IHttpHost;
    url?: URL;
    socketPath?: string;
    httpVersion?: HttpProtocolVersion;
    method?: "GET" | "POST" | "HEAD";
    encoding?: BufferEncoding;
    format?: BufferFormat | { out?: BufferFormat; parser?: PlainObject };
    headers?: OutgoingHttpHeaders;
    timeout?: number;
    pipeTo?: string | Writable;
    postData?: unknown;
    connected?: (headers: IncomingHttpHeaders) => Void<boolean>;
    statusMessage?: string;
    outFormat?: { out: BufferFormat; parser?: PlainObject };
    outFilename?: Null<string>;
    outHeaders?: Null<IncomingHttpHeaders>;
    outStream?: Writable;
    outAbort?: AbortController;
}

export interface PostOptions extends OpenOptions {
    contentType?: string;
    formData?: ArrayOf<FormDataPart>;
    dataEncoding?: BufferEncoding;
}

export interface FormDataPart {
    name?: string;
    data?: Buffer | Readable | string;
    value?: unknown;
    contentType?: string;
    filename?: string;
}

export interface Aria2Options extends BinaryAction, SilentAction {
    pathname?: string;
    headers?: OutgoingHttpHeaders;
}

export interface HostConfig extends OpenOptions {
    host: IHttpHost;
    url: URL;
}

export interface ProxySettings extends KeepAliveAction {
    host: URL;
    exclude?: string[];
    include?: string[];
}

export interface RequestInit extends ProtocolAction {
    headers?: unknown;
    /* @deprecated - readTimeout */
    requestTimeout?: number;
    readTimeout?: number;
}

export interface ClientConfig {
    timeout?: number;
    connectTimeout?: number;
    redirectLimit?: number;
    retryWait?: number;
    retryAfter?: number;
    retryLimit?: number;
}

export interface ApplyOptions extends ProtocolAction, PlainObject {
    client?: ClientConfig;
    readExpect?: ReadExpectType;
    acceptEncoding?: boolean;
    keepAlive?: boolean;
}

export type BufferFormat = "json" | "yaml" | "json5" | "xml" | "toml";
export type ReadExpectType = "always" | "string" | "none";
export type DataEncodedResult<T extends { encoding?: BufferEncoding }> = T extends { encoding: BufferEncoding } ? string : Null<BufferContent>;
export type DataObjectResult<T extends { format?: unknown; encoding?: BufferEncoding }> = T extends { format: string | PlainObject } ? Null<object> : DataEncodedResult<T>;
export type StatusOnCallback = (code: number, headers: IncomingHttpHeaders, url?: URL) => Void<boolean>;
export type HeadersOnCallback = (headers: IncomingHttpHeaders, url?: URL) => Void<boolean>;