NormalLayout¶

class NormalLayout:
    """Defines unified properties for all cards and serves as the layout for any M15 style typical card."""
    card_class: str = LayoutType.Normal

    # Static properties
    is_transform: bool = False
    is_mdfc: bool = False

    def __init__(self, scryfall: dict, file: dict):

        # Establish core properties
        self._file = file
        self._scryfall = scryfall

        # Cache set data and frame data
        _ = self.set_data
        _ = self.frame

    def __str__(self):
        """String representation of the card layout object."""
        return (f"{self.name}"
                f"{f' [{self.set}]' if self.set else ''}"
                f"{f' {{{self.collector_number_raw}}}' if self.collector_number else ''}")

    """
    * Core Data
    """

    @cached_property
    def file(self) -> CardDetails:
        """Dictionary containing parsed art file details."""
        return self._file

    @cached_property
    def scryfall(self) -> dict:
        """Card data fetched from Scryfall."""
        return self._scryfall

    @cached_property
    def template_file(self) -> Path:
        """Template PSD file path, replaced before render process."""
        return PATH.TEMPLATES / 'normal.psd'

    @cached_property
    def art_file(self) -> Path:
        """Path: Art image file path."""
        return self.file['file']

    @cached_property
    def scryfall_scan(self) -> str:
        """Scryfall large image scan, if available."""
        return self.card.get('image_uris', {}).get('large', '')

    """
    * Set Data
    """

    @cached_property
    def set(self) -> str:
        """Card set code, uppercase enforced, falls back to 'MTG' if missing."""
        return self.scryfall.get('set', 'MTG').upper()

    @cached_property
    def set_data(self) -> dict:
        """Set data from the current hexproof.io data file."""
        return CON.set_data.get(self.scryfall.get('set', 'mtg').lower(), {})

    @cached_property
    def set_type(self) -> str:
        """str: Type of set the card was printed in, e.g. promo, draft_innovation, etc."""
        return self.scryfall.get('set_type', '')

    @cached_property
    def date(self) -> date:
        """date: The date this card was released."""
        _released = self.scryfall.get('released_at')
        if not _released:
            return date.today()
        return datetime.strptime(_released, '%Y-%m-%d').date()

    """
    * Gameplay Info
    """

    @cached_property
    def card(self) -> dict:
        """Main card data object to pull most relevant data from."""
        for i, face in enumerate(self.scryfall.get('card_faces', [])):
            # Card with multiple faces, first index is always front side
            if normalize_str(face['name']) == normalize_str(self.input_name):
                return face

        # Treat single face cards as front
        return self.scryfall

    @cached_property
    def first_print(self) -> dict:
        """Card data fetched from Scryfall representing the first print of this card."""
        first = get_cards_oracle(self.scryfall.get('oracle_id', ''))
        return first[0] if first else {}

    """
    * Card Collections
    """

    @cached_property
    def frame_effects(self) -> list[str]:
        """Array of frame effects, e.g. nyxtouched, snow, etc."""
        return self.scryfall.get('frame_effects', [])

    @cached_property
    def keywords(self) -> list[str]:
        """Array of keyword abilities, e.g. Flying, Haste, etc."""
        return self.scryfall.get('keywords', [])

    @cached_property
    def promo_types(self) -> list[str]:
        """list[str]: Promo types this card matches, e.g. stamped, datestamped, etc."""
        return self.scryfall.get('promo_types', [])

    """
    * Text Info
    """

    @cached_property
    def name(self) -> str:
        """Card name, supports alternate language source."""
        return self.card.get('printed_name', self.name_raw) if self.is_alt_lang else self.name_raw

    @cached_property
    def name_raw(self) -> str:
        """Card name, enforced English representation."""
        return self.card.get('name', '')

    @cached_property
    def nickname(self) -> str:
        """Nickname, typically set inside template logic but can be passed in filename."""
        # Todo: Add user-provided text
        return self.card.get('flavor_name', '')

    @cached_property
    def display_name(self) -> str:
        """Card name, GUI appropriate representation."""
        return self.name

    @cached_property
    def input_name(self) -> str:
        """Card name, version provided in art file name."""
        return self.file['name']

    @cached_property
    def mana_cost(self) -> Optional[str]:
        """Scryfall formatted card mana cost."""
        return self.card.get('mana_cost', '')

    @cached_property
    def oracle_text(self) -> str:
        """Card rules text, supports alternate language source."""
        return self.card.get('printed_text', self.oracle_text_raw) if self.is_alt_lang else self.oracle_text_raw

    @cached_property
    def oracle_text_raw(self) -> str:
        """Card rules text, enforced English representation."""
        return self.card.get('oracle_text', '')

    @cached_property
    def flavor_text(self) -> str:
        """Card flavor text, alternate language version shares the same key."""
        return self.card.get('flavor_text', '')

    @cached_property
    def rules_text(self) -> str:
        """Utility definition comprised of rules and flavor text as available."""
        return (self.oracle_text or '') + (self.flavor_text or '')

    @cached_property
    def power(self) -> str:
        """Creature power, if provided."""
        return self.card.get('power', '')

    @cached_property
    def toughness(self) -> str:
        """Creature toughness, if provided."""
        return self.card.get('toughness', '')

    """
    * Card Types
    """

    @cached_property
    def type_line(self) -> str:
        """Card type line, supports alternate language source."""
        return self.card.get('printed_type_line', self.type_line_raw) if self.is_alt_lang else self.type_line_raw

    @cached_property
    def type_line_raw(self) -> str:
        """Card type line, enforced English representation."""
        return self.card.get('type_line', '')

    @cached_property
    def types_raw(self) -> list[str]:
        """List of types extracted from the raw typeline."""
        return self.type_line_raw.replace(' —', '').split(' ')

    @cached_property
    def types(self) -> list[str]:
        """Main cards types represented, e.g. Sorcery, Instant, Creature, etc."""
        return [n for n in self.types_raw if n in CardTypes]

    @cached_property
    def supertypes(self) -> list[str]:
        """Supertypes represented, e.g. Basic, Legendary, Snow, etc."""
        return [n for n in self.types_raw if n in CardTypesSuper]

    @cached_property
    def subtypes(self) -> list[str]:
        """Subtypes represented, e.g. Elf, Human, Goblin, etc."""
        return [
            n for n in self.types_raw
            if n not in self.supertypes
            and n not in self.types
        ]

    """
    * Color Info
    """

    @cached_property
    def color_identity(self) -> list[str]:
        """Commander relevant color identity array, e.g. [W, U]."""
        return self.card.get('color_identity', [])

    @cached_property
    def color_indicator(self) -> str:
        """Color indicator identity array, e.g. [W, U]."""
        return get_ordered_colors(self.card.get('color_indicator', []))

    """
    * Collector Info
    """

    @cached_property
    def symbol_code(self) -> str:
        """Code used to match a symbol to this card's set. Provided by hexproof.io."""
        if CFG.symbol_force_default:
            return CFG.symbol_default.upper()
        return self.set_data.get('code_symbol', 'DEFAULT').upper()

    @cached_property
    def lang(self) -> str:
        """Card print language, uppercase enforced, falls back to settings defined value."""
        return self.scryfall.get('lang', CFG.lang).upper()

    @cached_property
    def rarity(self) -> str:
        """Card rarity, interprets 'special' rarities based on card data."""
        return self.rarity_raw if self.rarity_raw in [
            Rarity.C, Rarity.U, Rarity.R, Rarity.M, Rarity.T
        ] else get_special_rarity(self.rarity_raw, self.scryfall)

    @cached_property
    def rarity_raw(self) -> str:
        """Card rarity, doesn't interpret 'special' rarities."""
        return self.scryfall.get('rarity', Rarity.C)

    @cached_property
    def rarity_letter(self) -> str:
        """First letter of card rarity, uppercase enforced."""
        return self.rarity[0].upper()

    @cached_property
    def artist(self) -> str:
        """Card artist name, prioritizes user provided artist name. Controls for duplicate last names."""
        if self.file.get('artist'):
            return self.file['artist']

        # Check for duplicate last names
        artist, count = self.card.get('artist', 'Unknown'), []
        if '&' in artist:
            for w in artist.split(' '):
                if w in count:
                    count.remove(w)
                count.append(w)
            return ' '.join(count)
        return artist

    @cached_property
    def collector_number(self) -> int:
        """int: Card number assigned within release set. Non-digit characters are ignored, falls back to 0."""
        if self.collector_number_raw:
            return int(''.join(char for char in self.collector_number_raw if char.isdigit()))
        return 0

    @cached_property
    def collector_number_raw(self) -> Optional[str]:
        """str | None: Card number assigned within release set. Raw string representation, allows non-digits."""
        return self.scryfall.get('collector_number')

    @cached_property
    def card_count(self) -> Optional[int]:
        """int | None: Number of cards within the card's release set. Only required in 'Normal' Collector Mode."""

        # Skip if collector mode doesn't require it or if collector number is bad
        if CFG.collector_mode != CollectorMode.Normal or not self.collector_number_raw:
            return

        # Prefer printed count, fallback to card count, skip if count isn't found
        count = self.set_data.get('count_printed', self.set_data.get('count_cards'))
        if count is None:
            return

        # Skip if count is smaller than collector number
        return count if int(count) >= self.collector_number else None

    @cached_property
    def collector_data(self) -> str:
        """str: Formatted collector info line, e.g. 050/230 M."""
        if self.card_count:
            return f"{str(self.collector_number).zfill(3)}/{str(self.card_count).zfill(3)} {self.rarity_letter}"
        if self.collector_number_raw:
            return f"{self.rarity_letter} {str(self.collector_number).zfill(4)}"
        return ''

    @cached_property
    def creator(self) -> str:
        """str: Optional creator string provided by user in art file name."""
        return self.file.get('creator', '')

    """
    * Symbols
    """

    @cached_property
    def symbol_svg(self) -> Optional[Path]:
        """SVG path definition for card's expansion symbol."""

        # If code is default, perform replacement and check if we have a local asset first
        if self.symbol_code == 'DEFAULT':
            if not CFG.symbol_force_default:
                path = (PATH.SRC_IMG_SYMBOLS / 'set' / self.set / self.rarity_letter).with_suffix('.svg')
                if path.is_file():
                    return path
            self.symbol_code = CFG.symbol_default.upper()

        # Does SVG exist?
        path = (PATH.SRC_IMG_SYMBOLS / 'set' / self.symbol_code / self.rarity_letter).with_suffix('.svg')
        if path.is_file():
            return path

        # Revert to mythic for special rarities
        if self.rarity not in [Rarity.C, Rarity.U, Rarity.R, Rarity.M]:
            path = (PATH.SRC_IMG_SYMBOLS / 'set' / self.symbol_code / 'M').with_suffix('.svg')
            if path.is_file():
                return path

        # Revert to default symbol or None
        path = (PATH.SRC_IMG_SYMBOLS / 'set' / 'DEFAULT' / self.rarity_letter).with_suffix('.svg')
        if path.is_file():
            return path
        return

    @cached_property
    def watermark(self) -> Optional[str]:
        """Name of the card's watermark file that is actually used, if provided."""
        if not self.watermark_svg:
            return
        if self.watermark_svg.stem.upper() == 'WM':
            return self.watermark_svg.parent.stem.lower()
        return self.watermark_svg.stem.lower()

    @cached_property
    def watermark_raw(self) -> Optional[str]:
        """Name of the card's watermark from raw Scryfall data, if provided."""
        return self.card.get('watermark')

    @cached_property
    def watermark_svg(self) -> Optional[Path]:
        """Path to the watermark SVG file, if provided."""
        def _find_watermark_svg(wm: str) -> Optional[Path]:
            """Try to find a watermark SVG asset, allowing for special cases and set code fallbacks.

            Args:
                wm: Watermark name or set code to look for.

            Returns:
                Path to a watermark SVG file if found, otherwise None.

            Notes:
                - 'set' maps to the symbol collection of the set this card was first printed in.
                - 'symbol' maps to the symbol collection of this card object's set.
            """
            if not wm:
                return
            wm = wm.lower()

            # Special case watermarks
            if wm in ['set', 'symbol']:
                return get_watermark_svg_from_set(
                    self.first_print.get('set', self.set) if wm == 'set' else self.set)

            # Look for normal watermark
            return get_watermark_svg(wm)

        # WatermarkMode: Disabled or Forced
        if CFG.watermark_mode == WatermarkMode.Disabled:
            return
        elif CFG.watermark_mode == WatermarkMode.Forced:
            return _find_watermark_svg(CFG.watermark_default)

        # WatermarkMode: Automatic
        path = _find_watermark_svg(self.watermark_raw)
        if path or CFG.watermark_mode == WatermarkMode.Automatic:
            return path

        # WatermarkMode: Fallback
        return _find_watermark_svg(CFG.watermark_default)

    @cached_property
    def watermark_basic(self) -> Optional[Path]:
        """Optional[Path]: Path to basic land watermark, if card is a Basic Land."""
        if not self.is_basic_land:
            return

        # Map pinlines to basic land type
        _map = {
            'W': 'plains',
            'U': 'island',
            'B': 'swamp',
            'R': 'mountain',
            'G': 'forest',
            'Land': 'wastes'}
        if basic_type := _map.get(self.pinlines):
            return (PATH.SRC_IMG_SYMBOLS / 'watermark' / basic_type).with_suffix('.svg')
        return

    """
    * Bool Properties
    """

    @cached_property
    def is_creature(self) -> bool:
        """True if card is a Creature."""
        return bool(self.power and self.toughness)

    @cached_property
    def is_land(self) -> bool:
        """True if card is a Land."""
        return 'Land' in self.type_line_raw

    @cached_property
    def is_basic_land(self) -> bool:
        """True if card is a Basic Land."""
        return self.type_line_raw.startswith('Basic')

    @cached_property
    def is_legendary(self) -> bool:
        """True if card is Legendary."""
        return 'Legendary' in self.type_line_raw

    @cached_property
    def is_colorless(self) -> bool:
        """True if card is colorless or devoid."""
        return self.frame['is_colorless']

    @cached_property
    def is_hybrid(self) -> bool:
        """True if card is a hybrid frame."""
        return self.frame['is_hybrid']

    @cached_property
    def is_artifact(self) -> bool:
        """True if card is an Artifact."""
        return 'Artifact' in self.type_line_raw

    @cached_property
    def is_vehicle(self) -> bool:
        """True if card is a Vehicle."""
        return 'Vehicle' in self.type_line_raw

    @cached_property
    def is_promo(self) -> bool:
        """True if card is a promotional print."""
        if self.scryfall.get('promo', False):
            return True
        if self.set_type == 'promo':
            return True
        if self.promo_types:
            return True
        return False

    @cached_property
    def is_front(self) -> bool:
        """True if card is front face."""
        return bool(self.scryfall.get('front', True))

    @cached_property
    def is_alt_lang(self) -> bool:
        """True if language selected isn't English."""
        return bool(self.lang != 'EN')

    """
    * Cosmetic Bool
    """

    @cached_property
    def is_token(self) -> bool:
        """bool: True if card is a Token or Emblem."""
        return bool('Token' in self.type_line_raw or self.is_emblem)

    @cached_property
    def is_emblem(self) -> bool:
        """bool: True on card is an Emblem."""
        return bool('Emblem' in self.type_line_raw)

    @cached_property
    def is_nyx(self) -> bool:
        """True if card has Nyx enchantment background texture."""
        if 'nyxtouched' in self.frame_effects:
            return True
        # Nyxtouched often not provided, check for 'Enchantment Creature'
        return bool(self.is_creature and 'Enchantment' in self.type_line_raw)

    @cached_property
    def is_companion(self) -> bool:
        """True if card is a Companion."""
        return "companion" in self.frame_effects

    @cached_property
    def is_miracle(self) -> bool:
        """True if card is a 'Miracle' card."""
        return bool("Miracle" in self.frame_effects)

    @cached_property
    def is_snow(self) -> bool:
        """True if card is a 'Snow' card."""
        return bool('Snow' in self.type_line_raw)

    """
    * Frame Details
    """

    @cached_property
    def frame(self) -> FrameDetails:
        """Dictionary containing calculated frame information."""
        return get_frame_details(self.card)

    @cached_property
    def twins(self) -> str:
        """Identity of the name and title boxes."""
        return self.frame['twins']

    @cached_property
    def pinlines(self) -> str:
        """Identity of the pinlines."""
        return self.frame['pinlines']

    @cached_property
    def background(self) -> str:
        """Identity of the background."""
        return self.frame['background']

    @cached_property
    def identity(self) -> str:
        """Frame appropriate color identity of the card."""
        return self.frame['identity']

    """
    * Opposing Face Properties
    """

    @cached_property
    def transform_icon(self) -> str:
        """Transform icon if provided, data possibly deprecated in modern practice."""
        for effect in self.frame_effects:
            if effect in TransformIcons:
                return effect
        # Cover special Havengul Lab case
        if self.scryfall.get('oracle_id') == 'e71ac446-02a4-4468-8d29-f28b21617665':
            return TransformIcons.UPSIDEDOWN
        # All other cards use the triangle (originally: `convertdfc`)
        return TransformIcons.CONVERT

    @cached_property
    def other_face(self) -> dict:
        """Card data from opposing face if provided."""
        for face in self.scryfall.get('card_faces', []):
            if face.get('name') != self.name_raw:
                return face
        return {}

    @cached_property
    def other_face_frame(self) -> Union[FrameDetails, dict]:
        """Calculated frame information of opposing face, if provided."""
        return get_frame_details(self.other_face) if self.other_face else {}

    @cached_property
    def other_face_twins(self) -> str:
        """Name and title box identity of opposing face."""
        return self.other_face_frame.get('twins', '')

    @cached_property
    def other_face_mana_cost(self) -> str:
        """Mana cost of opposing face."""
        return self.other_face.get('mana_cost', '')

    @cached_property
    def other_face_type_line(self) -> str:
        """Type line of opposing face."""
        return self.other_face.get('type_line', '')

    @cached_property
    def other_face_type_line_raw(self) -> str:
        """Type line of opposing face, English language enforced."""
        if self.is_alt_lang:
            return self.other_face.get('printed_type_line', self.other_face_type_line)
        return self.other_face_type_line

    @cached_property
    def other_face_oracle_text(self) -> str:
        """Rules text of opposing face."""
        if self.is_alt_lang:
            return self.other_face.get('printed_text', self.other_face_oracle_text_raw)
        return self.other_face_oracle_text_raw

    @cached_property
    def other_face_oracle_text_raw(self) -> str:
        """Rules text of opposing face."""
        return self.other_face.get('oracle_text', '')

    @cached_property
    def other_face_power(self) -> str:
        """Creature power of opposing face, if provided."""
        return self.other_face.get('power', '')

    @cached_property
    def other_face_toughness(self) -> str:
        """Creature toughness of opposing face, if provided."""
        return self.other_face.get('toughness', '')

    @cached_property
    def other_face_left(self) -> Optional[str]:
        """Abridged type of the opposing side to display on bottom MDFC bar."""
        return self.other_face_type_line_raw.split(' ')[-1] if self.other_face else ''

    @cached_property
    def other_face_right(self) -> str:
        """Mana cost or mana ability of opposing side, depending on land or nonland."""
        if not self.other_face:
            return ''

        # Other face is not a land
        if 'Land' not in self.other_face_type_line_raw:
            return self.other_face_mana_cost

        # Other face is a land, find the mana tap ability
        for line in self.other_face_oracle_text.split('\n'):
            if line.startswith('{T}'):
                return f"{line.split('.')[0]}."
        return self.other_face_oracle_text