"""Anki flashcard generator for Polish islands.

Generates Anki-compatible flashcard decks with maps showing islands
highlighted on a Poland map.
"""

from __future__ import annotations

import argparse
import hashlib
from io import BytesIO
import multiprocessing as mp
from pathlib import Path
import secrets
import sys
import tempfile
from typing import TYPE_CHECKING, Any

import genanki
import geopandas as gpd
import matplotlib as mpl

mpl.use("Agg")  # Non-interactive backend for multiprocessing
import matplotlib.pyplot as plt

sys.path.insert(0, str(Path(__file__).parent.parent))
from geo_data import get_poland_boundary, get_polish_islands

if TYPE_CHECKING:
    from collections.abc import Sequence

    from matplotlib.figure import Figure

ISLAND_COLOR = "#E67E22"  # Orange for islands
NEIGHBOR_COLOR = "#EAECEE"  # Lighter gray for extended view

# Padding for zoom (in degrees)
ZOOM_PADDING_DEG = 0.2


def _island_extends_beyond(
    island_gdf: gpd.GeoDataFrame,
    poland_boundary: gpd.GeoDataFrame,
) -> bool:
    """Check if island extends beyond Poland's boundaries."""
    poland_bounds = poland_boundary.total_bounds  # [minx, miny, maxx, maxy]
    island_bounds = island_gdf.total_bounds

    # Check if any part of island is outside Poland
    extends_west = island_bounds[0] < poland_bounds[0]
    extends_south = island_bounds[1] < poland_bounds[1]
    extends_east = island_bounds[2] > poland_bounds[2]
    extends_north = island_bounds[3] > poland_bounds[3]

    return extends_west or extends_south or extends_east or extends_north


def create_island_map(
    island_gdf: gpd.GeoDataFrame,
    poland_boundary: gpd.GeoDataFrame,
    *,
    zoom: bool,
) -> Figure:
    """Create a map showing Poland with one island highlighted.

    Args:
        island_gdf: GeoDataFrame with the island to highlight.
        poland_boundary: GeoDataFrame with Poland's boundary.
        zoom: If True, zoom to island area for better visibility.
    """
    fig, ax = plt.subplots(figsize=(10, 12))
    ax.set_aspect("equal")
    ax.axis("off")
    fig.patch.set_alpha(0)
    ax.patch.set_alpha(0)

    extends_beyond = _island_extends_beyond(island_gdf, poland_boundary)

    if extends_beyond:
        # Draw extended background if island goes beyond Poland
        island_bounds = island_gdf.total_bounds
        padding = 0.5
        ax.fill(
            [
                island_bounds[0] - padding,
                island_bounds[2] + padding,
                island_bounds[2] + padding,
                island_bounds[0] - padding,
            ],
            [
                island_bounds[1] - padding,
                island_bounds[1] - padding,
                island_bounds[3] + padding,
                island_bounds[3] + padding,
            ],
            color=NEIGHBOR_COLOR,
            zorder=0,
        )

    # Plot Poland as a plain gray shape
    poland_boundary.plot(ax=ax, color="#D5D8DC", alpha=0.6)
    poland_boundary.boundary.plot(ax=ax, color="#2C3E50", linewidth=1)

    # Plot the island with thinner lines
    island_gdf.plot(ax=ax, color=ISLAND_COLOR, alpha=0.9)
    island_gdf.boundary.plot(ax=ax, color="#1A1A1A", linewidth=1.5)

    # Set bounds based on zoom mode and whether island extends beyond
    if zoom:
        # Zoom to island area with padding
        island_bounds = island_gdf.total_bounds
        ax.set_xlim(
            island_bounds[0] - ZOOM_PADDING_DEG,
            island_bounds[2] + ZOOM_PADDING_DEG,
        )
        ax.set_ylim(
            island_bounds[1] - ZOOM_PADDING_DEG,
            island_bounds[3] + ZOOM_PADDING_DEG,
        )
    elif extends_beyond:
        # Include the full island in view
        island_bounds = island_gdf.total_bounds
        poland_bounds = poland_boundary.total_bounds
        ax.set_xlim(
            min(poland_bounds[0], island_bounds[0] - 0.1),
            max(poland_bounds[2], island_bounds[2] + 0.1),
        )
        ax.set_ylim(
            min(poland_bounds[1], island_bounds[1] - 0.1),
            max(poland_bounds[3], island_bounds[3] + 0.1),
        )
    else:
        # Normal Poland bounds
        bounds = poland_boundary.total_bounds
        ax.set_xlim(bounds[0], bounds[2])
        ax.set_ylim(bounds[1], bounds[3])

    return fig


