#!/usr/bin/env python3
"""
Deck builder for MTG Commander decks from existing collections.
"""

import argparse
import json
import os
from collections import Counter
from typing import List, Dict, Optional


def load_collection(collection_path: str) -> List[dict]:
    """Load hydrated collection from JSON file."""
    with open(collection_path, "r", encoding="utf-8") as f:
        return json.load(f)


def load_multiple_collections(collection_paths: List[str]) -> List[dict]:
    """Load and merge multiple collection files."""
    all_cards = []

    for path in collection_paths:
        cards = load_collection(path)
        all_cards.extend(cards)

    # Merge cards with same name by summing counts
    merged_cards = {}
    for card in all_cards:
        name = card["name"]
        if name in merged_cards:
            merged_cards[name]["count"] += card.get("count", 1)
        else:
            merged_cards[name] = card.copy()

    return list(merged_cards.values())


def analyze_collection(cards: List[dict]) -> Dict:
    """Analyze collection statistics."""
    colors = Counter()
    types = Counter()
    cmc_dist = Counter()

    for card in cards:
        # Count colors
        for color in card.get("color_identity", []):
            colors[color] += card.get("count", 1)

        # Count types
        type_line = card.get("type_line", "")
        if "Creature" in type_line:
            types["creatures"] += card.get("count", 1)
        elif "Instant" in type_line:
            types["instants"] += card.get("count", 1)
        elif "Sorcery" in type_line:
            types["sorceries"] += card.get("count", 1)
        elif "Artifact" in type_line:
            types["artifacts"] += card.get("count", 1)
        elif "Enchantment" in type_line:
            types["enchantments"] += card.get("count", 1)
        elif "Land" in type_line:
            types["lands"] += card.get("count", 1)

        # Count CMC
        cmc = card.get("cmc")
        if cmc:
            cmc_dist[int(cmc)] += card.get("count", 1)

    return {
        "colors": dict(colors),
        "types": dict(types),
        "cmc_distribution": dict(cmc_dist),
        "total_cards": sum(card.get("count", 1) for card in cards),
        "unique_cards": len(cards),
    }


def find_commanders(cards: List[dict]) -> List[dict]:
    """Find potential commander cards in collection."""
    commanders = []
    for card in cards:
        type_line = card.get("type_line", "")
        if "Legendary" in type_line and (
            "Creature" in type_line or "Planeswalker" in type_line
        ):
            commanders.append(card)
    return commanders


def score_commander(commander: dict, collection_stats: Dict) -> float:
    """Score commander based on collection support."""
    color_identity = commander.get("color_identity", [])
    score = 0.0

    # Score based on color support
    total_colors = sum(collection_stats["colors"].values())
    if total_colors > 0:
        color_support = sum(
            collection_stats["colors"].get(c, 0) for c in color_identity
        )
        score += (color_support / total_colors) * 100

    # Bonus for multi-color commanders with good support
    if len(color_identity) > 1:
        score += 10

    return score


def suggest_commanders(cards: List[dict]) -> List[dict]:
    """Suggest top commanders from collection."""
    commanders = find_commanders(cards)
    if not commanders:
        return []

    stats = analyze_collection(cards)
    scored = [(score_commander(cmd, stats), cmd) for cmd in commanders]
    scored.sort(reverse=True, key=lambda x: x[0])

    return [cmd for (score, cmd) in scored[:5]]


def is_basic_land(card: dict) -> bool:
    """Check if a card is a basic land."""
    name = card.get("name", "")
    return name in ["Plains", "Island", "Swamp", "Mountain", "Forest"]


