import traceback

from fastapi import status
from fastapi.responses import JSONResponse
from openai import (
    AuthenticationError,
    BadRequestError,
    ConflictError,
    InternalServerError,
    NotFoundError,
    PermissionDeniedError,
    RateLimitError,
    UnprocessableEntityError,
)
from sqlalchemy.exc import DatabaseError, SQLAlchemyError

from .exceptions import *


def graph_node_exception_handler(request, exc):
    if isinstance(
        exc.__cause__,
        (
            BadRequestError,
            AuthenticationError,
            PermissionDeniedError,
            NotFoundError,
            ConflictError,
            UnprocessableEntityError,
            RateLimitError,
            InternalServerError,
        ),
    ):
        return JSONResponse(
            status_code=status.HTTP_400_BAD_REQUEST,
            content={
                "node_id": exc.node_id,
                "code": "openai_invalid_request_error",
                "message": str(exc.__cause__),
            },
        )
    elif isinstance(exc.__cause__, EmbeddingError):
        return JSONResponse(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            content={
                "node_id": exc.node_id,
                "code": "embedding_error",
                "message": str(exc.__cause__),
            },
        )
    elif isinstance(exc.__cause__, EmbeddingServiceError):
        return JSONResponse(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            content={
                "node_id": exc.node_id,
                "code": "call_embedding_service_error",
                "message": str(exc.__cause__),
            },
        )
    elif isinstance(exc.__cause__, InvokeError):
        return JSONResponse(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            content={
                "node_id": exc.node_id,
                "code": "invoke_error",
                "message": str(exc.__cause__),
                "error": {
                    "application_id": exc.__cause__.application_id,
                    "code": exc.__cause__.code,
                    "message": exc.__cause__.message,
                    "node_id": exc.__cause__.node_id,
                },
            },
        )
    elif isinstance(exc.__cause__, TimeoutError):
        return JSONResponse(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            content={
                "node_id": exc.node_id,
                "code": "timeout",
                "message": str(exc.__cause__),
            },
        )
    elif issubclass(type(exc.__cause__), DatabaseError):
        return JSONResponse(
            status_code=status.HTTP_400_BAD_REQUEST,
            content={
                "node_id": exc.node_id,
                "code": "db_query_error",
                "message": str(exc.__cause__),
            },
        )
    elif isinstance(type(exc.__cause__), ParameterMissing):
        return JSONResponse(
            status_code=status.HTTP_400_BAD_REQUEST,
            content={
                "node_id": exc.node_id,
                "code": "parameter missing",
                "message": str(exc.__cause__),
            },
        )
    else:
        print(traceback.format_exc())
        return JSONResponse(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            content={
                "node_id": exc.node_id,
                "code": "unknown",
                "message": f"except {type(exc.__cause__)}",
            },
        )


def graph_check_exception_handler(request, exc):
    return JSONResponse(
        status_code=status.HTTP_400_BAD_REQUEST,
        content={
            "code": "bad_graph",
            "message": str(exc),
        },
    )


def database_exception_handler(request, exc):
    return JSONResponse(
        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
        content={
            "code": "database_error",
            "message": str(exc),
        },
    )


def node_construct_exception_handler(request, exc):
    return JSONResponse(
        status_code=status.HTTP_400_BAD_REQUEST,
        content={
            "code": "node_construct_error",
            "message": str(exc),
        },
    )


def logger_not_available_handler(request, exc):
    return JSONResponse(
        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
        content={
            "code": "logger_not_available",
            "message": str(exc),
        },
    )


def application_not_found_handler(request, exc):
    return JSONResponse(
        status_code=status.HTTP_404_NOT_FOUND,
        content={
            "code": "app_not_found",
            "message": str(exc),
        },
    )


def interaction_not_found_handler(request, exc):
    return JSONResponse(
        status_code=status.HTTP_404_NOT_FOUND,
        content={
            "code": "interaction_not_found",
            "message": str(exc),
        },
    )


def application_input_mismatch_handler(request, exc):
    return JSONResponse(
        status_code=status.HTTP_400_BAD_REQUEST,
        content={
            "code": "app_input_type_mismatch",
            "message": str(exc),
        },
    )


def invalid_parameters_handler(request, exc):
    return JSONResponse(
        status_code=status.HTTP_400_BAD_REQUEST,
        content={
            "code": "invalid_parameters",
            "message": str(exc),
        },
    )


def type_name_resolve_exception_handler(request, exc):
    return JSONResponse(
        status_code=status.HTTP_400_BAD_REQUEST,
        content={
            "code": "type_name_resolve_error",
            "message": str(exc),
        },
    )


def not_implemented_exception_handler(request, exc):
    return JSONResponse(
        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
        content={
            "code": "not_implemented",
            "message": str(exc),
        },
    )


def plugin_not_found_exception_handler(request, exc):
    return JSONResponse(
        status_code=status.HTTP_404_NOT_FOUND,
        content={
            "code": "plugin_not_found",
            "message": str(exc),
        },
    )


def timeout_exception_handler(request, exc):
    return JSONResponse(
        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
        content={
            "code": "timeout",
            "message": str(exc),
        },
    )


def exception_handler(request, exc):
    return JSONResponse(
        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
        content={
            "code": "unknown",
            "message": str(exc),
        },
    )


def register_exception_handlers(app):
    app.exception_handler(NodeException)(graph_node_exception_handler)
    app.exception_handler(GraphCheckError)(graph_check_exception_handler)
    app.exception_handler(SQLAlchemyError)(database_exception_handler)
    app.exception_handler(NodeConstructError)(node_construct_exception_handler)
    app.exception_handler(LoggerNotAvailable)(logger_not_available_handler)
    app.exception_handler(ApplicationNotFound)(application_not_found_handler)
    app.exception_handler(InteractionNotFound)(interaction_not_found_handler)
    app.exception_handler(ApplicationInputTypeMismatch)(
        application_input_mismatch_handler
    )
    app.exception_handler(InvalidParameters)(invalid_parameters_handler)
    app.exception_handler(TypeNameResolveError)(type_name_resolve_exception_handler)
    app.exception_handler(NotImplementedError)(not_implemented_exception_handler)
    app.exception_handler(PluginNotFoundError)(plugin_not_found_exception_handler)
    app.exception_handler(Exception)(exception_handler)