from fastapi import FastAPI, Request, Response
# from app.permit.permit import FactorySelector
from app.routes.v1.elastic import router as elastic_router
from app.routes.v1.elastic_map import router as elastic_map_router
from app.routes.v1.elastic_admin import router as elastic_admin_router
from app.routes.rag.rag_chat import router as rag_chat
from app.routes.voice.voice import router as voice_routers
from app.routes.tree.tree_base import router as tree_base_routers
from app.config.settings import get_settings, Settings
from app.core.elastic_client_helper import ElasticClientHelper, create_async_elastic_client
from starlette.middleware.base import BaseHTTPMiddleware
from app.core.response_helper import ResponseHelper
from app.lib.general_functions import extract_jwt_user_id



def create_app() -> FastAPI:
    app = FastAPI(title="Flexible Elasticsearch Backend", version="0.1.0")
    app.state.settings = get_settings()

    @app.on_event("startup")
    async def on_startup() -> None:
        # settings:Settings = app.state.settings

        # create_async_redis_client(settings)        
        app.state.elastic_client = await create_async_elastic_client(app.state.settings)
        app.state.elastic_helper = ElasticClientHelper(app.state.elastic_client)
            
        # permit = getattr(app.state, "permit_client", None)
        # if permit is None:
        #     app.state.permit_client = await FactorySelector.get_factory("db",
        #                                                           type=settings.permit_db_type,
        #                                                           host=settings.permit_database_host,
        #                                                           port=settings.permit_database_port,
        #                                                           username=settings.permit_database_user,
        #                                                           db_name=settings.permit_database_name,
        #                                                           )
        
            
    @app.on_event("shutdown")
    async def on_shutdown() -> None:
        client = getattr(app.state, "elastic_client", None)
        if client is not None:
            await client.close()


    @app.get("/")
    async def Ping():
        return "Elasticsearch Backend Service"
    
    @app.get("/ping")
    async def Ping():
        return "Elasticsearch Backend ping"

    app.include_router(elastic_router, prefix="/v1")
    app.include_router(rag_chat, prefix="/rag")
    app.include_router(voice_routers, prefix="/voice")
    app.include_router(tree_base_routers, prefix="/tree")
    
    #---------------------------------------------
    #  برای نسخه نهایی نیاز است با دسترسی فعال شود
    if app.state.settings.is_mode_develop :
        app.include_router(elastic_map_router, prefix="/v1/map")
        app.include_router(elastic_admin_router, prefix="/v1/admin")
    
    return app


app = create_app()


class TavasiMiddleware(BaseHTTPMiddleware):
    # routes_to_reroute = ["/indices/entity/insert/{entity_type}/{data_type}/{ref_key}"]
    routes_to_reroute = ["/indices/entity/insert"]
    
        
    async def test_rewrite(self, request: Request, call_next):
        if request.url.path in self.routes_to_reroute:
            request.scope['path'] = '/welcome'
            headers = dict(request.scope['headers'])
            headers[b'custom-header'] = b'my custom header'
            request.scope['headers'] = [(k, v) for k, v in headers.items()]        
        return await request   
        # return await call_next(request)    
    
    async def rewriteUrls(self, request):
        request.state.app = app
        user_id = extract_jwt_user_id(request, app.state.settings.jwtKey, "HS256" )
        if user_id:
            # ذخیره موقت در settings یا context
            app.state.settings.current_user_id = user_id 
            
        return request
    
    async def responseNormal(self, response):
        responseHelper = ResponseHelper()
        return await responseHelper.general(response)
    
    async def dispatch(self, request: Request, call_next):
        # قبل از پردازش درخواست        
        # print("قبل از پردازش درخواست:", request.url)
        await self.rewriteUrls(request)

        # پردازش درخواست
        response = await call_next(request)

        # بعد از پردازش درخواست
        response = await self.responseNormal(response)
        # print("بعد از پردازش درخواست:", response.status_code)

        return response

# @app.middleware("http")
# async def check_permit(request: Request, call_next):
#     # client = app.state.permit_client
#     # print(await client.ping())
#     # result = await client.check_perm(
#     # user_id=2, action_tag='item_new'
#     # )
#     if app.state.settings.enable_back_permition:
#         return Response(content={"detail":"The server is temporarily limited."},status_code=503)
#     else:
#         response = await call_next(request)
#         return response

app.add_middleware(TavasiMiddleware)