from sqlalchemy import (
    String,
    ForeignKey,
    Index,
    Numeric,
    Boolean,
    BigInteger,
    Integer,
    Text, or_,
)
from sqlalchemy.orm import mapped_column, Mapped
from Controllers.Postgres.mixin import CrudCollection


class RelationshipEmployee2PostCode(CrudCollection):
    """
    Build2EmployeeRelationship class based on declarative_base and BaseMixin via session
    """

    __tablename__ = "relationship_employee2postcode"
    __exclude__fields__ = []
    __include__fields__ = []

    company_id: Mapped[int] = mapped_column(
        ForeignKey("companies.id"), nullable=True
    )  # 1, 2, 3
    employee_id: Mapped[int] = mapped_column(ForeignKey("employees.id"), nullable=False)
    member_id: Mapped[int] = mapped_column(
        ForeignKey("address_postcode.id"), nullable=False
    )

    relationship_type: Mapped[str] = mapped_column(
        String, nullable=True, server_default="Employee"
    )  # Commercial
    show_only: Mapped[bool] = mapped_column(Boolean, server_default="0")

    __table_args__ = ({"comment": "Build2Employee Relationship Information"},)


class AddressPostcode(CrudCollection):
    """
    Postcode class based on declarative_base and BaseMixin via session
    """

    __tablename__ = "address_postcode"
    __exclude__fields__ = []
    __access_by__ = []
    __many__table__ = RelationshipEmployee2PostCode

    street_id: Mapped[int] = mapped_column(ForeignKey("address_street.id"))
    street_uu_id: Mapped[str] = mapped_column(
        String, server_default="", comment="Street UUID"
    )
    postcode: Mapped[str] = mapped_column(
        String(32), nullable=False, comment="Postcode"
    )

    __table_args__ = ({"comment": "Postcode Information"},)


class Addresses(CrudCollection):
    """
    Address class based on declarative_base and BaseMixin via session
    """

    __tablename__ = "addresses"
    __exclude__fields__ = []

    build_number: Mapped[str] = mapped_column(
        String(24), nullable=False, comment="Build Number"
    )
    door_number: Mapped[str] = mapped_column(
        String(24), nullable=True, comment="Door Number"
    )
    floor_number: Mapped[str] = mapped_column(
        String(24), nullable=True, comment="Floor Number"
    )

    comment_address: Mapped[str] = mapped_column(
        String, nullable=False, comment="Address"
    )
    letter_address: Mapped[str] = mapped_column(
        String, nullable=False, comment="Address"
    )
    short_letter_address: Mapped[str] = mapped_column(
        String, nullable=False, comment="Address"
    )

    latitude: Mapped[float] = mapped_column(Numeric(20, 12), server_default="0")
    longitude: Mapped[float] = mapped_column(Numeric(20, 12), server_default="0")

    street_id: Mapped[int] = mapped_column(
        ForeignKey("address_street.id"), nullable=False
    )
    street_uu_id: Mapped[str] = mapped_column(
        String, server_default="", comment="Street UUID"
    )

    __table_args__ = (
        # Index("_address_ndx_00", country_code, b_state, city, district),
        {"comment": "Address Information"},
    )

    @classmethod
    def list_via_employee(cls, token_dict, filter_expr=None):
        with cls.new_session() as db_session:
            post_code_list = RelationshipEmployee2PostCode.filter_all(
                RelationshipEmployee2PostCode.employee_id
                == token_dict.selected_company.employee_id,
                db=db_session
            ).data
            post_code_id_list = [post_code.member_id for post_code in post_code_list]
            if not post_code_id_list:
                raise ValueError(
                    "User has no post code registered. User can not list addresses."
                )
                # raise HTTPException(
                #     status_code=404,
                #     detail="User has no post code registered. User can not list addresses.",
                # )
            cls.pre_query = cls.filter_all(cls.post_code_id.in_(post_code_id_list), db=db_session).query
            filter_cls = cls.filter_all(*filter_expr or [], db=db_session)
            cls.pre_query = None
            return filter_cls.data

    # buildings: Mapped["Build"] = relationship(
    #     "Build", back_populates="addresses", foreign_keys="Build.address_id"
    # )
    # site: Mapped["BuildSites"] = relationship(
    #     "BuildSites", back_populates="addresses", foreign_keys="BuildSites.address_id"
    # )
    # official_companies: Mapped["Companies"] = relationship(
    #     "Company",
    #     back_populates="official_address",
    #     foreign_keys="Company.official_address_id",
    # )

    # @classmethod
    # def create_action(cls, request, create_address: InsertAddress):
    #     from services.redis.auth_actions.token import parse_token_object_to_dict
    #
    #     token_dict = parse_token_object_to_dict(request=request)
    #     data_dict = create_address.model_dump()
    #     post_code = AddressPostcode.find_one(uu_id=create_address.post_code_uu_id)
    #     if not post_code:
    #         raise HTTPException(
    #             status_code=404,
    #             detail="Post code not found.",
    #         )
    #     if Employee2AddressRelationship.post_code_id.find_one(
    #         employee_id=token_dict.selected_company.employee_id,
    #         post_code_id=post_code.id,
    #     ):
    #         data_dict["post_code_id"] = post_code.id
    #         del data_dict["post_code_uu_id"]
    #         return cls.find_or_create(**create_address.model_dump())
    #     raise HTTPException(
    #         status_code=401,
    #         detail=f"User is not qualified to create address at this post code {post_code.postcode}",
    #     )

    # __table_args__ = (
    #     Index("_address_ndx_00", country_code, b_state, city, district),
    #     {"comment": "Address Information"},
    # )


