TransformMod

class TransformMod(BaseTemplate):
    """
    * Modifier for Transform templates.

    Adds:
        * Flipside power/toughness on the front if opposite side is a Creature.
        * Transform icon, inherited from BaseTemplate, is made visible.

    Modifies:
        * Rules text layer has 2 new options: a creature and noncreature option with flipside PT cutout.
        * PT, name, and type text are all white UNLESS this is an eldrazi, e.g. Eldritch Moon transform cards.
    """

    """
    * Mixin Methods
    """

    @auto_prop_cached
    def frame_layer_methods(self) -> list[Callable]:
        """Add Transform frame layers step."""
        funcs = [self.enable_transform_layers] if self.is_transform else []
        return super().frame_layer_methods + funcs

    @auto_prop_cached
    def text_layer_methods(self) -> list[Callable]:
        """Add Transform text layers step."""
        funcs = [self.text_layers_transform] if self.is_transform else []
        return super().text_layer_methods + funcs

    """
    * Text Layers
    """

    @auto_prop_cached
    def text_layer_rules(self) -> Optional[ArtLayer]:
        """Supports noncreature and creature, with or without flipside PT."""
        if self.is_transform and self.is_front and self.is_flipside_creature:
            if self.is_creature:
                return psd.getLayer(LAYERS.RULES_TEXT_CREATURE_FLIP, self.text_group)
            return psd.getLayer(LAYERS.RULES_TEXT_NONCREATURE_FLIP, self.text_group)
        return super().text_layer_rules

    """
    * Transform Text Layers
    """

    @auto_prop_cached
    def text_layer_flipside_pt(self) -> Optional[ArtLayer]:
        """Flipside power/toughness layer for front face Transform cards."""
        return psd.getLayer(LAYERS.FLIPSIDE_POWER_TOUGHNESS, self.text_group)

    """
    * Transform Frame Layer Methods
    """

    def enable_transform_layers(self) -> None:
        """Enable layers that are required by transform cards."""

        # Enable transform icon
        if self.transform_icon_layer:
            self.transform_icon_layer.visible = True

        # Enable front / back specific layers
        if self.is_front:
            return self.enable_transform_layers_front()
        return self.enable_transform_layers_back()

    def enable_transform_layers_front(self) -> None:
        """Enables layers that are required by front face transform cards."""
        pass

    def enable_transform_layers_back(self) -> None:
        """Enables layers that are required by back face transform cards."""
        pass

    """
    * Transform Text Layer Methods
    """

    def text_layers_transform(self) -> None:
        """Adds and modifies text layers for transform cards."""

        # Enable front / back specific layers
        if self.is_front:
            return self.text_layers_transform_front()
        return self.text_layers_transform_back()

    def text_layers_transform_front(self) -> None:
        """Adds and modifies text layers for front face transform cards."""

        # Add flipside Power/Toughness
        if self.is_flipside_creature:
            self.text.append(
                TextField(
                    layer=self.text_layer_flipside_pt,
                    contents=f'{self.layout.other_face_power}/'
                             f'{self.layout.other_face_toughness}'))

    def text_layers_transform_back(self) -> None:
        """Adds and modifies text layers for back face transform cards."""

        # Rear face Eldrazi cards: Black rules, typeline, and PT text
        if self.layout.transform_icon == TransformIcons.MOONELDRAZI:
            self.text_layer_name.textItem.color = self.RGB_BLACK
            self.text_layer_type.textItem.color = self.RGB_BLACK
            if self.is_creature:
                self.text_layer_pt.textItem.color = self.RGB_BLACK