export type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head';
export type RawArgType = Record<string, unknown> | Record<string, unknown>[] | undefined;


export interface BasicAPICallT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse
> {
    (args: ArgType): Promise<ResultType>;
    (args: ArgType, returnError: false): Promise<ResultType>;
    (args: ArgType, returnError: true): Promise<ResultType | ErrorType>;
    readonly reqType: HttpMethod;
}

export type BasicGetAPICallT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse
> = BasicAPICallT<ArgType, ResultType, ErrorType> & { readonly reqType: 'get' };

export type BasicPostAPICallT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse
> = BasicAPICallT<ArgType, ResultType, ErrorType> & { readonly reqType: 'post' };

export type BasicPutAPICallT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse
> = BasicAPICallT<ArgType, ResultType, ErrorType> & { readonly reqType: 'put' };

export type BasicDeleteAPICallT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse
> = BasicAPICallT<ArgType, ResultType, ErrorType> & { readonly reqType: 'delete' };

export type BasicPatchAPICallT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse
> = BasicAPICallT<ArgType, ResultType, ErrorType> & { readonly reqType: 'patch' };

export type BasicHeadAPICallT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse
> = BasicAPICallT<ArgType, ResultType, ErrorType> & { readonly reqType: 'head' };

export interface EmptyAPICallT<ResultType extends ValidResponse, ErrorType extends InvalidResponse> {
    (): Promise<ResultType>;
    (args?: undefined): Promise<ResultType>;
    (args: undefined, returnError: false): Promise<ResultType>;
    (args: undefined, returnError: true): Promise<ResultType | ErrorType>;
    readonly reqType: HttpMethod;
}

export type EmptyGetAPICallT<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse
> = EmptyAPICallT<ResultType, ErrorType> & { readonly reqType: 'get' };

export type EmptyPostAPICallT<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse
> = EmptyAPICallT<ResultType, ErrorType> & { readonly reqType: 'post' };

export type EmptyPutAPICallT<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse
> = EmptyAPICallT<ResultType, ErrorType> & { readonly reqType: 'put' };

export type EmptyDeleteAPICallT<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse
> = EmptyAPICallT<ResultType, ErrorType> & { readonly reqType: 'delete' };

export type EmptyPatchAPICallT<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse
> = EmptyAPICallT<ResultType, ErrorType> & { readonly reqType: 'patch' };

export type EmptyHeadAPICallT<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse
> = EmptyAPICallT<ResultType, ErrorType> & { readonly reqType: 'head' };

// eslint-disable-next-line @typescript-eslint/no-explicit-any
export type ArgTypeOf<T> = T extends APICallT<infer A, any, any> ? A : never;


export type APICallT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse = ValidResponse,
    ErrorType extends InvalidResponse = InvalidResponse
> = ArgType extends undefined ? EmptyAPICallT<ResultType, ErrorType> : BasicAPICallT<ArgType, ResultType, ErrorType>;

export type GetAPICallT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse = ValidResponse,
    ErrorType extends InvalidResponse = InvalidResponse
> = ArgType extends undefined ? EmptyGetAPICallT<ResultType, ErrorType> : BasicGetAPICallT<ArgType, ResultType, ErrorType>;

export type PostAPICallT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse = ValidResponse,
    ErrorType extends InvalidResponse = InvalidResponse
> = ArgType extends undefined ? EmptyPostAPICallT<ResultType, ErrorType> : BasicPostAPICallT<ArgType, ResultType, ErrorType>;

export type PutAPICallT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse = ValidResponse,
    ErrorType extends InvalidResponse = InvalidResponse
> = ArgType extends undefined ? EmptyPutAPICallT<ResultType, ErrorType> : BasicPutAPICallT<ArgType, ResultType, ErrorType>;

export type DeleteAPICallT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse = ValidResponse,
    ErrorType extends InvalidResponse = InvalidResponse
> = ArgType extends undefined ? EmptyDeleteAPICallT<ResultType, ErrorType> : BasicDeleteAPICallT<ArgType, ResultType, ErrorType>;

export type PatchAPICallT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse = ValidResponse,
    ErrorType extends InvalidResponse = InvalidResponse
> = ArgType extends undefined ? EmptyPatchAPICallT<ResultType, ErrorType> : BasicPatchAPICallT<ArgType, ResultType, ErrorType>;

export type HeadAPICallT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse = ValidResponse,
    ErrorType extends InvalidResponse = InvalidResponse
> = ArgType extends undefined ? EmptyHeadAPICallT<ResultType, ErrorType> : BasicHeadAPICallT<ArgType, ResultType, ErrorType>;

export type APITail = ReturnType<typeof GET> | ReturnType<typeof POST> | ReturnType<typeof PUT> | ReturnType<typeof DELETE> | ReturnType<typeof PATCH> | ReturnType<typeof HEAD>;

export function GET<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): EmptyGetAPICallT<ResultType, ErrorType>
export function GET<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): BasicGetAPICallT<ArgType, ResultType, ErrorType>;
export function GET<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): BasicGetAPICallT<ArgType, ResultType, ErrorType> | EmptyGetAPICallT<ResultType, ErrorType> {
    return Object.assign(
        fakeGET,
        { reqType: 'get' } as const
    )
}

