from typing import List, Optional
from fastapi import APIRouter, Depends
from fastapi.responses import JSONResponse, FileResponse
from pydantic import BaseModel
import os


from src.auth.service import JWTBearer


from src.masterdata.router import router as masterdata_router
from src.masterdata_simulations.router import router as masterdata_simulations_router
from src.plant_masterdata.router import router as plant_masterdata
from src.plant_transaction_data.router import router as plant_transaction_data
from src.plant_transaction_data_simulations.router import router as plant_transaction_data_simulations
from src.plant_fs_transaction_data.router import router as plant_fs_transaction_data_router
from src.equipment.router import router as equipment_router
from src.acquisition_cost.router import router as acquisition_data_router
from src.yeardata.router import router as yeardata_router
from src.equipment_master.router import router as equipment_master_router
from src.uploaded_file.router import router as uploaded_file_router
from src.simulations.router import router as simulations_router


class ErrorMessage(BaseModel):
    msg: str


class ErrorResponse(BaseModel):
    detail: Optional[List[ErrorMessage]]


api_router = APIRouter(
    default_response_class=JSONResponse,
    responses={
        400: {"model": ErrorResponse},
        401: {"model": ErrorResponse},
        403: {"model": ErrorResponse},
        404: {"model": ErrorResponse},
        500: {"model": ErrorResponse},
    },
)


@api_router.get("/healthcheck", include_in_schema=False)
def healthcheck():
    return {"status": "ok"}


authenticated_api_router = APIRouter(
    dependencies=[Depends(JWTBearer())],
)

authenticated_api_router.include_router(
    uploaded_file_router, prefix="/uploaded-files", tags=["uploaded_files"]
)

# Master Data
authenticated_api_router.include_router(
    masterdata_router, prefix="/masterdata", tags=["masterdata"]
)

authenticated_api_router.include_router(
    masterdata_simulations_router,
    prefix="/masterdata-simulations",
    tags=["masterdata_simulations"],
)

authenticated_api_router.include_router(
    simulations_router,
    prefix="/simulations",
    tags=["simulations"],
)

authenticated_api_router.include_router(
    plant_masterdata, prefix="/plant-masterdata", tags=["plant_masterdata"]
)

authenticated_api_router.include_router(
    plant_transaction_data,
    prefix="/plant-transaction-data",
    tags=["plant_transaction_data"],
)

authenticated_api_router.include_router(
    plant_transaction_data_simulations,
    prefix="/plant-transaction-data-simulations",
    tags=["plant_transaction_data_simulations"],
)

authenticated_api_router.include_router(
    plant_fs_transaction_data_router,
    prefix="/plant-fs-transaction-data",
    tags=["plant_fs_transaction_data"],
)

authenticated_api_router.include_router(
    equipment_router, prefix="/equipment", tags=["equipment"]
)

authenticated_api_router.include_router(
    equipment_master_router, prefix="/equipment-master", tags=["equipment_master"]
)

authenticated_api_router.include_router(
    acquisition_data_router, prefix="/acquisition-data", tags=["acquisition_cost"]
)

authenticated_api_router.include_router(
    yeardata_router, prefix="/yeardata", tags=["yeardata"]
)

@api_router.get("/uploads/{file_path:path}", include_in_schema=False)
def uploads(file_path: str):
    """Endpoint to static folder on backend ."""
    uploads_dir = os.path.join(os.path.dirname(__file__), "uploads")
    abs_file_path = os.path.abspath(os.path.join(uploads_dir, file_path))

    # Security check: ensure abs_file_path is inside uploads_dir
    if not abs_file_path.startswith(os.path.abspath(uploads_dir)):
        return JSONResponse(status_code=403, content={"detail": [{"msg": "Forbidden"}]})

    if not os.path.isfile(abs_file_path):
        return JSONResponse(status_code=404, content={"detail": [{"msg": "File not found"}]})

    return FileResponse(abs_file_path)

api_router.include_router(authenticated_api_router)