import { IncomingMessage, ServerResponse } from 'http';

type Request = IncomingMessage & {
    params: any;
    method: HttpMethod;
    headers?: Record<string, string>;
    body?: any;
    raw_body?: any;
    files?: any;
    query?: Record<string, string>;
};
type Response = ServerResponse;
type LexerToken = {
    type: string;
    value: string;
};
type HandlerType = (req: Request, res: Response, next?: (() => any) | undefined) => Promise<any> | any;
type ControllerDecoratorOptions = {
    middlewares?: MiddlewareProvider[];
};
type MiddlewareProvider = typeof Middleware | Middleware | ((request: Request, response: Response, next: () => Promise<void>) => Promise<void>);
type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
type RouteCheck = (req: Request, res: Response) => boolean;

declare abstract class Middleware {
    protected constructor(params?: any);
    static getInstance(params: any): Middleware;
    abstract call(req: Request, res: Response, next: () => Promise<void>): Promise<void>;
}

declare class Route {
    methods: HttpMethod[];
    path: string;
    handler: HandlerType;
    private middlewares;
    private checks;
    private urlRegex;
    constructor(methods: HttpMethod[], path: string, handler: HandlerType);
    pathToRegex(path: string): RegExp;
    lexUrlPath(path: string): {
        type: string;
        value: string;
    }[];
    tokensToRegex(tokens: LexerToken[]): RegExp;
    /**
     * to evaluadate if request is a match for this route
     * @param request http request
     * @returns return true if route is a match for this request
     */
    test(request: Request): boolean;
    testPath(pathname: string): boolean;
    /**
     * returns details of the match, otherwise it returns false
     * @param request the request to match
     * @returns object cotaining details of match including matched params
     */
    match(request: Request): false | {
        url: URL;
        params: {
            [key: string]: string;
        };
    };
    prependMiddleware(middlewares: MiddlewareProvider | MiddlewareProvider[]): this;
    addMiddleware(middlewares: MiddlewareProvider | MiddlewareProvider[]): this;
    getMiddlewares(): MiddlewareProvider[];
    addCheck(checks: RouteCheck | RouteCheck[]): this;
    getChecks(): RouteCheck[];
    callHanlder(request: Request, response: Response): any;
}

declare class CompiledRoute {
    route: Route;
    request: Request;
    response: Response;
    globalMiddlewares: MiddlewareProvider[];
    constructor(route: Route, request: Request, response: Response, globalMiddlewares?: MiddlewareProvider[]);
    private middlewares;
    getMiddlewares(): Middleware[];
    private prepareMiddlewares;
    run(): Promise<void>;
    prepareOutputJsonFormat<T>(obj: object | Array<any>): T;
    convertToString(obj: any): string;
    processResponseBody(res: Response, controller_rc: any): Promise<void>;
    writeAsync(res: any, chunk: any): Promise<unknown>;
    runMiddlewares(middlewares: Middleware[], req: Request, res: Response): Promise<void>;
}

declare class BaseController {
    static routes: {
        methods: HttpMethod[];
        path: string;
        handler: string;
        middlewares: MiddlewareProvider[];
    }[];
    static basePath: string;
    static baseMiddlewares: MiddlewareProvider[];
    constructor();
    static getInstance(): BaseController;
}
declare function Controller(path: string, options?: ControllerDecoratorOptions): ClassDecorator;
declare function Get(data?: {
    path?: string;
    middlewares?: MiddlewareProvider[];
}): MethodDecorator;
declare function Post(data?: {
    path?: string;
    middlewares?: MiddlewareProvider[];
}): MethodDecorator;
declare function Put(data?: {
    path?: string;
    middlewares?: MiddlewareProvider[];
}): MethodDecorator;
declare function Patch(data?: {
    path?: string;
    middlewares?: MiddlewareProvider[];
}): MethodDecorator;
declare function Delete(data?: {
    path?: string;
    middlewares?: MiddlewareProvider[];
}): MethodDecorator;
declare function Options(data?: {
    path?: string;
    middlewares?: MiddlewareProvider[];
}): MethodDecorator;
declare function createParamDecorator(func: () => Promise<any> | (() => any)): ParameterDecorator;

declare function runNext(middlewares: Middleware[], req: Request, res: Response, final: (request: Request, response: Response) => Promise<void>): Promise<void>;

declare class MiddlewareFactory {
    static create(func: HandlerType): Middleware;
}

declare class Router {
    private middlewares;
    private checks;
    routes: Route[];
    addRoute(methods: HttpMethod[], path: string, handler: HandlerType): Route;
    getMiddlewares(): MiddlewareProvider[];
    addCheck(checks: RouteCheck | RouteCheck[]): this;
    getChecks(): RouteCheck[];
    addController(controller: typeof BaseController): void;
    addRouter(path: string, router: Router): void;
    addGlobalMiddleware(middlewares: MiddlewareProvider | MiddlewareProvider[]): void;
    resolve(request: Request): Route | undefined;
    resolveMultiple(request: Request): Route[];
    getCompiledRoute(request: Request, response: Response): CompiledRoute | undefined;
}

export { BaseController, CompiledRoute, Controller, type ControllerDecoratorOptions, Delete, Get, type HandlerType, type HttpMethod, type LexerToken, Middleware, MiddlewareFactory, type MiddlewareProvider, Options, Patch, Post, Put, type Request, type Response, Route, type RouteCheck, Router, createParamDecorator, runNext };