from typing import List, Optional

from frostfs_sdk.models.dto.replica import Replica
from frostfs_sdk.protos.models.netmap import types_pb2 as types_pb2_netmap


class ReplicaMapper:
    @staticmethod
    def to_grpc_messages(replicas: List[Replica]) -> Optional[List[types_pb2_netmap.Replica]]:
        if not replicas:
            return None
        return [ReplicaMapper.to_grpc_message(selector) for selector in replicas]
    
    @staticmethod
    def to_grpc_message(replica: Replica) -> Optional[types_pb2_netmap.Replica]:
        """
        Converts Replica DTO to gRPC message
        
        Args:
            replice: Replica DTO object
            
        Returns:
            gRPC Replica message
        """
        if not replica:
            return None
        
        return types_pb2_netmap.Replica(
            count=replica.count,
            selector=replica.selector
        )

    @staticmethod
    def to_models(grpc_replicas: List[types_pb2_netmap.Replica]) -> Optional[List[Replica]]:
        if not grpc_replicas:
            return None
        return [ReplicaMapper.to_model(grpc_replica) for grpc_replica in grpc_replicas]
    
    @staticmethod
    def to_model(grpc_replica: types_pb2_netmap.Replica) -> Optional[Replica]:
        """
        Converts gRPC message to Replica DTO
        
        Args:
            grpc_replica: gRPC Replica message
            
        Returns:
            Replica DTO object
        """
        if not grpc_replica or grpc_replica.ByteSize() == 0:
            return None
        
        return Replica(
            count=grpc_replica.count,
            selectors=grpc_replica.selector
        )