export function POST<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): EmptyPostAPICallT<ResultType, ErrorType>
export function POST<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): BasicPostAPICallT<ArgType, ResultType, ErrorType>;
export function POST<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): BasicPostAPICallT<ArgType, ResultType, ErrorType> | EmptyPostAPICallT<ResultType, ErrorType> {
    return Object.assign(
        fakePOST,
        { reqType: 'post' } as const
    )
}

export function PUT<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): EmptyPutAPICallT<ResultType, ErrorType>
export function PUT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): BasicPutAPICallT<ArgType, ResultType, ErrorType>;
export function PUT<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): BasicPutAPICallT<ArgType, ResultType, ErrorType> | EmptyPutAPICallT<ResultType, ErrorType> {
    return Object.assign(
        fakePUT,
        { reqType: 'put' } as const
    )
}

export function DELETE<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): EmptyDeleteAPICallT<ResultType, ErrorType>
export function DELETE<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): BasicDeleteAPICallT<ArgType, ResultType, ErrorType>;
export function DELETE<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): BasicDeleteAPICallT<ArgType, ResultType, ErrorType> | EmptyDeleteAPICallT<ResultType, ErrorType> {
    return Object.assign(
        fakeDELETE,
        { reqType: 'delete' } as const
    )
}

export function PATCH<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): EmptyPatchAPICallT<ResultType, ErrorType>
export function PATCH<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): BasicPatchAPICallT<ArgType, ResultType, ErrorType>;
export function PATCH<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): BasicPatchAPICallT<ArgType, ResultType, ErrorType> | EmptyPatchAPICallT<ResultType, ErrorType> {
    return Object.assign(
        fakePATCH,
        { reqType: 'patch' } as const
    )
}

export function HEAD<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): EmptyHeadAPICallT<ResultType, ErrorType>
export function HEAD<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): BasicHeadAPICallT<ArgType, ResultType, ErrorType>;
export function HEAD<
    ArgType extends RawArgType,
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
>(): BasicHeadAPICallT<ArgType, ResultType, ErrorType> | EmptyHeadAPICallT<ResultType, ErrorType> {
    return Object.assign(
        fakeHEAD,
        { reqType: 'head' } as const
    )
}

export async function fakeGET<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
    ArgType extends undefined = undefined
>(args?: ArgType, returnError = false): Promise<ResultType | ErrorType> {
    throw `Can't directly call GET. ${args}, ${returnError}. Use auto-generated path API.`
}

export async function fakePOST<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
    ArgType extends RawArgType = undefined
>(args: ArgType, returnError = false): Promise<ResultType | ErrorType> {
    throw `Can't directly call POST. ${args}, ${returnError}. Use auto-generated path API.`
}

export async function fakePUT<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
    ArgType extends RawArgType = undefined
>(args: ArgType, returnError = false): Promise<ResultType | ErrorType> {
    throw `Can't directly call PUT. ${args}, ${returnError}. Use auto-generated path API.`;
}

export async function fakeDELETE<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
    ArgType extends RawArgType = undefined
>(args: ArgType, returnError = false): Promise<ResultType | ErrorType> {
    throw `Can't directly call DELETE. ${args}, ${returnError}. Use auto-generated path API.`;
}

export async function fakePATCH<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
    ArgType extends RawArgType = undefined
>(args: ArgType, returnError = false): Promise<ResultType | ErrorType> {
    throw `Can't directly call PATCH. ${args}, ${returnError}. Use auto-generated path API.`
}

export async function fakeHEAD<
    ResultType extends ValidResponse,
    ErrorType extends InvalidResponse,
    ArgType extends RawArgType = undefined
>(args?: ArgType, returnError = false): Promise<ResultType | ErrorType> {
    throw `Can't directly call HEAD. ${args}, ${returnError}. Use auto-generated path API.`;
}

export interface ValidResponse {
    result: true;
}

export type recoveryMethod = 'refreshEntirePage' | 'retryAPI' | 'gameLogin' | 'gatewayLogin' | 'gateway2FA' | 'gameQuota';
export interface InvalidResponse {
    result: false;
    reason: string;
    recovery?: recoveryMethod;
}

type ExtractValid<T> = T extends ValidResponse ? T : never;
type ExtractInvalid<T> = T extends InvalidResponse ? T : never;

export type Callable = (...args: any) => any;

export type ExtractResponse<T extends Callable> = ExtractValid<Awaited<ReturnType<T>>>;
export type ExtractError<T extends Callable> = ExtractInvalid<Awaited<ReturnType<T>>>;
export type ExtractQuery<T extends Callable> = Parameters<T>[0];

export type DefAPINamespace = {
    [key: string]: DefAPINamespace
    | BasicGetAPICallT<any, any, any>
    | BasicPostAPICallT<any, any, any>
    | BasicPutAPICallT<any, any, any>
    | BasicDeleteAPICallT<any, any, any>
    | BasicPatchAPICallT<any, any, any>
    | BasicHeadAPICallT<any, any, any>
    | EmptyGetAPICallT<any, any>
    | EmptyPostAPICallT<any, any>
    | EmptyPutAPICallT<any, any>
    | EmptyDeleteAPICallT<any, any>
    | EmptyPatchAPICallT<any, any>
    | EmptyHeadAPICallT<any, any>
    ;
}

export type APICompatType<T extends Callable> = T extends APICallT<infer A, infer R, infer E> ? APICallT<A, R, E> : never;