def balance_mana_curve(cards: List[dict], target_slots: int) -> List[dict]:
    """Balance mana curve for non-land cards."""
    # Group cards by CMC
    cmc_groups = {}
    for card in cards:
        cmc = card.get("cmc", 0)
        if cmc not in cmc_groups:
            cmc_groups[cmc] = []
        cmc_groups[cmc].append(card)

    # Target distribution (CMC: target count)
    # This follows typical Commander mana curve recommendations
    target_dist = {
        1: 8,  # 1-drops
        2: 12,  # 2-drops
        3: 10,  # 3-drops
        4: 8,  # 4-drops
        5: 6,  # 5-drops
        6: 4,  # 6-drops
        7: 2,  # 7+ drops (combined)
    }

    selected_cards = []
    remaining_slots = target_slots

    # Distribute cards according to target curve
    for cmc, target_count in sorted(target_dist.items()):
        if cmc == 7:
            # Handle 7+ CMC cards together
            available_cards = []
            for higher_cmc in sorted(cmc_groups.keys()):
                if higher_cmc >= 7:
                    available_cards.extend(cmc_groups[higher_cmc])
        else:
            available_cards = cmc_groups.get(cmc, [])

        # Calculate how many we can take from this CMC group
        slots_for_cmc = min(target_count, len(available_cards), remaining_slots)

        if slots_for_cmc > 0:
            # Take the first N cards (already sorted by CMC)
            selected_cards.extend(available_cards[:slots_for_cmc])
            remaining_slots -= slots_for_cmc

        if remaining_slots <= 0:
            break

    # If we still have slots, fill with remaining cards
    if remaining_slots > 0:
        # Get all remaining cards not yet selected
        remaining_cards = []
        for cmc, card_list in cmc_groups.items():
            if cmc < 7:  # We already handled 7+ above
                remaining_cards.extend(
                    card_list[
                        sorted(target_dist.items()).index((cmc, target_dist[cmc]))
                        if cmc in target_dist
                        else 0 :
                    ]
                )

        # Add remaining cards until we fill all slots
        fill_cards = remaining_cards[:remaining_slots]
        selected_cards.extend(fill_cards)

    return selected_cards


def select_lands(
    valid_cards: List[dict], color_identity: List[str], target_land_count: int = 38
) -> List[dict]:
    """Select lands with priority for basic lands and color fixing."""
    basic_lands = []
    color_fixing_lands = []
    other_lands = []

    # Categorize lands
    for card in valid_cards:
        if "Land" not in card.get("type_line", ""):
            continue

        if is_basic_land(card):
            basic_lands.append(card)
        elif any(
            color in card.get("name", "").lower()
            for color in ["plains", "island", "swamp", "mountain", "forest"]
        ):
            # Dual lands, shock lands, etc.
            color_fixing_lands.append(card)
        else:
            other_lands.append(card)

    selected_lands = []
    land_count = 0

    # Add basic lands first
    for land in basic_lands:
        if land_count >= target_land_count:
            break

        # Check if this basic land produces a color in our identity
        land_color = None
        if land["name"] == "Plains":
            land_color = "W"
        elif land["name"] == "Island":
            land_color = "U"
        elif land["name"] == "Swamp":
            land_color = "B"
        elif land["name"] == "Mountain":
            land_color = "R"
        elif land["name"] == "Forest":
            land_color = "G"

        if land_color and land_color in color_identity:
            count = min(land.get("count", 1), target_land_count - land_count)
            if count > 0:
                selected_lands.append(land)
                land_count += count

    # Add color-fixing lands
    for land in color_fixing_lands:
        if land_count >= target_land_count:
            break

        count = min(land.get("count", 1), target_land_count - land_count)
        if count > 0:
            selected_lands.append(land)
            land_count += count

    # Add other lands if needed
    for land in other_lands:
        if land_count >= target_land_count:
            break

        count = min(land.get("count", 1), target_land_count - land_count)
        if count > 0:
            selected_lands.append(land)
            land_count += count

    return selected_lands


