from __future__ import annotations

from starlette.applications import Starlette
from starlette.requests import Request 
from starlette.routing import Route
from starlette.middleware import Middleware

from typing import (
    Callable,
    Any,
    Awaitable,
    Sequence,
)


# I got my inspiration from Flask and Fastapi for this approch.

class SearxAPI(Starlette):
    
    # Starlette plans to remove route functionality 
    # in a future update. However, the code I made retains that approch.
 
    def _route(
        self,
        path: str,
        methods: list[str] | None = None,
        name: str | None = None,
        include_in_schema: bool = True,
        middleware: Sequence[Middleware] | None = None,
    ):
        
        def wrapper(func: Callable[[Request], Awaitable[Any]]):
            self.routes.append(
                Route(
                    path,
                    endpoint=func,
                    methods=methods,
                    name=name,
                    include_in_schema=include_in_schema,
                    middleware=middleware,
                )
            )
            # Return the original function if we decide to use the function elsewhere...
            return func

        return wrapper

    def get(
        self,
        path: str,
        name: str | None = None,
        include_in_schema: bool = True,
        middleware: Sequence[Middleware] | None = None,
    ):
        """Creates a get request enpoint via function wrapper"""
        return self._route(path, ["GET"], name, include_in_schema, middleware)

    def post(
        self,
        path: str,
        name: str | None = None,
        include_in_schema: bool = True,
        middleware: Sequence[Middleware] | None = None,
    ):
        """Creates a post request enpoint via function wrapper"""
        return self._route(path, ["POST"], name, include_in_schema, middleware)