from typing import Any

from ApiControllers.abstracts.event_clusters import Event
from Controllers.Postgres.pagination import Pagination, PaginationResult, PaginateOnly
from Controllers.Postgres.response import EndpointResponse
from Schemas import (
    Applications,
    Application2Employee,
    Application2Occupant,
    Service2Application,
    Services,
)

# List all endpoint
ApplicationListAllEvent = Event(
    name="application_list_all",
    key="1971ce4d-4f59-4aa8-83e2-ca19d7da6d11",
    request_validator=None,  # TODO: Add request validator
    response_validator=None,  # TODO: Add response validator
    description="Super Users List all applications endpoint",
)

# List available endpoint
ApplicationListAvailableEvent = Event(
    name="application_list_available",
    key="d8e733f5-b53a-4c36-9082-12579bf9cc4a",
    request_validator=None,  # TODO: Add request validator
    response_validator=None,  # TODO: Add response validator
    description="Super Users List available applications endpoint",
)

# List appended endpoint
ApplicationListAppendedEvent = Event(
    name="application_list_appended",
    key="ea7bbd58-da09-407c-a630-c324e0272385",
    request_validator=None,  # TODO: Add request validator
    response_validator=None,  # TODO: Add response validator
    description="Super Users List appended applications endpoint",
)

# Register application to service endpoint
ApplicationRegisterServiceEvent = Event(
    name="application_register_service",
    key="47d7cfc8-6004-4442-8357-16ceac5d9d18",
    request_validator=None,  # TODO: Add request validator
    response_validator=None,  # TODO: Add response validator
    description="Super Users Register application to service endpoint",
)

# Unregister application to service endpoint
ApplicationUnRegisterServiceEvent = Event(
    name="application_unregister_service",
    key="d228ab26-0b74-440f-8f1f-8f40be5a22f2",
    request_validator=None,  # TODO: Add request validator
    response_validator=None,  # TODO: Add response validator
    description="Super Users Unregister application to service endpoint",
)

# Create endpoint
ApplicationCreateEvent = Event(
    name="application_create",
    key="f53ca9aa-5536-4d77-9129-78d67e61db4a",
    request_validator=None,  # TODO: Add request validator
    response_validator=None,  # TODO: Add response validator
    description="Super Users Create applications endpoint",
)

# Update endpoint
ApplicationUpdateEvent = Event(
    name="application_update",
    key="0e9a855e-4e69-44b5-8ac2-825daa32840c",
    request_validator=None,  # TODO: Add request validator
    response_validator=None,  # TODO: Add response validator
    description="Super Users Update applications endpoint",
)


def application_list_all_callable(list_options: PaginateOnly):
    list_options = PaginateOnly(**list_options.model_dump())
    with Applications.new_session() as db_session:
        if list_options.query:
            applications_list = Applications.filter_all(*Applications.convert(list_options.query), db=db_session)
        else:
            applications_list = Applications.filter_all(db=db_session)
        pagination = Pagination(data=applications_list)
        pagination.change(**list_options.model_dump())
        pagination_result = PaginationResult(data=applications_list, pagination=pagination)
        return EndpointResponse(message="MSG0003-LIST", pagination_result=pagination_result).response


ApplicationListAllEvent.event_callable = application_list_all_callable


def application_list_available_callable(list_options: PaginateOnly):
    """
    Example callable method
    """
    list_options = PaginateOnly(**list_options.model_dump())
    service_uu_id = list_options.query.get("service_uu_id__ilike", None)
    if not service_uu_id:
        return {
            "message": "MSG0003-PARAM-MISSING",
            "data": list_options.query,
            "completed": False,
        }
    list_options.query.pop("service_uu_id__ilike", None)
    list_options.query.pop("service_uu_id", None)
    with Applications.new_session() as db_session:
        service2applications = Service2Application.filter_all(
            *Service2Application.convert({"service_uu_id__ilike": service_uu_id}),
            db=db_session,
        )
        already_events = [
            service_to_application.application_id for service_to_application in service2applications.data
        ]
        if list_options.query:
            applications_list = Applications.filter_all(
                *Applications.convert(list_options.query), Applications.id.not_in(already_events), db=db_session
            )
        else:
            applications_list = Applications.filter_all(Applications.id.not_in(already_events), db=db_session)
        pagination = Pagination(data=applications_list)
        pagination.change(**list_options.model_dump())
        pagination_result = PaginationResult(data=applications_list, pagination=pagination)
        return EndpointResponse(message="MSG0003-LIST", pagination_result=pagination_result).response


ApplicationListAvailableEvent.event_callable = application_list_available_callable


