#!/usr/bin/env python3
import argparse
import pathlib
import os
from typing import MutableMapping
import yaml

CARD_TEMPLATE = \
"""\\documentclass{{standalone}}
\\input{{common.tex}}

\\begin{{document}}
\\begin{{tikzpicture}}
{0}
\\cardborder
\\end{{tikzpicture}}
\\end{{document}}"""

SET_SYMBOLS = {
    'base': 'base',
    'magic': 'magic',
    'equipments': 'equipments',
    'nautics': 'nautics',
    'misc': '',
    'kraken': 'kraken'
}

LATEX_ROOT = pathlib.Path(os.getcwd())
ASSETS_DIR = LATEX_ROOT / '../assets'
CARDS_DIR = LATEX_ROOT / 'cards'

def file_for_card(card_name: str, suffix = '.tex') -> pathlib.Path:
    """Return the corresponding latex file name for a card"""
    return pathlib.Path(f'{card_name.lower().replace(" ", "_")}{suffix}')

def get_latex_field(card: MutableMapping, field: str) -> str:
    """Return the latex_ prefixed field from card or the field itself"""
    latex_field = f'latex_{field}'
    if latex_field in card:
        return card[latex_field]
    else:
        return card[field]

def generate_markdown(card: MutableMapping, indentation=3):
    """Output a markdown enumeration"""

    formatted_keys = {'ai': 'AI', 'full_action': 'Full Action'}

    print(f'{"#" * indentation} {card["name"]}')

    yml_card_path = f'cards-data/{card["set"]}/{file_for_card(card["name"], ".yml")}'
    built_card_path = f'cards/{card["set"]}/{file_for_card(card["name"], "")}'
    print(f'\n[pdf]({built_card_path}.pdf) [png]({built_card_path}.png) [yml]({yml_card_path})\n')

    for key in ['type', 'token', 'buy', 'upkeep', 'play', 'ai', 'health', 'movement', 'attack', 'full_action', 'effect']:
        if key in card:
            formatted_key = formatted_keys.get(key, key.capitalize())
            print(f'* **{formatted_key}**: {card[key]}')

def generate_latex(card: MutableMapping):
    """Generate a standalone tikz picture with the card data"""
    card_content = ""

    card_file = file_for_card(card['name'])

    for ext in ['.jpg', '.png']:
        image_file =  ASSETS_DIR / card_file.with_suffix(ext)
        if image_file.exists():
            card_content += f'\\cardbackground{{{image_file.name}}}\n'
            break

    card_content += f'\cardtype{card["type"].capitalize()}{"Token" if "token" in card else ""}{{{card["name"]}}}\n'

    if 'buy' in card:
        card_content += f'\cardbuycost{{{card["buy"]}}}\n'

    if card['type'] == 'unit':
        stats = []
        abilities = []
        if 'ai' in card:
            stats.append(f'AI: {card["ai"]}')

        if 'health' in card:
            stats.append(f'Health: {card["health"]}')

        if 'movement' in card:
            stats.append(f'Movement: {card["movement"]}')

        attack = card.get('attack', None)
        if attack:
            # attack_sym = '\\faFistRaised'
            # if "Range" in attack:
                # attack_sym = '\\ding{246}'
            stats.append(f'Attack: {attack}')

        if 'effect' in card:
            abilities.append(get_latex_field(card, 'effect'))

        if 'full_action' in card:
            if 'latex_full_action' in card:
                abilities.append(f'{card["latex_full_action"]}')
            else:
                abilities.append(f'\\faRedo: {card["full_action"]}')

        stats_str = '\\\\'.join(stats)
        ability_block = '\\\\ \\vspace{0.2cm} '.join(abilities)
        if stats and abilities:
            card_content += f'\cardsplitcontent{{{stats_str}}}{{{ability_block}}}'
        elif stats:
            card_content += f'\cardcontent{{{stats_str}}}'

        card_content += '\n'

        if 'upkeep' in card:
            card_content += f'\cardplaycost{{{card["upkeep"]}}}'

    elif card['type'] in ['spell', 'artifact']:
        effect = get_latex_field(card, 'effect')
        assert effect is not None
        card_content += f'\cardcontent{{{effect}}}\n'

    elif card['type'] == 'equipment':
        stats = f'Durability: {card["durability"]}'
        effect = get_latex_field(card, 'effect')
        card_content += f'\cardsplitcontent{{{stats}}}{{{effect}}}\n'
    else:
        print(f'WARNING: unknown card type {card["type"]}!')

    if 'play' in card:
        card_content += f'\cardplaycost{{{card["play"]}}}\n'

    if card['set'] in SET_SYMBOLS:
        card_content += f'\cardmodule{{{SET_SYMBOLS[card["set"]]}}}'
    else:
        print(f'WARNING unknown set: {card["set"]}')

    set_dir = CARDS_DIR / card['set']
    if not set_dir.exists():
        set_dir.mkdir(parents=True)

    with open(set_dir / card_file, 'w') as tex_file:
        print(CARD_TEMPLATE.format(card_content), file=tex_file)


def main():
    """Generate one standalone tikz picture for each card in the input data"""

    parser = argparse.ArgumentParser(description='generate latex standalone cards')
    parser.add_argument('data', help='yaml file or directory containing yaml files defining the cards to generate')
    parser.add_argument('--latex-root', help='path to the latex root directory')
    parser.add_argument('--format', choices=['latex', 'markdown'], default='latex', help='output format')

    args = parser.parse_args()

    if args.latex_root:
        global LATEX_ROOT
        LATEX_ROOT = pathlib.Path(args.latex_root)
        global CARDS_DIR
        CARDS_DIR = LATEX_ROOT / 'cards'
        global ASSETS_DIR
        ASSETS_DIR = LATEX_ROOT / '../assets'


    data_files = [args.data]
    data_path = pathlib.Path(args.data)
    if data_path.is_dir():
        data_files = data_path.glob('*.yml')
        card_set = data_path.stem
    else:
        card_set = data_path.parent.stem

    for f in data_files:
        with open(f, 'r') as yaml_file:
            card = yaml.full_load(yaml_file)

        card['set'] = card_set
        if args.format == 'latex':
            generate_latex(card)
        elif args.format == 'markdown':
            generate_markdown(card)


if __name__ == '__main__':
    main()