def generate_deck(commander: dict, cards: List[dict]) -> Dict:
    """Generate a decklist based on chosen commander."""
    color_identity = commander.get("color_identity", [])
    deck_cards = []

    # Add commander
    deck_cards.append({"name": commander["name"], "count": 1, "data": commander})

    # Filter cards matching color identity
    valid_cards = []
    for card in cards:
        if card["name"] == commander["name"]:
            continue  # Skip commander in main deck

        card_colors = card.get("color_identity", [])
        # Check if card colors are subset of commander colors
        if all(c in color_identity for c in card_colors):
            valid_cards.append(card)

    # Select lands using improved logic
    selected_lands = select_lands(valid_cards, color_identity)

    # Get non-land cards
    land_names = {land["name"] for land in selected_lands}
    non_land_cards = [c for c in valid_cards if c["name"] not in land_names]

    # Balance mana curve for non-land cards (target 61 cards)
    balanced_non_lands = balance_mana_curve(non_land_cards, 61)

    # Add lands to deck
    for land in selected_lands:
        count = land.get("count", 1)
        deck_cards.append({"name": land["name"], "count": count, "data": land})

    # Add non-land cards to deck
    for card in balanced_non_lands:
        count = card.get("count", 1)
        deck_cards.append({"name": card["name"], "count": count, "data": card})

    return {
        "name": f"{commander['name']} Deck",
        "commander": commander["name"],
        "colors": color_identity,
        "archetype": "Auto-generated",
        "cards": {card["name"]: card["count"] for card in deck_cards},
    }


def save_deck(deck: Dict, output_dir: str = "data/decks") -> str:
    """Save deck to JSON file."""
    os.makedirs(output_dir, exist_ok=True)

    # Create safe filename
    commander_name = (
        deck["commander"].replace(" ", "_").replace(",", "").replace("'", "")
    )
    filename = f"{commander_name}.json"
    filepath = os.path.join(output_dir, filename)

    with open(filepath, "w", encoding="utf-8") as f:
        json.dump(deck, f, indent=2)

    return filepath


def main():
    parser = argparse.ArgumentParser(
        description="Build MTG Commander decks from collection"
    )
    parser.add_argument(
        "--collection",
        nargs="+",
        required=True,
        help="Path(s) to hydrated collection JSON file(s)",
    )
    parser.add_argument("--name", help="Deck name (defaults to commander name)")
    parser.add_argument("--commander", help="Specific commander to use")
    parser.add_argument(
        "--list-commanders", action="store_true", help="List suggested commanders"
    )
    parser.add_argument(
        "--output-dir", default="data/decks", help="Output directory for deck files"
    )

    args = parser.parse_args()

    # Load collection(s)
    if isinstance(args.collection, list) and len(args.collection) > 1:
        cards = load_multiple_collections(args.collection)
    else:
        cards = load_collection(
            args.collection[0] if isinstance(args.collection, list) else args.collection
        )

    if args.list_commanders:
        commanders = suggest_commanders(cards)
        print(f"Found {len(commanders)} potential commanders:")
        for i, cmd in enumerate(commanders, 1):
            colors = "".join(cmd.get("color_identity", []))
            print(f"{i}. {cmd['name']} ({colors})")
        return

    # Find or select commander
    if args.commander:
        # Find specific commander
        commanders = [c for c in cards if c["name"] == args.commander]
        if not commanders:
            print(f"Error: Commander '{args.commander}' not found in collection")
            return
        commander = commanders[0]
    else:
        # Suggest and use top commander
        commanders = suggest_commanders(cards)
        if not commanders:
            print("Error: No suitable commanders found in collection")
            return
        commander = commanders[0]
        print(f"Using suggested commander: {commander['name']}")

    # Generate deck
    deck = generate_deck(commander, cards)

    # Customize deck name if provided
    if args.name:
        deck["name"] = args.name

    # Save deck
    filepath = save_deck(deck, args.output_dir)
    print(f"Deck saved to: {filepath}")
    print(f"\nDeck Summary:")
    print(f"  Name: {deck['name']}")
    print(f"  Commander: {deck['commander']}")
    print(f"  Colors: {', '.join(deck['colors'])}")
    print(f"  Total cards: {sum(deck['cards'].values())}")
    print(f"  Unique cards: {len(deck['cards'])}")


if __name__ == "__main__":
    main()