from fprime_gds.common.data_types.base_type import BaseType
from fprime_gds.common.utils.config_manager import ConfigManager
import logging

LOGGER = logging.getLogger("NonDisplayableType")

class NonDisplayableType(BaseType):
    """
    Represents types that cannot be displayed in GDS but need to be maintained
    in dictionaries for data product records and other purposes.
    """
    def __init__(self, type_name: str, size: int = None, format_string: str = None):
        """
        Initialize a non-displayable type
        
        Args:
            type_name: Name of the original type
            size: Optional byte size of the type if known
            format_string: Optional format string for debugging
        """
        super().__init__()
        self.type_name = type_name
        self.size = size
        self.format_string = format_string or f"<{type_name}>"
        self._config = ConfigManager()

    def serialize(self) -> bytes:
        """
        Serialize type information for dictionary storage
        """
        return {
            "type": "non_displayable",
            "name": self.type_name,
            "size": self.size,
            "format": self.format_string
        }

    def deserialize(self, data: bytes, offset: int = 0):
        """
        Deserialize data into a placeholder representation
        """
        LOGGER.debug(f"Skipping deserialization of non-displayable type {self.type_name}")
        return (None, offset + (self.size if self.size else 0))

    def get_type_base(self) -> str:
        """
        Return base type identifier
        """
        return "non_displayable"

    def __str__(self) -> str:
        return f"NonDisplayable({self.type_name})"

# Extension to XmlLoader to handle non-displayable types
def parse_non_displayable_type(self, type_name: str, xml_node, xml_tree, context):
    """
    Parse XML definition for non-displayable type
    """
    size = None
    format_string = None
    
    # Try to extract size information if available
    try:
        size_node = xml_node.find("size")
        if size_node is not None:
            size = int(size_node.text)
    except (ValueError, AttributeError):
        LOGGER.warning(f"Could not parse size for type {type_name}")

    # Try to extract format string if available    
    try:
        format_node = xml_node.find("format")
        if format_node is not None:
            format_string = format_node.text
    except AttributeError:
        pass

    return NonDisplayableType(type_name, size, format_string)

# Modified exception handling in XmlLoader.parse_type
def parse_type(self, type_name: str, xml_node, xml_tree, context):
    """
    Enhanced type parsing with non-displayable type handling
    """
    try:
        return super().parse_type(type_name, xml_node, xml_tree, context)
    except exceptions.GseControllerParsingException as e:
        LOGGER.warning(f"Converting unparseable type {type_name} to NonDisplayableType: {str(e)}")
        return parse_non_displayable_type(self, type_name, xml_node, xml_tree, context)