SagaVectorTemplate

class SagaVectorTemplate(VectorNyxMod, VectorSagaMod, VectorTransformMod, VectorTemplate):
    """Saga template using vector shape layers and automatic pinlines / multicolor generation."""

    """
    * Bool Properties
    """

    @auto_prop_cached
    def is_name_shifted(self) -> bool:
        """bool: Back face TF icon is on right side."""
        return bool(self.is_transform and self.is_front)

    """
    * Colors
    """

    @auto_prop_cached
    def twins_colors(self) -> list[str]:
        """list[str]: Use Back face versions for back side Transform."""
        return [f'{self.twins} {LAYERS.BACK}'] if self.is_transform and not self.is_front else [self.twins]

    @auto_prop_cached
    def textbox_colors(self) -> list[str]:
        """list[str]: Support back and front side textures."""
        if self.is_transform and not self.is_front:
            # Back -> Dual color
            if 1 < len(self.identity) < self.color_limit:
                return [f"{n} {LAYERS.BACK}" for n in self.identity]
            # Back -> Single color
            return [f"{self.pinlines} {LAYERS.BACK}"]
        # Front -> Dual color
        if 1 < len(self.identity) < self.color_limit:
            return [n for n in self.identity]
        # Front -> Single color
        return [self.pinlines]

    @auto_prop_cached
    def crown_colors(self) -> Union[list[int], list[dict]]:
        """Return RGB/CMYK integer list or Gradient dict notation for color adjustment layers."""
        return psd.get_pinline_gradient(
            colors=self.pinlines,
            color_map=self.crown_color_map)

    """
    * Groups
    """

    @auto_prop_cached
    def crown_group(self) -> LayerSet:
        """Legendary crown group."""
        return psd.getLayerSet(LAYERS.SHAPE, LAYERS.LEGENDARY_CROWN)

    @auto_prop_cached
    def textbox_group(self) -> LayerSet:
        """Must enable textbox group."""
        if group := psd.getLayerSet(LAYERS.TEXTBOX):
            group.visible = True
            return group

    """
    * Layers
    """

    @auto_prop_cached
    def border_layer(self) -> Optional[ArtLayer]:
        """Check for Legendary and/or front face Transform."""
        name = LAYERS.LEGENDARY if self.is_legendary else LAYERS.NORMAL
        if self.is_transform and self.is_front:
            name += f" {LAYERS.TRANSFORM_FRONT}"
        return psd.getLayer(name, LAYERS.BORDER)

    """
    * References
    """

    @auto_prop_cached
    def art_reference(self) -> ArtLayer:
        return psd.getLayer(LAYERS.ART_FRAME + " Right")

    @auto_prop_cached
    def textbox_reference(self) -> Optional[ReferenceLayer]:
        if self.is_front and self.is_flipside_creature:
            return psd.get_reference_layer(f"{LAYERS.TEXTBOX_REFERENCE} {LAYERS.TRANSFORM_FRONT}", self.saga_group)
        return psd.get_reference_layer(LAYERS.TEXTBOX_REFERENCE, self.saga_group)

    """
    * Blending Masks
    """

    @auto_prop_cached
    def textbox_masks(self) -> list[ArtLayer]:
        return [psd.getLayer(LAYERS.HALF, [self.mask_group, LAYERS.TEXTBOX])]

    @auto_prop_cached
    def background_masks(self) -> list[ArtLayer]:
        return [psd.getLayer(LAYERS.HALF, [self.mask_group, LAYERS.BACKGROUND])]

    """
    * Shape Layers
    """

    @auto_prop_cached
    def pinlines_shapes(self) -> list[Union[ArtLayer, LayerSet, None]]:
        """Add Legendary shape to pinlines shapes."""
        shapes = [psd.getLayerSet(LAYERS.LEGENDARY, [self.pinlines_group, LAYERS.SHAPE])] if self.is_legendary else []
        return [
            # Normal or Transform pinline
            psd.getLayerSet(
                (LAYERS.TRANSFORM_FRONT if self.is_front else LAYERS.TRANSFORM_BACK)
                if self.is_transform else LAYERS.NORMAL,
                [self.pinlines_group, LAYERS.SHAPE]
            ), *shapes
        ]

    @auto_prop_cached
    def textbox_shapes(self) -> list[Union[ArtLayer, LayerSet, None]]:
        """Optional Textbox cutout shapes."""
        if self.is_transform and self.is_front:
            return [psd.getLayer(LAYERS.TRANSFORM_FRONT, [self.textbox_group, LAYERS.SHAPE])]
        return []

    @auto_prop_cached
    def twins_shape(self) -> ArtLayer:
        """Allow for both front and back Transform twins."""
        if self.is_transform:
            return psd.getLayer(
                LAYERS.TRANSFORM_FRONT if self.is_front else LAYERS.TRANSFORM_BACK,
                [self.twins_group, LAYERS.SHAPE])
        # Normal twins
        return psd.getLayer(LAYERS.NORMAL, [self.twins_group, LAYERS.SHAPE])

    @auto_prop_cached
    def outline_shape(self) -> ArtLayer:
        """Outline for textbox and art area."""
        return psd.getLayer(
            LAYERS.TRANSFORM_FRONT if self.is_transform and self.is_front else LAYERS.NORMAL,
            LAYERS.OUTLINE)

    @auto_prop_cached
    def enabled_shapes(self) -> list[Union[ArtLayer, LayerSet, None]]:
        """Add support for outline shape, multiple pinlines shapes, and saga shapes."""
        return [
            *self.pinlines_shapes,
            *self.textbox_shapes,
            self.saga_banner_shape,
            self.saga_stripe_shape,
            self.saga_trim_shape,
            self.outline_shape,
            self.border_shape,
            self.twins_shape
        ]

    """
    * Blending Masks
    """

    @auto_prop_cached
    def pinlines_mask(self) -> list[ArtLayer]:
        """Mask hiding pinlines effects inside textbox and art frame."""
        return [
            psd.getLayer(
                LAYERS.TRANSFORM_FRONT if self.is_transform and self.is_front else LAYERS.NORMAL,
                [self.mask_group, LAYERS.PINLINES]),
            self.pinlines_group
        ]

    @auto_prop_cached
    def enabled_masks(self) -> list[Union[dict, list, ArtLayer, LayerSet, None]]:
        """Support a pinlines mask."""
        return [self.pinlines_mask]

    """
    * Transform Frame Layer Methods
    """

    def enable_transform_layers(self):

        # Must enable Transform Icon group
        if self.transform_icon_layer:
            self.transform_icon_layer.parent.visible = True
            self.transform_icon_layer.visible = True

    """
    * Transform Text Layer Methods
    """

    def text_layers_transform_back(self):

        # Change back face name and typeline to white
        self.text_layer_name.textItem.color = psd.rgb_white()
        self.text_layer_type.textItem.color = psd.rgb_white()