import typing

from fastapi import status, HTTPException
from fastapi.responses import JSONResponse

from databases import (
    Build,
    BuildDecisionBook,
    Companies,
    OccupantTypes,
)

from validations import (
    InsertDecisionBook,
    ListOptions,
)

from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import return_json_response_from_alchemy
from api_library.date_time_actions.date_functions import DateTimeLocal


class DecisionBookListEventMethods(MethodToEvent):

    event_type = "SELECT"
    __event_keys__ = {
        "5c10d6ae-2aee-4243-a7c3-94826d028d13": "building_decision_book_list",
    }

    @classmethod
    def building_decision_book_list(
        cls,
        list_options: ListOptions,
        token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
    ):
        records = []
        if isinstance(token_dict, EmployeeTokenObject):

            build_id_list_query = Build.select_action(
                employee_id=token_dict.selected_company.employee_id
            )
            build_id_list = build_id_list_query.all()
            if not build_id_list:
                raise HTTPException(
                    status_code=status.HTTP_404_NOT_FOUND,
                    detail=f"No building is match with given Employee UUID {token_dict.selected_company.employee_uu_id}",
                )
            records = BuildDecisionBook.filter_active(
                BuildDecisionBook.build_id.in_([build.id for build in build_id_list]),
                *BuildDecisionBook.get_smart_query(list_options.query),
            )
        elif isinstance(token_dict, OccupantTokenObject):
            records = BuildDecisionBook.filter_active(
                BuildDecisionBook.build_id == token_dict.selected_occupant.build_id,
                *BuildDecisionBook.get_smart_query(list_options.query),
            )
        return return_json_response_from_alchemy(
            response=records, pagination=list_options
        )


class DecisionBookCreateEventMethods(MethodToEvent):

    event_type = "CREATE"
    __event_keys__ = {
        "0a68cb44-271a-4829-81f6-cd99a5f326b4": "building_decision_book_create",
    }

    @classmethod
    def building_decision_book_create(
        cls,
        data: InsertDecisionBook,
        token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
    ):
        data_dict = data.excluded_dump()
        if isinstance(token_dict, EmployeeTokenObject):
            Build.pre_query = Build.select_action(
                employee_id=token_dict.selected_company.employee_id
            )
            build = Build.filter_active(
                Build.uu_id == data.build_uu_id,
            )
            if not build.data:
                raise HTTPException(
                    status_code=status.HTTP_404_NOT_FOUND,
                    detail=f"Emloyee UUID {token_dict.selected_company.employee_uu_id} has no build with given UUID {data_dict.get('build_uu_id')}",
                )
            data_dict["build_id"] = build.data[0].id
            if data.resp_company_uu_id:
                Companies.pre_query = Companies.select_action(
                    duty_id_list=[
                        token_dict.selected_company.duty_id,
                        token_dict.selected_company.bulk_duties_id,
                    ]
                )
                company = Companies.filter_active(
                    Companies.uu_id == data.resp_company_uu_id
                )
                if not company.data:
                    raise HTTPException(
                        status_code=status.HTTP_404_NOT_FOUND,
                        detail=f"Duty UUID {token_dict.selected_company.duty_uu_id} has no company with given UUID {data_dict.get('resp_company_uu_id')}",
                    )
                data_dict["resp_company_id"] = company.data[0].id
                data_dict["resp_company_uu_id"] = str(company.data[0].uu_id)

            build_object = build.data[0]
            decision_period_date = DateTimeLocal.get(build_object.decision_period_date)
            data_dict["expiry_starts"] = DateTimeLocal.get(
                DateTimeLocal.now().date().year,
                int(decision_period_date.date().month),
                int(decision_period_date.date().day),
            )
            data_dict["expiry_ends"] = str(
                data_dict["expiry_starts"].shift(years=1, days=-1)
            )
            data_dict["expiry_starts"] = str(data_dict["expiry_starts"])
            build_decision_book = BuildDecisionBook.find_or_create(**data_dict)
            return JSONResponse(
                status_code=status.HTTP_200_OK,
                content=dict(
                    message="Decision Book has created",
                    completed=True,
                    data=build_decision_book.get_dict(),
                ),
            )
        elif isinstance(token_dict, OccupantTokenObject):
            occupant_manager = OccupantTypes.find_one(
                occupant_category_type="BU", occupant_code="BU-MNG"
            )
            if not token_dict.selected_occupant.occupant_type_id == occupant_manager.id:
                raise HTTPException(
                    status_code=status.HTTP_403_FORBIDDEN,
                    detail="Only Build Manager can create decision book",
                )

            occupant_build = Build.find_one(id=token_dict.selected_occupant.build_id)
            occupant_company = Companies.find_one(
                id=token_dict.selected_occupant.responsible_company_id
            )
            data_dict["build_id"] = occupant_build.id
            data_dict["build_uu_id"] = str(occupant_build.uu_id)
            data_dict["resp_company_id"] = occupant_company.id
            data_dict["resp_company_uu_id"] = str(occupant_company.uu_id)

            decision_period_date = DateTimeLocal.get(
                occupant_build.decision_period_date
            )
            data_dict["expiry_starts"] = DateTimeLocal.get(
                DateTimeLocal.now().date().year,
                int(decision_period_date.date().month),
                int(decision_period_date.date().day),
            )
            data_dict["expiry_ends"] = str(
                data_dict["expiry_starts"].shift(years=1, days=-1)
            )
            data_dict["expiry_starts"] = str(data_dict["expiry_starts"])
            build_decision_book = BuildDecisionBook.find_or_create(**data_dict)
            return JSONResponse(
                status_code=status.HTTP_200_OK,
                content=dict(
                    message="Decision Book has created",
                    completed=True,
                    data=build_decision_book.get_dict(),
                ),
            )


class DecisionBookUpdateEventMethods(MethodToEvent):

    event_type = "UPDATE"
    __event_keys__ = {
        "6bc7035c-3b53-4c0a-8cc9-1ec9c6af1e29": "building_decision_book_update",
    }

    @classmethod
    def building_decision_book_update(cls, data: InsertDecisionBook, token_dict: dict):
        return


class DecisionBookPatchEventMethods(MethodToEvent):

    event_type = "PATCH"
    __event_keys__ = {
        "7b58ed84-9a65-4588-994d-30df8366b050": "building_decision_book_patch",
    }

    @classmethod
    def building_decision_book_patch(cls, data: InsertDecisionBook, token_dict: dict):
        return


class DecisionBookApprovalEventMethods(MethodToEvent):

    event_type = "UPDATE"
    __event_keys__ = {
        "fc745142-3437-4ca2-89fa-c5a3e2b5c6c2": "building_decision_book_approval",
    }

    @classmethod
    def building_decision_book_approval(cls, data, token_dict):
        return


DecisionBookListEventMethod = DecisionBookListEventMethods(
    action=ActionsSchema(endpoint="/build/decision_book/list")
)
DecisionBookCreateEventMethod = DecisionBookCreateEventMethods(
    action=ActionsSchema(endpoint="/build/decision_book/create")
)
DecisionBookUpdateEventMethod = DecisionBookUpdateEventMethods(
    action=ActionsSchema(endpoint="/build/decision_book/update")
)
DecisionBookPatchEventMethod = DecisionBookPatchEventMethods(
    action=ActionsSchema(endpoint="/build/decision_book/patch")
)
DecisionBookApprovalEventMethod = DecisionBookApprovalEventMethods(
    action=ActionsSchema(endpoint="/build/decision_book/approval")
)