class AddressGeographicLocations(CrudCollection):
    """
    Country class based on declarative_base and BaseMixin via session
    """

    __tablename__ = "address_geographic_locations"
    __exclude__fields__ = []

    geo_table: Mapped[str] = mapped_column(
        String, nullable=False, comment="Address Table Name"
    )
    geo_id: Mapped[int] = mapped_column(
        Integer, nullable=False, comment="Address Table ID"
    )
    geo_name: Mapped[str] = mapped_column(
        String, nullable=False, comment="Geographic Location Name"
    )
    geo_latitude: Mapped[float] = mapped_column(
        Numeric(20, 6), server_default="0", comment="Geographic Location Name"
    )
    geo_longitude: Mapped[float] = mapped_column(
        Numeric(20, 6), server_default="0", comment="Geographic Location Latitude"
    )
    geo_altitude: Mapped[float] = mapped_column(
        Numeric(20, 6), server_default="0", comment="Geographic Location Longitude"
    )
    geo_description: Mapped[str] = mapped_column(
        Text, nullable=False, comment="Geographic Location Description"
    )
    geo_area_size: Mapped[float] = mapped_column(
        Numeric(20, 2),
        nullable=True,
        server_default="0",
        comment="Geographic Location Area Size",
    )
    geo_population: Mapped[int] = mapped_column(
        BigInteger, nullable=True, comment="Geographic Location Population"
    )
    # geo_geom_point = mapped_column(Geometry('POINT', srid=4326), nullable=True, comment="Geographic Location Points")
    # geo_geom_polygon = mapped_column(Geometry('POLYGON', srid=4326), nullable=True,
    # comment="Geographic Location Vector geographic information (polygon)")
    # geo_centroid = mapped_column( GEOMETRY(POINT, 4326), nullable=True,
    # comment="Geographic Location center of gravity of the region(points)")

    __table_args__ = (
        Index("_address_geographic_locations_ndx_00", geo_table, geo_id),
        Index("_address_geographic_locations_ndx_01", geo_latitude, geo_longitude),
        {"comment": "Geographic Location Information"},
    )


