from backend.addresses.Address import Address


class Addresses:
    def __init__(self, addresses: list[Address]):
        self._addresses = addresses
        # self._identity_index = self._build_identity_index()

    def __getitem__(self, index: int) -> Address:
        return self._addresses[index]

    def __len__(self) -> int:
        return len(self._addresses)

    @classmethod
    def from_plan_input(cls, plan_input: list[dict], body) -> "Addresses":
        addresses = []
        for row in plan_input:
            addresses.append(cls._parse_row(row, body))
        return cls(addresses)

    def get_uprns(self):
        return [x.uprn for x in self._addresses if x.uprn is not None]

    def get_landlord_ids(self):
        return [x.landlord_property_id for x in self._addresses if x.landlord_property_id is not None]

    def get_unique_postcodes(self):
        return list({x.postcode for x in self._addresses})

    def get_postcodes_for_flats(self):
        # Method to extract all of the postcodes associated to a flat, which is used for remote assessments
        # on flats
        return [x.postcode for x in self._addresses if x.property_type in ["Flat", "flat"]]

    def get_property_requests(self):
        return [x.request_data for x in self._addresses]

    @staticmethod
    def _parse_row(row: dict, body) -> Address:
        def clean_uprn(v):
            try:
                return int(float(v))
            except (TypeError, ValueError):
                return None

        uprn = clean_uprn(row.get("uprn"))

        address = row.get("address")
        if not address and body.file_format == "domna_asset_list":
            address = row.get("domna_address_1")

        full_address = (
            row.get("domna_full_address")
            if body.file_format == "domna_asset_list"
            else None
        )
        if not isinstance(full_address, str):
            full_address = None

        postcode = str(row["postcode"]).strip().upper()

        return Address(
            uprn=uprn,
            landlord_property_id=str(row["landlord_property_id"])
            if row.get("landlord_property_id") else None,
            address=str(address).strip() if address else None,
            full_address=str(full_address).strip() if full_address else None,
            postcode=postcode,
            property_type=row.get("property_type"),
            built_form=row.get("built_form"),
            estimated=bool(row.get("estimated", False)),
            domna_full_address=row.get("domna_full_address"),
            domna_address_1=row.get("domna_address_1"),
        )

    # def _build_identity_index(self) -> dict:
    #     index = {}
    #     for addr in self._addresses:
    #         key = addr.identity_key()
    #         if key in index:
    #             raise ValueError(f"Duplicate address identity detected: {key}")
    #         index[key] = addr
    #     return index