def generate_island_image_bytes(
    island_gdf: gpd.GeoDataFrame,
    poland_boundary: gpd.GeoDataFrame,
    *,
    zoom: bool,
) -> bytes:
    """Generate an island map image as bytes."""
    fig = create_island_map(island_gdf, poland_boundary, zoom=zoom)

    buf = BytesIO()
    fig.savefig(buf, format="png", bbox_inches="tight", dpi=150)
    plt.close(fig)
    buf.seek(0)

    return buf.read()


# Multiprocessing shared state (set via initializer)
_mp_state: dict[str, Any] = {}


def _init_worker(poland_geojson: str, zoom_mode: str) -> None:
    """Initialize worker process with shared data."""
    _mp_state["poland_boundary"] = gpd.read_file(poland_geojson)
    _mp_state["zoom_mode"] = zoom_mode


def _render_single_island(args: tuple[str, str]) -> tuple[str, bytes]:
    """Render a single island image (worker function).

    Args:
        args: Tuple of (island_name, island_geojson_str).

    Returns:
        Tuple of (island_name, image_bytes).
    """
    island_name, island_geojson = args
    island_gdf = gpd.read_file(island_geojson)

    if "poland_boundary" not in _mp_state:
        msg = "Worker not initialized"
        raise RuntimeError(msg)

    zoom = _mp_state["zoom_mode"] == "zoom"
    image_data = generate_island_image_bytes(
        island_gdf, _mp_state["poland_boundary"], zoom=zoom
    )
    return island_name, image_data


def generate_anki_package(
    islands: gpd.GeoDataFrame,
    poland_boundary: gpd.GeoDataFrame,
    deck_name: str = "Polish Islands",
    *,
    zoom: bool = True,
) -> genanki.Package:
    """Generate Anki package for Polish islands."""
    model_id_hash = hashlib.sha256(f"polish_islands_{deck_name}".encode())
    model_id = int(model_id_hash.hexdigest()[:8], 16)

    card_css = """
.card {
    font-family: Arial, sans-serif;
    font-size: 24px;
    text-align: center;
    color: #333;
    background-color: #fff;
}
.card.night_mode {
    color: #eee;
    background-color: #2f2f2f;
}
.map-container {
    display: flex;
    justify-content: center;
    align-items: center;
    min-height: 80vh;
}
.map-container img {
    max-width: 100%;
    max-height: 80vh;
    object-fit: contain;
}
.answer-text {
    font-size: 32px;
    font-weight: bold;
    margin-top: 20px;
    color: #2C3E50;
}
.card.night_mode .answer-text {
    color: #ECF0F1;
}
.info-text {
    font-size: 18px;
    color: #7F8C8D;
    margin-top: 10px;
}
.card.night_mode .info-text {
    color: #BDC3C7;
}
"""

    my_model = genanki.Model(
        model_id,
        "Polish Island Model",
        fields=[
            {"name": "IslandMap"},
            {"name": "IslandName"},
            {"name": "Area"},
        ],
        templates=[
            {
                "name": "Card 1",
                "qfmt": '<div class="map-container">{{IslandMap}}</div>',
                "afmt": '<div class="map-container">{{IslandMap}}</div>'
                '<hr id="answer">'
                '<div class="answer-text">{{IslandName}}</div>'
                '<div class="info-text">{{Area}} km²</div>',
            },
        ],
        css=card_css,
    )

    deck_id = secrets.randbelow(1 << 30) + (1 << 30)
    my_deck = genanki.Deck(deck_id, deck_name)
    media_files = []

    # Prepare data for parallel processing
    with tempfile.NamedTemporaryFile(suffix=".geojson", delete=False) as f:
        poland_boundary.to_file(f.name, driver="GeoJSON")
        poland_geojson_path = f.name

    # Prepare work items: (island_name, island_geojson_str)
    work_items: list[tuple[str, str]] = []
    for _, row in islands.iterrows():
        island_gdf = gpd.GeoDataFrame([row], crs=islands.crs)
        island_geojson = island_gdf.to_json()
        work_items.append((row["name"], island_geojson))

    # Use multiprocessing for parallel rendering
    zoom_mode = "zoom" if zoom else "no-zoom"
    num_workers = min(mp.cpu_count(), 8)
    sys.stdout.write(
        f"Rendering {len(work_items)} images using {num_workers} workers...\n"
    )

    results: dict[str, bytes] = {}
    with mp.Pool(
        num_workers,
        initializer=_init_worker,
        initargs=(poland_geojson_path, zoom_mode),
    ) as pool:
        for i, (island_name, image_data) in enumerate(
            pool.imap_unordered(_render_single_island, work_items)
        ):
            results[island_name] = image_data
            if (i + 1) % 10 == 0:
                sys.stdout.write(f"  Rendered {i + 1}/{len(work_items)}...\n")

    # Clean up temp file
    Path(poland_geojson_path).unlink(missing_ok=True)

    # Create notes from results
    for _, row in islands.iterrows():
        island_name = row["name"]
        area_km2 = round(row["area_km2"], 1) if "area_km2" in row else 0
        image_data = results[island_name]
        filename = f"island_{island_name.replace(' ', '_').replace('/', '_')}.png"

        note = genanki.Note(
            model=my_model,
            fields=[f'<img src="{filename}">', island_name, str(area_km2)],
            tags=["geography", "poland", "islands", "coastal"],
        )
        my_deck.add_note(note)

        temp_path = Path(tempfile.gettempdir()) / filename
        temp_path.write_bytes(image_data)
        media_files.append(str(temp_path))

    package = genanki.Package(my_deck)
    package.media_files = media_files
    return package


