ClassicTemplate

class ClassicTemplate(NormalTemplate):
    """A template for 7th Edition frame. Lacks some of the Normal Template features."""
    frame_suffix = 'Classic'

    """
    * Frame Details
    """

    @auto_prop_cached
    def template_suffix(self) -> str:
        """Add Promo if promo star enabled."""
        return 'Promo' if self.is_promo_star else ''

    """
    * Settings
    """

    @auto_prop_cached
    def is_promo_star(self) -> bool:
        """bool: Whether to enable the Promo Star overlay."""
        return CFG.get_setting(
            section='FRAME',
            key='Promo.Star',
            default=False)

    @auto_prop_cached
    def is_extended(self) -> bool:
        """bool: Whether to render using Extended Art framing."""
        return CFG.get_setting(
            section='FRAME',
            key='Extended.Art',
            default=False)

    @auto_prop_cached
    def is_align_collector_left(self) -> bool:
        """CollectorAlign: Which collector alignment to use."""
        return CFG.get_setting(
            section='TEXT',
            key='Collector.Align.Left',
            default=False)

    """
    * Bool Properties
    """

    @auto_prop_cached
    def is_content_aware_enabled(self) -> bool:
        """Force enabled if Extended Art is toggled."""
        return True if self.is_extended else super().is_content_aware_enabled

    """
    * Frame Layers
    """

    @auto_prop_cached
    def pinlines_layer(self) -> ArtLayer:
        """Only use split colors for land and hybrid cards, otherwise gold."""
        return psd.getLayer(
            self.background if len(self.pinlines) == 2 and not self.is_hybrid and not self.is_land else self.pinlines,
            LAYERS.LAND if self.is_land else LAYERS.NONLAND)

    """
    * Text Layers
    """

    @auto_prop_cached
    def text_layer_rules(self) -> ArtLayer:
        """ArtLayer: Does not change depending on Creature/Noncreature."""
        return psd.getLayer(LAYERS.RULES_TEXT, self.text_group)

    @auto_prop_cached
    def text_layer_type(self) -> ArtLayer:
        """ArtLayer: Card typeline text layer, used shifted version when color indicator is present."""
        if self.is_type_shifted:
            return psd.getLayer(LAYERS.TYPE_LINE_SHIFT, self.text_group)
        return psd.getLayer(LAYERS.TYPE_LINE, self.text_group)

    """
    * References
    """

    @auto_prop_cached
    def collector_reference(self) -> ReferenceLayer:
        """ReferenceLayer: Reference used to position the collector info."""
        return psd.get_reference_layer(LAYERS.COLLECTOR_REFERENCE, self.legal_group)

    @auto_prop_cached
    def textbox_reference(self) -> ArtLayer:
        """ArtLayer: Separately positioned box for 'Land' cards."""
        return psd.get_reference_layer(
            LAYERS.TEXTBOX_REFERENCE_LAND if self.is_land
            else LAYERS.TEXTBOX_REFERENCE,
            self.text_group)

    @auto_prop_cached
    def expansion_reference(self) -> ArtLayer:
        """ArtLayer: Separately positioned box for 'Land' cards."""
        return psd.getLayer(
            f"{LAYERS.EXPANSION_REFERENCE} {LAYERS.LAND}" if self.is_land
            else LAYERS.EXPANSION_REFERENCE,
            self.text_group)

    """
    * Masks
    """

    @auto_prop_cached
    def border_mask(self) -> ArtLayer:
        """ArtLayer: Contains a mask used to change the border to an Extended Art border."""
        return psd.getLayer(LAYERS.EXTENDED, LAYERS.MASKS)

    """
    * Layout Data Methods
    """

    def process_layout_data(self) -> None:
        """Remove rarity letter from collector data."""
        super().process_layout_data()
        self.layout.collector_data = self.layout.collector_data[:-2] if (
                '/' in self.layout.collector_data
        ) else self.layout.collector_data[2:]

    """
    * Collector Info Methods
    """

    def collector_info(self) -> None:
        """Format and add the collector info at the bottom."""

        # Which collector info mode?
        if CFG.collector_mode in [
            CollectorMode.Default, CollectorMode.Modern
        ] and self.layout.collector_data:
            layers = self.collector_info_authentic()
        elif CFG.collector_mode == CollectorMode.ArtistOnly:
            layers = self.collector_info_artist_only()
        else:
            layers = self.collector_info_basic()

        # Shift collector text
        if self.is_align_collector_left:
            [psd.align_left(n, ref=self.collector_reference.dims) for n in layers]

    def collector_info_basic(self) -> list[ArtLayer]:
        """Called to generate basic collector info."""

        # Get artist and info layers
        artist = psd.getLayer(LAYERS.ARTIST, self.legal_group)
        info = psd.getLayer(LAYERS.SET, self.legal_group)

        # Fill optional promo star
        if self.is_collector_promo:
            psd.replace_text(info, "•", MagicIcons.COLLECTOR_STAR)

        # Apply the collector info
        if self.layout.lang != 'en':
            psd.replace_text(info, 'EN', self.layout.lang.upper())
        psd.replace_text(artist, "Artist", self.layout.artist)
        psd.replace_text(info, 'SET', self.layout.set)
        return [artist, info]

    def collector_info_authentic(self) -> list[ArtLayer]:
        """Classic presents authentic collector info differently."""

        # Hide basic 'Set' layer
        psd.getLayer(LAYERS.SET, self.legal_group).visible = False

        # Get artist and info layers, reveal info layer
        artist = psd.getLayer(LAYERS.ARTIST, self.legal_group)
        info = psd.getLayer(LAYERS.COLLECTOR, self.legal_group)
        info.visible = True

        # Fill optional promo star
        if self.is_collector_promo:
            psd.replace_text(info, "•", MagicIcons.COLLECTOR_STAR)

        # Apply the collector info
        psd.replace_text(artist, 'Artist', self.layout.artist)
        psd.replace_text(info, 'SET', self.layout.set)
        psd.replace_text(info, 'NUM', self.layout.collector_data)
        return [artist, info]

    def collector_info_artist_only(self) -> list[ArtLayer]:
        """Called to generate 'Artist Only' collector info."""

        # Collector layers
        artist = psd.getLayer(LAYERS.ARTIST, self.legal_group)
        psd.getLayer(LAYERS.SET, self.legal_group).visible = False

        # Apply the collector info
        psd.replace_text(artist, "Artist", self.layout.artist)
        return [artist]

    """
    * Frame Layer Methods
    """

    def enable_frame_layers(self):
        """Enable layers which create the frame of the card. Simplified, does not support Legendary Crown."""

        # Resize expansion symbol
        if self.expansion_symbol_layer:
            self.expansion_symbol_layer.resize(90, 90, AnchorPosition.MiddleCenter)
            if self.is_land:
                self.expansion_symbol_layer.translate(0, 8)

        # Simple one image background
        self.pinlines_layer.visible = True

        # Add the promo star
        if self.is_promo_star:
            psd.getLayerSet("Promo Star", LAYERS.TEXT_AND_ICONS).visible = True

        # Make Extended Art modifications
        if self.is_extended:
            # Copy extended mask to Border
            psd.copy_layer_mask(self.border_mask, self.border_group)

            # Enable extended mask on Pinlines
            psd.enable_mask(self.pinlines_layer.parent)
            psd.enable_vector_mask(self.pinlines_layer.parent)

    """
    * Text Layer Methods
    """

    def rules_text_and_pt_layers(self):
        """Does not require a separate text area definition for Creature cards."""

        # Add rules text
        self.text.append(
            FormattedTextArea(
                layer=self.text_layer_rules,
                contents=self.layout.oracle_text,
                flavor=self.layout.flavor_text,
                centered=self.is_centered,
                reference=self.textbox_reference,
                divider=self.divider_layer))

        # Add Power / Toughness
        if self.is_creature:
            self.text.append(
                TextField(
                    layer=self.text_layer_pt,
                    contents=f'{self.layout.power}/'
                             f'{self.layout.toughness}'))

    """
    * Hook Methods
    """

    def hook_large_mana(self) -> None:
        """Adjust mana cost position for large symbols."""
        self.text_layer_mana.translate(0, -5)