class AddressCountry(CrudCollection):
    """
    Country class based on declarative_base and BaseMixin via session
    """

    __tablename__ = "address_country"
    __exclude__fields__ = []

    country_code: Mapped[str] = mapped_column(
        String(16), nullable=False, comment="Country Code"
    )
    country_name: Mapped[str] = mapped_column(
        String, nullable=False, comment="Country Name"
    )
    money_code: Mapped[str] = mapped_column(
        String(12), nullable=True, comment="Money Code"
    )
    language: Mapped[str] = mapped_column(
        String, nullable=True, comment="Language Code"
    )
    address_geographic_id: Mapped[int] = mapped_column(
        BigInteger, nullable=True, comment="Address Geographic Id"
    )

    __table_args__ = (
        Index("_address_country_ndx_00", money_code),
        Index("_address_country_ndx_01", country_code, unique=True),
        {"comment": "Country Information"},
    )


class AddressState(CrudCollection):
    """
    State class based on declarative_base and BaseMixin via session
    """

    __tablename__ = "address_state"
    __exclude__fields__ = []

    state_code: Mapped[str] = mapped_column(
        String(16), nullable=False, comment="State Code"
    )
    state_name: Mapped[str] = mapped_column(
        String, nullable=False, comment="State Name"
    )
    licence_plate: Mapped[str] = mapped_column(
        String(24), nullable=True, comment="Sign Code"
    )
    phone_code: Mapped[str] = mapped_column(
        String(36), nullable=True, comment="Phone Code"
    )
    gov_code: Mapped[str] = mapped_column(
        String(128), nullable=True, comment="Government Code"
    )
    address_geographic_id: Mapped[int] = mapped_column(
        BigInteger, nullable=True, comment="Address Geographic Id"
    )

    country_id: Mapped[int] = mapped_column(ForeignKey("address_country.id"))
    country_uu_id: Mapped[str] = mapped_column(
        String, server_default="", comment="Country UUID"
    )

    __table_args__ = (
        Index(
            "_address_state_ndx_01",
            country_id,
            state_code,
            unique=True,
        ),
        {"comment": "State Information"},
    )


class AddressCity(CrudCollection):
    """
    City class based on declarative_base and BaseMixin via session
    """

    __tablename__ = "address_city"
    __exclude__fields__ = []

    city_code: Mapped[str] = mapped_column(
        String(24), nullable=False, comment="City Code"
    )
    city_name: Mapped[str] = mapped_column(String, nullable=False, comment="City Name")
    licence_plate: Mapped[str] = mapped_column(
        String(24), nullable=True, comment="Sign Code"
    )
    phone_code: Mapped[str] = mapped_column(
        String(36), nullable=True, comment="Phone Code"
    )
    gov_code: Mapped[str] = mapped_column(
        String(128), nullable=True, comment="Government Code"
    )
    address_geographic_id: Mapped[int] = mapped_column(
        BigInteger, nullable=True, comment="Address Geographic Id"
    )

    state_id: Mapped[int] = mapped_column(ForeignKey("address_state.id"))
    state_uu_id: Mapped[str] = mapped_column(
        String, server_default="", comment="State UUID"
    )

    __table_args__ = (
        Index(
            "_address_city_ndx_01",
            state_id,
            city_code,
            unique=True,
        ),
        {"comment": "City Information"},
    )