def main(argv: Sequence[str] | None = None) -> int:
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Generate Anki flashcards for Polish islands.",
    )
    parser.add_argument(
        "--output",
        "-o",
        type=str,
        default=None,
        help="Output file path (default: polish_islands.apkg)",
    )
    parser.add_argument(
        "--deck-name",
        "-d",
        type=str,
        default="Polish Islands",
        help="Name for the Anki deck",
    )
    parser.add_argument(
        "--preview",
        "-p",
        type=str,
        default=None,
        help="Export preview images to specified directory",
    )
    parser.add_argument(
        "--preview-count",
        type=int,
        default=5,
        help="Number of preview images to export (default: 5)",
    )

    args = parser.parse_args(argv)
    output_path = Path(args.output) if args.output else Path("polish_islands.apkg")

    try:
        sys.stdout.write("Loading islands data...\n")
        islands = get_polish_islands()
        poland_boundary = get_poland_boundary()
        num_islands = len(islands)

        sys.stdout.write(f"Found {num_islands} islands.\n")
        sys.stdout.write("Generating flashcards...\n")

        package = generate_anki_package(islands, poland_boundary, args.deck_name)
        package.write_to_file(str(output_path))

        # Export preview images if requested
        if args.preview:
            preview_dir = Path(args.preview)
            preview_dir.mkdir(parents=True, exist_ok=True)
            preview_islands = list(islands.iterrows())[: args.preview_count]
            sys.stdout.write(
                f"Exporting {len(preview_islands)} preview images to {preview_dir}...\n"
            )
            for _, row in preview_islands:
                island_name = row["name"]
                island_gdf = gpd.GeoDataFrame([row], crs=islands.crs)
                image_data = generate_island_image_bytes(
                    island_gdf, poland_boundary, zoom=True
                )
                safe_name = island_name.replace(" ", "_").replace("/", "_")
                preview_path = preview_dir / f"{safe_name}.png"
                preview_path.write_bytes(image_data)
                sys.stdout.write(f"  Saved: {preview_path.name}\n")

        sys.stdout.write("\n")
        sys.stdout.write("=" * 60 + "\n")
        sys.stdout.write("FLASHCARD GENERATION COMPLETE\n")
        sys.stdout.write("=" * 60 + "\n")
        sys.stdout.write(f"Islands: {num_islands}\n")
        sys.stdout.write(f"Output file: {output_path.absolute()}\n")
        if args.preview:
            sys.stdout.write(f"Preview images: {args.preview}\n")
    except (OSError, ValueError, RuntimeError) as e:
        sys.stderr.write(f"Error: {e}\n")
        return 1
    else:
        return 0


if __name__ == "__main__":
    sys.exit(main())
