import typing

from fastapi import status, HTTPException

from api_events.events.events.events_bind_modules import ModulesBindOccupantEventMethods
from databases import (
    BuildParts,
    Build,
    BuildLivingSpace,
    OccupantTypes,
    People,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject

from api_validations.core_response import AlchemyJsonResponse
from api_validations.validations_request import (
    InsertBuildLivingSpace,
    ListOptions,
)
from databases.sql_models.event.event import Modules


class BuildingLivingSpacesPartsListEventMethods(MethodToEvent):

    event_type = "SELECT"
    __event_keys__ = {
        "8fd04d94-68fb-4a07-9549-8b47aee3a870": "building_build_parts_list",
        "2f3041a9-6184-44c2-ac38-8ea934297ed1": "building_build_parts_list_with_expired",
    }

    @classmethod
    def building_build_parts_list(cls, list_options: ListOptions, token_dict):
        build_id_list_query = Build.select_action(
            employee_id=token_dict.selected_company.employee_id
        )
        Build.filter_attr = list_options
        build_part_id_list_query = BuildParts.filter_all(
            BuildParts.build_id.in_([build.id for build in build_id_list_query.all()]),
            BuildParts.active == True,
        ).data

        list_options.query.pop("expiry_starts", None)
        list_options.query.pop("expiry_ends", None)

        records = BuildLivingSpace.filter_all(
            BuildLivingSpace.build_parts_id.in_(
                [build_part.id for build_part in build_part_id_list_query]
            ),
            BuildLivingSpace.active == True,
            *BuildLivingSpace.get_smart_query(smart_query=list_options.query),
        )
        return AlchemyJsonResponse(
            completed=True,
            message="Building Living Spaces are listed successfully",
            result=records,
        )

    @classmethod
    def building_build_parts_list_with_expired(
        cls, list_options: ListOptions, token_dict
    ):
        build_id_list_query = Build.select_action(
            employee_id=token_dict.selected_company.employee_id
        )
        Build.filter_attr = list_options
        build_part_id_list_query = BuildParts.filter_all(
            BuildParts.build_id.in_([build.id for build in build_id_list_query.all()]),
            BuildParts.active == True,
        ).data

        records = BuildLivingSpace.filter_all(
            BuildLivingSpace.build_parts_id.in_(
                [build_part.id for build_part in build_part_id_list_query]
            ),
            *BuildLivingSpace.get_smart_query(smart_query=list_options.query),
        ).data
        return AlchemyJsonResponse(
            completed=True,
            message="Building Living Spaces are listed successfully",
            result=records,
        )


class BuildingLivingSpacesPartsCreateEventMethods(MethodToEvent):

    event_type = "CREATE"
    __event_keys__ = {
        "b78ca45c-b9f4-41f6-9ddb-2c6f2faa2570": "building_live_space_create"
    }

    @classmethod
    def building_live_space_create(
        cls,
        data: InsertBuildLivingSpace,
        token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
    ):
        from api_library.date_time_actions.date_functions import system_arrow
        from sqlalchemy.sql import select

        data_dict = data.dump()
        build_id_list_query = Build.select_action(
            employee_id=token_dict.selected_company.employee_id
        )
        build_part = BuildParts.filter_one(
            BuildParts.uu_id == data.build_parts_uu_id,
            BuildParts.build_id.in_([build.id for build in build_id_list_query.all()]),
        ).data
        if not build_part:
            raise HTTPException(
                status_code=status.HTTP_418_IM_A_TEAPOT,
                detail=f"{data.build_parts_uu_id} - Build Part is not found in database. Check build part uu_id",
            )

        life_person = People.filter_one(People.uu_id==data.person_uu_id or "").data
        if not life_person:
            raise HTTPException(
                status_code=status.HTTP_418_IM_A_TEAPOT,
                detail=f"{data.life_person_uu_id} - Living Person is not found in database. "
                f"Check build live person uu_id",
            )

        occupant_type = OccupantTypes.filter_by_one(uu_id=data.occupant_type_uu_id).data
        if not occupant_type:
            raise HTTPException(
                status_code=status.HTTP_418_IM_A_TEAPOT,
                detail=f"{data.occupant_type_uu_id} - Occupant Type is not found in database. "
                f"Check occupant type uu_id",
            )

        data_dict["occupant_type"] = occupant_type.id
        data_dict["occupant_type_uu_id"] = str(occupant_type.uu_id)
        data_dict["build_parts_id"] = build_part.id
        data_dict["build_parts_uu_id"] = str(build_part.uu_id)
        data_dict["person_id"] = life_person.id
        data_dict["person_uu_id"] = str(life_person.uu_id)

        living_space_id = BuildLivingSpace.select_only(
            BuildLivingSpace.build_parts_id == build_part.id,
            BuildLivingSpace.person_id == life_person.id,
            BuildLivingSpace.occupant_type == occupant_type.id,
            BuildLivingSpace.active == True,
            BuildLivingSpace.is_confirmed == True,
            str(system_arrow.now()) < BuildLivingSpace.expiry_ends,
            str(system_arrow.now()) >= BuildLivingSpace.expiry_starts,
            select_args=[BuildLivingSpace.id],
            order_by=BuildLivingSpace.expiry_starts.desc(),
            limit=1
        ).data

        last_living_space = BuildLivingSpace.filter_one(
            BuildLivingSpace.id == living_space_id[0] if living_space_id else None
        )

        data_dict["expiry_starts"] = str(system_arrow.now())
        created_living_space = BuildLivingSpace.create_action(
            data=data_dict, token_dict=token_dict
        )

        if last_living_space:
            if last_living_space.expiry_ends > str(system_arrow.now()):
                last_living_space.expiry_ends = str(system_arrow.shift(minutes=-10))
                last_living_space.save()

        user_module = Modules.filter_one(Modules.module_code == "USR-PUB", system=True).data
        ModulesBindOccupantEventMethods.modules_bind_occupant_system(
            build_living_space_id=created_living_space.id,
            modules_id=user_module.id,
        )
        created_living_space.save()
        return created_living_space


class BuildingLivingSpacesPartsUpdateEventMethods(MethodToEvent):

    event_type = "UPDATE"
    __event_keys__ = {
        "70b4666f-4ceb-46ec-b89e-24be8712f0e7": "building_live_space_update",
    }

    @classmethod
    def building_live_space_update(cls, build_uu_id: str, data, token_dict):
        from api_library.date_time_actions.date_functions import system_arrow
        from sqlalchemy.sql import select

        data_dict = data.dump()
        build_id_list_query = Build.select_action(
            employee_id=token_dict.selected_company.employee_id
        )
        build_part = BuildParts.filter_one(
            BuildParts.uu_id == data.build_parts_uu_id,
            BuildParts.build_id.in_([build.id for build in build_id_list_query.all()]),
            BuildParts.active == True,
        ).data
        if not build_part:
            raise HTTPException(
                status_code=status.HTTP_418_IM_A_TEAPOT,
                detail=f"{data.build_parts_uu_id} - Build Part is not found in database. Check build part uu_id",
            )

        life_person = People.filter_one(People.uu_id==data.life_person_uu_id or "").data
        if not life_person:
            raise HTTPException(
                status_code=status.HTTP_418_IM_A_TEAPOT,
                detail=f"{data.life_person_uu_id} - Living Person is not found in database. "
                f"Check build live person uu_id",
            )

        living_space_id = BuildLivingSpace.select_only(
            select_args=[BuildLivingSpace.id],
            order_by=BuildLivingSpace.expiry_starts.desc(),
            limit=1
        ).get(1)

        last_living_space = BuildLivingSpace.filter_one(
            BuildLivingSpace.id == living_space_id if living_space_id else None
        ).data

        data_dict["expiry_starts"] = str(system_arrow.now())
        data_dict["is_tenant_live"] = bool(data.is_tenant_live)
        data_dict["build_parts_id"] = build_part.id
        if data_dict["is_tenant_live"]:
            owner_person = getattr(last_living_space, "owner_person_id", None)
            if not owner_person:
                raise HTTPException(
                    status_code=status.HTTP_418_IM_A_TEAPOT,
                    detail=dict(
                        message="Owner person of build part is not defined. Please register owner of part first.",
                        data=build_part.get_dict(),
                    ),
                )
            data_dict["life_person_id"] = life_person.id
            data_dict["owner_person_id"] = owner_person
        else:
            data_dict["life_person_id"] = life_person.id
            data_dict["owner_person_id"] = life_person.id
        del data_dict["build_parts_uu_id"], data_dict["life_person_uu_id"]


BuildingLivingSpacesPartsListEventMethod = BuildingLivingSpacesPartsListEventMethods(
    action=ActionsSchema(endpoint="/building/living_space/list")
)
BuildingLivingSpacesPartsCreateEventMethod = (
    BuildingLivingSpacesPartsCreateEventMethods(
        action=ActionsSchema(endpoint="/building/living_space/create")
    )
)
BuildingLivingSpacesPartsUpdateEventMethod = (
    BuildingLivingSpacesPartsUpdateEventMethods(
        action=ActionsSchema(endpoint="/building/living_space/update")
    )
)