class AddressDistrict(CrudCollection):
    """
    District class based on declarative_base and BaseMixin via session
    """

    __tablename__ = "address_district"
    __exclude__fields__ = []

    district_code: Mapped[str] = mapped_column(
        String(16), nullable=False, comment="District Code"
    )
    district_name: Mapped[str] = mapped_column(
        String, nullable=False, comment="District Name"
    )
    phone_code: Mapped[str] = mapped_column(
        String(36), nullable=True, comment="Phone Code"
    )
    gov_code: Mapped[str] = mapped_column(
        String(128), nullable=True, comment="Government Code"
    )
    address_geographic_id: Mapped[int] = mapped_column(
        BigInteger, nullable=True, comment="Address Geographic Id"
    )

    city_id: Mapped[int] = mapped_column(
        ForeignKey("address_city.id"), nullable=False, comment="City ID"
    )
    city_uu_id: Mapped[str] = mapped_column(
        String, server_default="", comment="City UUID"
    )

    __table_args__ = (
        Index(
            "_address_district_ndx_01",
            city_id,
            district_code,
            unique=True,
        ),
        {"comment": "District Information"},
    )


class AddressLocality(CrudCollection):
    """
    Locality class based on declarative_base and BaseMixin via session
    """

    __tablename__ = "address_locality"
    __exclude__fields__ = []

    locality_code: Mapped[str] = mapped_column(
        String(16), nullable=False, comment="Locality Code"
    )
    locality_name: Mapped[str] = mapped_column(
        String, nullable=False, comment="Locality Name"
    )
    type_code: Mapped[str] = mapped_column(String, nullable=True, comment="Type Name")
    type_description: Mapped[str] = mapped_column(
        String, nullable=True, comment="Type Name"
    )
    gov_code: Mapped[str] = mapped_column(
        String(128), nullable=True, comment="Government Code"
    )
    address_show: Mapped[bool] = mapped_column(Boolean, server_default="1")
    address_geographic_id: Mapped[int] = mapped_column(
        BigInteger, nullable=True, comment="Address Geographic Id"
    )

    district_id: Mapped[int] = mapped_column(
        ForeignKey("address_district.id"), nullable=False, comment="District ID"
    )
    district_uu_id: Mapped[str] = mapped_column(
        String, server_default="", comment="District UUID"
    )

    __table_args__ = (
        Index(
            "_address_locality_ndx_01",
            district_id,
            locality_code,
            unique=True,
        ),
        {"comment": "Locality Information"},
    )


class AddressNeighborhood(CrudCollection):
    """
    Neighborhood class based on declarative_base and BaseMixin via session
    """

    __tablename__ = "address_neighborhood"
    __exclude__fields__ = []

    neighborhood_code: Mapped[str] = mapped_column(
        String(16), nullable=False, comment="Neighborhood Code"
    )
    neighborhood_name: Mapped[str] = mapped_column(
        String, nullable=False, comment="Neighborhood Name"
    )
    type_code: Mapped[str] = mapped_column(String, nullable=True, comment="Type Name")
    type_description: Mapped[str] = mapped_column(
        String, nullable=True, comment="Type Name"
    )
    gov_code: Mapped[str] = mapped_column(
        String(128), nullable=True, comment="Government Code"
    )
    address_show: Mapped[bool] = mapped_column(Boolean, server_default="1")
    address_geographic_id: Mapped[int] = mapped_column(
        BigInteger, nullable=True, comment="Address Geographic Id"
    )

    district_id: Mapped[int] = mapped_column(
        ForeignKey("address_district.id"), nullable=True, comment="District ID"
    )
    district_uu_id: Mapped[str] = mapped_column(
        String, server_default="", comment="District UUID"
    )
    locality_id: Mapped[int] = mapped_column(
        ForeignKey("address_locality.id"), nullable=True, comment="Locality ID"
    )
    locality_uu_id: Mapped[str] = mapped_column(
        String, server_default="", comment="Locality UUID"
    )

    __table_args__ = (
        Index(
            "_address_neighborhood_ndx_01",
            locality_id,
            neighborhood_code,
            unique=True,
        ),
        {"comment": "Neighborhood Information"},
    )


