TextField

class TextField:
    FONT = CardFonts.TITLES
    FONT_ITALIC = CardFonts.RULES_ITALIC
    FONT_BOLD = CardFonts.RULES_BOLD

    def __init__(self, layer: ArtLayer, contents: str = "", **kwargs):
        """A generic TextField, which allows you to set a text layer's contents and text color.

        Args:
            layer: TextItem layer to insert contents.
            contents: Text contents to be inserted.
            color: Font color to use for this TextItem.

        Keyword Args:
            color: Color to apply to the text item.
            font: Font postScriptName to apply to the text item.
            font_mana: Font postScriptName to apply to mana symbol text.
            font_italic: Font postScriptName to apply to italicized text.
            font_bold: Font postScriptName to apply to bold text.
            reference: Reference layer to used for scaling operations.
        """
        self._kwargs = kwargs
        self._layer = layer
        self.contents = contents.replace(
            "\n", "\r")

    """
    * Keyword Arguments
    """

    @cached_property
    def kwargs(self) -> dict:
        """Contains optional parameters to modify text formatting behavior."""
        return self._kwargs

    @cached_property
    def kw_color(self) -> Optional[SolidColor]:
        """Color to apply to the TextItem."""
        return self.kwargs.get('color')

    @cached_property
    def kw_font(self) -> Optional[str]:
        """Font to apply to the root TextItem."""
        return self.kwargs.get('font')

    @cached_property
    def kw_font_mana(self) -> Optional[str]:
        """Font to apply to any mana symbols in the TextItem."""
        return self.kwargs.get('font_mana')

    @cached_property
    def kw_font_italic(self) -> Optional[str]:
        """Font to apply to any italicized text in the TextItem."""
        return self.kwargs.get('font_italic')

    @cached_property
    def kw_font_bold(self) -> Optional[str]:
        """Font to apply to any bold text in the TextItem."""
        return self.kwargs.get('font_bold')

    @cached_property
    def kw_symbol_map(self) -> dict[str, tuple[str, list[ColorObject]]]:
        """Symbol map to use for formatting mana symbols."""
        return self.kwargs.get('symbol_map', CON.symbol_map)

    """
    * Checks
    """

    @cached_property
    def is_text_layer(self) -> bool:
        """Checks if the layer provided is a TextLayer."""
        return bool(self.layer.kind == LayerKind.TextLayer)

    """
    * Core Objects
    """

    @cached_property
    def docref(self) -> Document:
        """The currently active Photoshop document."""
        return APP.activeDocument

    @cached_property
    def doc_selection(self) -> Selection:
        """The Selection object from the active document."""
        return self.docref.selection

    @property
    def layer(self) -> ArtLayer:
        """ArtLayer containing the TextItem."""
        return self._layer

    @cached_property
    def TI(self) -> TextItem:
        """The TextItem object within the ArtLayer."""
        return self.layer.textItem

    @cached_property
    def reference(self) -> Optional[ArtLayer]:
        """A reference layer, typically used for scaling the TextItem."""
        return self.kwargs.get('reference', None)

    @cached_property
    def reference_dims(self) -> Optional[type[LayerDimensions]]:
        """Optional[type[LayerDimensions]]: Dimensions of the scaling reference layer."""
        if isinstance(self.reference, ReferenceLayer):
            return self.reference.dims
        if self.reference:
            return get_layer_dimensions(self.reference)
        return None

    @property
    def input(self) -> str:
        """Raw contents provided to fill the TextItem."""
        return self.contents

    @cached_property
    def color(self) -> SolidColor:
        """A SolidColor object provided, or fallback on current TextItem color."""
        return self.kw_color or get_text_item_color(self.TI)

    @cached_property
    def font(self) -> str:
        """Font provided, or fallback on global constant."""
        return self.kw_font or CON.font_title

    """
    * Methods
    """

    def validate(self):
        """Ensure the Text Layer provided is valid."""
        if self.layer and self.is_text_layer:
            # Layer is valid, select and show it
            select_layer(self.layer, True)
            return True
        with suppress(Exception):
            # Layer provided doesn't exist or isn't a text layer
            name = self.layer.name if self.layer else '[Non-Layer]'
            print(f'Text Field class: {self.__class__.__name__}\n'
                  f'Invalid layer provided: {name}')
            self.layer.visible = False
        return False

    def execute(self):
        """Executes all text actions."""

        # Update TextItem contents
        self.TI.contents = self.input

        # Update color if it was provided manually
        if self.kw_color:
            self.TI.color = self.color

        # Update font manually if mismatch detected
        if self.font != self.FONT:
            self.TI.font = self.font

        # Change to English formatting if needed
        if CFG.force_english_formatting:
            self.TI.language = Language.EnglishUSA