import type { Request, Response } from 'express';
import type { Callable, DefAPINamespace, DeleteAPICallT, GetAPICallT, HeadAPICallT, HttpMethod, InvalidResponse, PatchAPICallT, PostAPICallT, PutAPICallT, RawArgType, ValidResponse, recoveryMethod } from '../apiStructure/defs';

export const treatedSpecial = Symbol('treatedSpecial');
export type APINamespace = {
    [key: string]: APINamespace
    | GET<any, any, any>
    | POST<any, any, any>
    | PUT<any, any, any>
    | DELETE<any, any, any>
    | PATCH<any, any, any>
    | HEAD<any, any, any>
    ;
}

export abstract class APIExecuter<R extends ValidResponse, E extends InvalidResponse, Q extends RawArgType>{
    readonly abstract reqType: HttpMethod;
    protected abstract parseQuery(expressReq: Request): Promise<Q>;
    protected abstract api(query: Q, expressReq: Request, expressRes: Response): Promise<R | E | true>;
    public async run(expressReq: Request, expressRes: Response): Promise<void> {
        const query = await this.parseQuery(expressReq);
        //TODO: middleware (인증, 요구사항, 아마도 decorator)
        const result = await this.api(query, expressReq, expressRes);
        if (result === true) {
            return;
        }
        expressRes.json(result);
    }
}

export abstract class APIBodyParseExecuter<R extends ValidResponse, E extends InvalidResponse, Q extends RawArgType> extends APIExecuter<R, E, Q>{
    protected async parseQuery(expressReq: Request): Promise<Q> {
        throw new Error('Not implemented');
        return expressReq.body;
    }
}

export abstract class GET<R extends ValidResponse, E extends InvalidResponse, Q extends RawArgType> extends APIExecuter<R, E, Q>{
    override readonly reqType = 'get';
    protected async parseQuery(expressReq: Request): Promise<Q> {
        expressReq.query;
        throw new Error('Not implemented');
        return expressReq.query as unknown as Q;
    }
}

export abstract class POST<R extends ValidResponse, E extends InvalidResponse, Q extends RawArgType> extends APIBodyParseExecuter<R, E, Q>{
    readonly reqType = 'post';
}

export abstract class PUT<R extends ValidResponse, E extends InvalidResponse, Q extends RawArgType> extends APIBodyParseExecuter<R, E, Q>{
    readonly reqType = 'put';
}

export abstract class DELETE<R extends ValidResponse, E extends InvalidResponse, Q extends RawArgType> extends APIBodyParseExecuter<R, E, Q>{
    readonly reqType = 'delete';
}

export abstract class PATCH<R extends ValidResponse, E extends InvalidResponse, Q extends RawArgType> extends APIBodyParseExecuter<R, E, Q>{
    readonly reqType = 'patch';
}

export abstract class HEAD<R extends ValidResponse, E extends InvalidResponse, Q extends RawArgType> extends APIBodyParseExecuter<R, E, Q>{
    readonly reqType = 'head';
}

export function raiseError(reason: string, recovery?: recoveryMethod): InvalidResponse {
    if (recovery) {
        return {
            result: false,
            reason,
            recovery,
        };
    }
    return {
        result: false,
        reason,
    };
}

export type GetClassGenerator<T> = {
    prototype: T
};
export type APIServerType<T extends Callable> =
    T extends GetAPICallT<infer Q, infer R, infer E> ? GetClassGenerator<GET<R, E, Q>> :
    T extends PostAPICallT<infer Q, infer R, infer E> ? GetClassGenerator<POST<R, E, Q>> :
    T extends PutAPICallT<infer Q, infer R, infer E> ? GetClassGenerator<PUT<R, E, Q>> :
    T extends DeleteAPICallT<infer Q, infer R, infer E> ? GetClassGenerator<DELETE<R, E, Q>> :
    T extends PatchAPICallT<infer Q, infer R, infer E> ? GetClassGenerator<PATCH<R, E, Q>> :
    T extends HeadAPICallT<infer Q, infer R, infer E> ? GetClassGenerator<HEAD<R, E, Q>> :
    never;
export type APINamespaceType<T extends DefAPINamespace> = {
    [K in keyof T]:
    T[K] extends Callable ? APIServerType<T[K]> :
    T[K] extends DefAPINamespace ? APINamespaceType<T[K]> :
    never;
};