from typing import List, Optional

from pdp.connectors.ows_account import OwsAccountClient
from pdp.connectors.redis_client import RedisConnector
from pdp.fastapi.schemas.check_resource_type_actions import CheckResourceTypeAction
from pdp.fastapi.schemas.tenant import (
    Tenant,
    UuidToIdExchangeTenant,
)
from pdp.proxies.uuid_to_id_exchange_tenant_proxy import UuidToIdExchangeTenantProxy


class AllowedTenant(Tenant):
    """Representation of an allowed tenant."""

    tenant_id: Optional[int | str] = None


class GetAllowedTenantsRequest(CheckResourceTypeAction):
    """Request object for getting allowed tenants for a resource type action pair."""


class GetAllowedTenantsResponse(CheckResourceTypeAction):
    """Response object for getting allowed tenants for a resource type action pair."""

    tenants: List[AllowedTenant]

    async def update_with_uuid_to_id_exchange(
        self,
        redis_connector: RedisConnector,
        ows_account_client: OwsAccountClient,
    ) -> None:
        """Perform UuidToIdExchange on the response's tenants."""
        exchange_tenants: List[UuidToIdExchangeTenant] = []
        for tenant in self.tenants:
            exchange_tenant = UuidToIdExchangeTenant(**tenant.model_dump())
            exchange_tenants.append(exchange_tenant)

        proxy = UuidToIdExchangeTenantProxy(
            tenants=exchange_tenants,
            redis_connector=redis_connector,
            ows_account_client=ows_account_client,
        )
        await proxy.gather_tenant_exchange()

        # Iterate over the resources to update in place
        updated_tenants = []
        for tenant in self.tenants:
            exchanged_tenant = proxy.get_tenant_exchange(tenant.tenant_uuid)
            if exchanged_tenant:
                updated_tenants.append(AllowedTenant(**exchanged_tenant.model_dump()))
            else:
                updated_tenants.append(AllowedTenant(**tenant.model_dump()))
        self.tenants = updated_tenants