class AddressStreet(CrudCollection):
    """
    Street class based on declarative_base and BaseMixin via session
    """

    __tablename__ = "address_street"
    __exclude__fields__ = []

    street_code: Mapped[str] = mapped_column(
        String(16), nullable=False, comment="Street Code"
    )
    street_name: Mapped[str] = mapped_column(
        String, nullable=False, comment="Street Name"
    )
    type_code: Mapped[str] = mapped_column(String, nullable=True, comment="Type Name")
    type_description: Mapped[str] = mapped_column(
        String, nullable=True, comment="Type Name"
    )
    gov_code: Mapped[str] = mapped_column(
        String(128), nullable=True, comment="Government Code"
    )

    address_geographic_id: Mapped[int] = mapped_column(
        BigInteger, nullable=True, comment="Address Geographic Id"
    )
    neighborhood_id: Mapped[int] = mapped_column(
        ForeignKey("address_neighborhood.id"), nullable=False, comment="Neighborhood ID"
    )
    neighborhood_uu_id: Mapped[str] = mapped_column(
        String, server_default="", comment="Neighborhood UUID"
    )

    __table_args__ = (
        Index("_address_street_ndx_01", neighborhood_id, street_code, unique=True),
        {"comment": "Street Information"},
    )

    @classmethod
    def search_address_text(cls, search_text, token_dict=None):
        field_dict = {
            "AddressStreet.uu_id": cls.uu_id,
            "AddressCountry.uu_id": AddressCountry.uu_id,
            "AddressState.uu_id": AddressState.uu_id,
            "AddressCity.uu_id": AddressCity.uu_id,
            "AddressDistrict.uu_id": AddressDistrict.uu_id,
            "AddressLocality.uu_id": AddressLocality.uu_id,
            "AddressNeighborhood.uu_id": AddressNeighborhood.uu_id,
            "AddressCountry.country_name": AddressCountry.country_name,
            "AddressState.state_name": AddressState.state_name,
            "AddressCity.city_name": AddressCity.city_name,
            "AddressDistrict.district_name": AddressDistrict.district_name,
            "AddressLocality.locality_name": AddressLocality.locality_name,
            "AddressNeighborhood.neighborhood_name": AddressNeighborhood.neighborhood_name,
            "AddressStreet.street_name": cls.street_name,
        }
        joined_data = (
            cls.session.query(*list(field_dict.values()))
            .select_from(cls)
            .join(AddressNeighborhood, AddressNeighborhood.id == cls.neighborhood_id)
            .join(
                AddressLocality, AddressLocality.id == AddressNeighborhood.locality_id
            )
            .join(AddressDistrict, AddressDistrict.id == AddressLocality.district_id)
            .join(AddressCity, AddressCity.id == AddressDistrict.city_id)
            .join(AddressState, AddressState.id == AddressCity.state_id)
            .join(AddressCountry, AddressCountry.id == AddressState.country_id)
            .filter(
                or_(
                    AddressNeighborhood.neighborhood_name.ilike(
                        f"%{str(search_text).upper()}%"
                    ),
                    AddressLocality.locality_name.ilike(
                        f"%{str(search_text).upper()}%"
                    ),
                    AddressDistrict.district_name.ilike(
                        f"%{str(search_text).upper()}%"
                    ),
                    # AddressCity.city_name.ilike(f"%{str(search_text).upper()}%"),
                    # AddressState.state_name.ilike(f"%{str(search_text).upper()}%"),
                    # AddressCountry.country_name.ilike(f"%{str(search_text).upper()}%"),
                    cls.street_name.ilike(f"%{str(search_text).upper()}%"),
                ),
            )
        )
        # select([mytable.c.id]).where(
        #     func.to_tsvector('english', mytable.c.title) \
        #         .match('somestring', postgresql_regconfig='english')
        # )
        joined_statement = joined_data
        joined_data = joined_data.first()
        if not joined_data:
            raise ValueError(
                "No address found with the given search text.",
            )
            # raise HTTPException(
            #     status_code=404,
            #     detail="No address found with the given search text.",
            # )
        return dict(
            query=joined_statement,
            schema=list(field_dict.keys()),
        )