"""CLI entry point for the PokeDB import tool.

Usage:
    # From tools/import-pokedb/ (auto-downloads PokeDB data on first run):
    python -m import_pokedb

    # With options:
    python -m import_pokedb --game firered
    python -m import_pokedb --pokedb-dir ~/my-pokedb-data/
    python -m import_pokedb --output /tmp/seed-output/
"""

from __future__ import annotations

import argparse
import sys
from pathlib import Path

from .loader import load_pokedb_data, load_seed_config
from .mappings import PokemonMapper, LocationMapper, build_version_map, map_encounter_method

SEEDS_DIR_CANDIDATES = [
    Path("backend/src/app/seeds"),                # from repo root
    Path("../../backend/src/app/seeds"),           # from tools/import-pokedb/
]


def find_seeds_dir() -> Path:
    """Locate the backend seeds directory."""
    for candidate in SEEDS_DIR_CANDIDATES:
        if (candidate / "version_groups.json").exists():
            return candidate.resolve()
    # Fallback
    return Path("backend/src/app/seeds").resolve()


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        prog="import-pokedb",
        description="Convert PokeDB.org JSON data exports into nuzlocke-tracker seed format.",
    )
    parser.add_argument(
        "--pokedb-dir",
        type=Path,
        default=None,
        help="Path to directory containing PokeDB JSON export files (default: .pokedb_cache/)",
    )
    parser.add_argument(
        "--output",
        type=Path,
        default=None,
        help="Output directory for seed JSON files (default: backend/src/app/seeds/data/)",
    )
    parser.add_argument(
        "--game",
        type=str,
        default=None,
        help="Generate data for a specific game slug only (default: all games)",
    )
    return parser


def main(argv: list[str] | None = None) -> None:
    parser = build_parser()
    args = parser.parse_args(argv)

    seeds_dir = find_seeds_dir()
    pokedb_dir: Path = args.pokedb_dir or (seeds_dir / ".pokedb_cache")
    output_dir: Path = args.output or (seeds_dir / "data")
    output_dir.mkdir(parents=True, exist_ok=True)

    print(f"PokeDB data:  {pokedb_dir.resolve()}")
    print(f"Seeds config: {seeds_dir}")
    print(f"Output:       {output_dir.resolve()}")
    print()

    # Load PokeDB export data
    pokedb = load_pokedb_data(pokedb_dir)
    print(pokedb.summary())
    print()

    # Load existing seed configuration
    config = load_seed_config(seeds_dir)
    print(f"Loaded {len(config.version_groups)} version groups")
    print(f"Loaded route order for {len(config.route_order)} version groups")
    if config.special_encounters:
        se_count = len(config.special_encounters.get("encounters", {}))
        print(f"Loaded special encounters for {se_count} version groups")
    print()

    # Determine which games to process
    target_game = args.game
    if target_game:
        found = False
        for vg_info in config.version_groups.values():
            if target_game in vg_info.get("versions", []):
                found = True
                break
        if not found:
            print(f"Error: Game '{target_game}' not found in version_groups.json", file=sys.stderr)
            sys.exit(1)
        print(f"Target: {target_game}")
    else:
        total_games = sum(
            len(vg.get("versions", []))
            for vg in config.version_groups.values()
        )
        print(f"Target: all {total_games} games")

    # Build mappings
    print("\nBuilding mappings...")

    pokemon_json = seeds_dir / "data" / "pokemon.json"
    pokemon_mapper = PokemonMapper(pokemon_json, pokedb)

    location_mapper = LocationMapper(pokedb)

    version_map = build_version_map(pokedb, config.version_groups)
    print(f"  Mapped {len(version_map)} PokeDB versions to our game slugs")

    # Report encounter method coverage
    pokedb_methods = {e.get("encounter_method_identifier", "") for e in pokedb.encounters}
    pokedb_methods.discard("")
    mapped_methods = {m for m in pokedb_methods if map_encounter_method(m) is not None}
    unmapped_methods = pokedb_methods - mapped_methods
    print(f"  Encounter methods: {len(mapped_methods)} mapped, {len(unmapped_methods)} unmapped")
    if unmapped_methods:
        print("  Unmapped methods:", file=sys.stderr)
        for m in sorted(unmapped_methods):
            print(f"    - {m}", file=sys.stderr)

    # Spot-check pokemon mapping on actual encounter data
    form_ids_in_encounters = {e.get("pokemon_form_identifier", "") for e in pokedb.encounters}
    form_ids_in_encounters.discard("")
    mapped_forms = 0
    for fid in form_ids_in_encounters:
        if pokemon_mapper.lookup(fid) is not None:
            mapped_forms += 1
    total_forms = len(form_ids_in_encounters)
    print(f"  Pokemon forms: {mapped_forms}/{total_forms} mapped from encounters")

    pokemon_mapper.report_unmapped()

    # TODO: Processing pipeline (subtasks rfg0, gkcy)
    print("\nMappings built. Processing pipeline not yet implemented.")


if __name__ == "__main__":
    main()