def application_list_appended_callable(list_options: PaginateOnly):
    """
    Example callable method
    """
    list_options = PaginateOnly(**list_options.model_dump())
    service_uu_id = list_options.query.get("service_uu_id__ilike", None)
    if not service_uu_id:
        return {
            "message": "MSG0003-PARAM-MISSING",
            "data": list_options.query,
            "completed": False,
        }
    list_options.query.pop("service_uu_id__ilike", None)
    list_options.query.pop("service_uu_id", None)

    with Applications.new_session() as db_session:
        service2applications = Service2Application.filter_all(
            *Service2Application.convert({"service_uu_id__ilike": service_uu_id}),
            db=db_session,
        )
        already_events = [
            service_to_application.application_id for service_to_application in service2applications.data
        ]
        if list_options.query:
            applications_list = Applications.filter_all(
                *Applications.convert(list_options.query), Applications.id.in_(already_events), db=db_session
            )
        else:
            applications_list = Applications.filter_all(Applications.id.in_(already_events), db=db_session)
        pagination = Pagination(data=applications_list)
        pagination.change(**list_options.model_dump())
        pagination_result = PaginationResult(data=applications_list, pagination=pagination)
        return EndpointResponse(message="MSG0003-LIST", pagination_result=pagination_result).response


ApplicationListAppendedEvent.event_callable = application_list_appended_callable


def application_create_callable(data: Any):
    """
    Create a new application
    """
    with Applications.new_session() as db_session:
        created_application_dict = data.model_dump()
        created_application = Applications.find_or_create(
            db=db_session,
            include_args=[Applications.application_for, Applications.application_code, Applications.site_url],
            **created_application_dict,
        )
        if created_application.meta_data.created:
            created_application.save(db=db_session)
            return {
                "completed": True,
                "message": "MSG0001-INSERT",
                "data": created_application,
            }
        return {
            "completed": False,
            "message": "MSG0002-ERROR",
            "data": created_application,
        }


ApplicationCreateEvent.event_callable = application_create_callable


def application_update_callable(data: Any, uu_id: str):
    """
    Update an existing application
    """
    with Applications.new_session() as db_session:
        updated_application_dict = data.model_dump(
            exclude_unset=True, exclude_none=True
        )
        found_application = Applications.filter_one(
            Applications.uu_id == uu_id, db=db_session
        ).data
        if not found_application:
            return {
                "completed": False,
                "message": "MSG0002-FOUND",
                "data": found_application,
            }
        updated_application = found_application.update(
            db=db_session, **updated_application_dict
        )
        updated_application.save(db_session)
        if updated_application.meta_data.updated:
            return {
                "completed": True,
                "message": "MSG0003-UPDATE",
                "data": updated_application,
            }
        return {
            "completed": False,
            "message": "MSG0003-UPDATE",
            "data": updated_application,
        }


ApplicationUpdateEvent.event_callable = application_update_callable


def application_register_service_callable(data: Any):
    """
    Register an application to a service
    """
    with Applications.new_session() as db_session:
        event = Applications.filter_one_system(Applications.uu_id == data.application_uu_id, db=db_session)
        if not event.data:
            return {
                "message": "MSG0003-NOT-FOUND",
                "data": data.model_dump(),
                "completed": False,
            }
        service = Services.filter_one_system(Services.uu_id == data.service_uu_id, db=db_session)
        if not service.data:
            return {
                "message": "MSG0003-NOT-FOUND",
                "data": data.model_dump(),
                "completed": False,
            }
        service_to_application = Service2Application.find_or_create(
            db=db_session,
            include_args=[Service2Application.service_uu_id, Service2Application.application_uu_id],
            service_id=service.data.id,
            service_uu_id=str(service.data.uu_id),
            application_id=event.data.id,
            application_uu_id=str(event.data.uu_id),
            application_code=event.data.application_code,
            site_url=event.data.site_url,
            is_confirmed=True,
        )
        if not service_to_application.meta_data.created:
            return {
                "message": "MSG0003-ALREADY-FOUND",
                "data": data.model_dump(),
                "completed": False,
            }
        service_to_application.save(db=db_session)
    return {
        "message": "MSG0003-REGISTER",
        "data": data.model_dump(),
        "completed": True,
    }


ApplicationRegisterServiceEvent.event_callable = application_register_service_callable


def application_unregister_service_callable(data: Any):
    """
    Unregister an application from a service
    """
    with Applications.new_session() as db_session:
        application = Applications.filter_one_system(Applications.uu_id == data.application_uu_id, db=db_session)
        if not application.data:
            return {
                "message": "MSG0003-NOT-FOUND",
                "data": data.model_dump(),
                "completed": False,
            }
        service = Services.filter_one_system(Services.uu_id == data.service_uu_id, db=db_session)
        if not service.data:
            return {
                "message": "MSG0003-NOT-FOUND",
                "data": data.model_dump(),
                "completed": False,
            }
        service_to_application = Service2Application.filter_one_system(
            Service2Application.service_id == service.data.id,
            Service2Application.application_id == application.data.id,
            db=db_session,
        )
        if not service_to_application.data:
            return {
                "message": "MSG0003-NOT-FOUND",
                "data": data.model_dump(),
                "completed": False,
            }
        service_to_application.query.delete()
        db_session.commit()
    return {
        "message": "MSG0003-UNREGISTER",
        "data": data.model_dump(),
        "completed": True,
    }


ApplicationUnRegisterServiceEvent.event_callable = application_unregister_service_callable