"""Convert Unity Tilemap data from SampleScene.unity into LevelTotalData.h.

Workflow:
  1. Parse the Unity scene YAML (no PyYAML dep — pure text scan,
     because the file is huge and uses Unity-specific tags).
  2. For each named Tilemap GameObject (e.g. "foreground", "background"),
     extract:
       - m_TileAssetArray  : ordered list of tile asset GUIDs
       - m_Tiles           : list of (x, y, m_TileIndex)
  3. Map each tile asset GUID -> a project TileId (uint16_t).
  4. Crop to a fixed window (origin + width + height, in Unity cell coords)
     and emit a C++ uint16_t[] array. Unity Y is up; the C++ array is
     row-major with row 0 at the TOP, so we flip Y on output.

Usage:
    python tools/unity_to_level.py

Edit FOREGROUND_GUID_TO_TILEID below to fill in the foreground mapping.
"""

from __future__ import annotations

import os
import re
import sys
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Tuple

# ---------------------------------------------------------------------------
# Configuration
# ---------------------------------------------------------------------------

REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
SCENE_PATH = os.path.join(REPO_ROOT, "SampleScene.unity")
OUTPUT_PATH = os.path.join(
    REPO_ROOT, "src", "Apps", "LightGame", "src", "levels", "LevelTotalData.h"
)

# Crop window in Unity cell coordinates. Aligned to the `background`
# Tilemap's origin (-43, -24). LevelTotal is 96 wide x 54 tall.
CROP_ORIGIN_X = -42
CROP_ORIGIN_Y = -24
CROP_WIDTH = 96
CROP_HEIGHT = 54

# TileId values mirror src/Apps/LightGame/src/engine/TileIds.h
class TileId:
    Empty = 0
    Background1 = 1
    Background2 = 2
    Background3 = 3
    Background4 = 4
    GroundTopGreen = 5
    GroundFillGreen = 6
    GroundTopGray = 7
    GroundFillGray = 8
    GroundTopPurple = 9
    GroundFillPurple = 10
    Platform = 11
    Spike = 12
    LightPlatformOff = 13
    LightPlatformOn = 14
    ShadowPlatformOff = 15
    ShadowPlatformOn = 16
    DoorClosed = 17
    DoorOpen = 18
    Coin = 19
    Flag = 20
    Checkpoint = 21
    SpikeCeiling = 22
    DecorVine = 23

# background Tilemap: m_TileAssetArray order (verified by user).
# Indexes 0..3 in the array correspond to TileId 1..4.
BACKGROUND_GUID_TO_TILEID: Dict[str, int] = {
    "7a416b45749852649890b58c40c94382": TileId.Background1,
    "3e398b33bfe59e8488e6622639e22680": TileId.Background2,
    "9c0d8493a349d2d4c9394cd4db6c144c": TileId.Background3,
    "c311fab5d43fea040b20ddf4109be8d4": TileId.Background4,
}

# foreground Tilemap: m_TileAssetArray order (16 entries in scene).
# >>> FILL THIS IN <<< — map each GUID to the matching TileId.* constant.
# Use TileId.Empty (= 0) to drop a tile, or comment a line out to leave
# it as Empty (the default).
FOREGROUND_GUID_TO_TILEID: Dict[str, int] = {
    "fc664ce3f6082ba478b8d50ca2dce27e": 12,
    "47a0287d160d89e449cfb63ece6bc64d": 10,
    "9c787be8025ad3e4ea41faf8641b6542": 19,
    "d317ceed21dc2844cbe35d377a237065": 9,
    "228f030a961526742ac581cd160291f2": 1,
    "5276bbe304866324fbd94b343f5d5716": 1,
    "47822c4ae0c151848be71ecddbe3e363": 20,
    "9dae7bdac3edf7e4996e186ac7ea8d42": 8,
    "f3c8dcd4899bb144795bf74e61529d57": 6,
    "430a6d0aec468d94d929e481d5082741": 5,
    "dcd1ff73844513940941a7906732f790": 7,
    "8caba5ecd24bd3143831d4f04096921f": 17,
    "c0ea1f55905049745a90ea7d4772f95f": 22,
    "0f7b94bca5b66ea4e8bf37ac8b2c1528": 16,
    "67e0c92da848ffa49b3792338de741ac": 14,
    "1289993ae67654b48a59c5743728e507": 20,
}

# Map Unity GameObject name -> tile id mapping table.
LAYER_MAPPINGS: Dict[str, Dict[str, int]] = {
    "foreground": FOREGROUND_GUID_TO_TILEID,
    "background": BACKGROUND_GUID_TO_TILEID,
}

# ---------------------------------------------------------------------------
# Parser
# ---------------------------------------------------------------------------

@dataclass
class TilemapBlock:
    name: str
    asset_guids: List[str] = field(default_factory=list)  # by m_TileIndex
    cells: List[Tuple[int, int, int]] = field(default_factory=list)  # x, y, idx


# Scene file blocks are separated by lines that start with "--- !u!".
DOC_SEP = re.compile(r"^--- !u!(\d+) &(\d+)", re.MULTILINE)


def split_documents(text: str) -> List[Tuple[int, int, str]]:
    """Return a list of (class_id, file_id, body) for each YAML doc."""
    matches = list(DOC_SEP.finditer(text))
    docs: List[Tuple[int, int, str]] = []
    for i, m in enumerate(matches):
        start = m.end()
        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
        docs.append((int(m.group(1)), int(m.group(2)), text[start:end]))
    return docs


def parse_gameobjects(docs) -> Dict[int, str]:
    """Map GameObject fileID -> name."""
    name_re = re.compile(r"^\s*m_Name:\s*(.+?)\s*$", re.MULTILINE)
    out: Dict[int, str] = {}
    for class_id, file_id, body in docs:
        if class_id != 1:  # GameObject
            continue
        m = name_re.search(body)
        if m:
            out[file_id] = m.group(1)
    return out


GAMEOBJECT_REF_RE = re.compile(r"m_GameObject:\s*\{fileID:\s*(\d+)\}")
TILE_FIRST_RE = re.compile(
    r"-\s*first:\s*\{x:\s*(-?\d+),\s*y:\s*(-?\d+),\s*z:\s*-?\d+\}\s*"
    r"second:\s*\n"
    r"\s*serializedVersion:\s*\d+\s*\n"
    r"\s*m_TileIndex:\s*(-?\d+)"
)
ASSET_ENTRY_RE = re.compile(
    r"-\s*m_RefCount:\s*(-?\d+)\s*\n\s*m_Data:\s*\{fileID:\s*\d+,\s*guid:\s*([0-9a-f]+),"
)


def parse_tilemaps(docs, go_names: Dict[int, str]) -> Dict[str, TilemapBlock]:
    """Find Tilemap docs (class 1839735485) and bucket by parent GO name."""
    out: Dict[str, TilemapBlock] = {}
    for class_id, _file_id, body in docs:
        if class_id != 1839735485:  # Tilemap
            continue
        m = GAMEOBJECT_REF_RE.search(body)
        if not m:
            continue
        go_id = int(m.group(1))
        name = go_names.get(go_id)
        if not name:
            continue

        # Slice out the m_Tiles ... m_AnimatedTiles section so the cell regex
        # only sees real tile entries.
        tiles_start = body.find("m_Tiles:")
        tiles_end = body.find("m_AnimatedTiles", tiles_start if tiles_start >= 0 else 0)
        tiles_body = body[tiles_start:tiles_end] if tiles_start >= 0 else ""

        # Slice the m_TileAssetArray section.
        asset_start = body.find("m_TileAssetArray:")
        asset_end = body.find("m_TileSpriteArray", asset_start if asset_start >= 0 else 0)
        asset_body = body[asset_start:asset_end] if asset_start >= 0 else ""

        # Collect (refcount, guid) entries in their YAML order.
        asset_entries: List[Tuple[int, str]] = []
        for am in ASSET_ENTRY_RE.finditer(asset_body):
            asset_entries.append((int(am.group(1)), am.group(2)))

        # Collect raw cell entries (x, y, raw_idx).
        raw_cells: List[Tuple[int, int, int]] = []
        for tm in TILE_FIRST_RE.finditer(tiles_body):
            raw_cells.append((int(tm.group(1)), int(tm.group(2)), int(tm.group(3))))

        # Unity does NOT renumber m_TileIndex when entries are removed from
        # m_TileAssetArray, so the YAML index of an entry is not necessarily
        # equal to the m_TileIndex referencing it. Reconstruct the mapping
        # by aligning the YAML-order asset entries with the *sorted distinct*
        # m_TileIndex values that share the same refcount/usage-count.
        from collections import Counter as _Counter
        idx_counts = _Counter(c[2] for c in raw_cells)
        sorted_idxs = sorted(idx_counts.keys())

        block = TilemapBlock(name=name)
        if len(sorted_idxs) == len(asset_entries):
            # Pair entries in array order with idx values in ascending order.
            # Sanity-check that refcount matches usage count for each pair.
            for entry, idx in zip(asset_entries, sorted_idxs):
                refcount, guid = entry
                actual = idx_counts[idx]
                if refcount != actual:
                    print(
                        f"  [warn] '{name}' refcount mismatch for guid {guid[:8]}: "
                        f"asset refcount={refcount} but idx={idx} appears {actual} times",
                        file=sys.stderr,
                    )
                # Grow asset_guids so [idx] -> guid works directly.
                while len(block.asset_guids) <= idx:
                    block.asset_guids.append("")
                block.asset_guids[idx] = guid
        else:
            print(
                f"  [warn] '{name}' has {len(asset_entries)} asset entries but "
                f"{len(sorted_idxs)} distinct m_TileIndex values; falling back "
                f"to positional mapping (results may be wrong)",
                file=sys.stderr,
            )
            for entry in asset_entries:
                block.asset_guids.append(entry[1])

        block.cells = raw_cells
        out[name] = block
    return out


# ---------------------------------------------------------------------------
# Conversion
# ---------------------------------------------------------------------------

def block_to_grid(
    block: TilemapBlock,
    guid_to_tile: Dict[str, int],
    origin_x: int,
    origin_y: int,
    width: int,
    height: int,
) -> List[List[int]]:
    """Convert a TilemapBlock to a row-major grid (row 0 = top).

    Cells outside the crop window are dropped. Cells whose tile asset has no
    mapping default to TileId.Empty (and a warning is printed once per GUID).
    """
    grid = [[0 for _ in range(width)] for _ in range(height)]
    unmapped: Dict[str, int] = {}

    for x, y, idx in block.cells:
        if idx < 0 or idx >= len(block.asset_guids):
            continue
        guid = block.asset_guids[idx]
        tile_id = guid_to_tile.get(guid)
        if tile_id is None:
            unmapped[guid] = unmapped.get(guid, 0) + 1
            continue
        if tile_id == 0:
            continue

        col = x - origin_x
        # Unity Y is up; flip so row 0 is the top of the array.
        row = (origin_y + height - 1) - y
        if 0 <= col < width and 0 <= row < height:
            grid[row][col] = tile_id

    if unmapped:
        print(
            f"  [warn] {len(unmapped)} unmapped GUID(s) in '{block.name}' "
            f"(treated as Empty):",
            file=sys.stderr,
        )
        for guid, count in sorted(unmapped.items(), key=lambda kv: -kv[1]):
            print(f"    {guid}  x{count}", file=sys.stderr)

    return grid


# ---------------------------------------------------------------------------
# C++ emitter
# ---------------------------------------------------------------------------

HEADER_TEMPLATE = """#pragma once

#include "LevelData.h"
#include "tile_atlas.h"

namespace LightGame
{{
    namespace LevelTotal
    {{
        static const int32_t kMapWidth = {width};
        static const int32_t kMapHeight = {height};
        static const int32_t kTileSize = 32;

        static const uint16_t tiles[] = {{
{tiles_body}
        }};

        static const uint16_t background_tiles[] = {{
{background_body}
        }};

        static const ObjectSpawn spawns[] = {{
            {{ GameObjectType::Player, 69, 29, 0, 0, TriggerAction::None, 0 }},
        }};

        static const RenderData::Image kAtlas(tile_atlas_pixels, tile_atlas_width, tile_atlas_height);

        static const LevelData data = {{
            tiles,
            kMapWidth,
            kMapHeight,
            kTileSize,
            &kAtlas,
            tile_atlas_columns,
            spawns,
            1,
            nullptr,
            0,
            Math::Vector2Int({spawn_px_x}, {spawn_px_y}),
            0,
            0,
            {bounds_max_x},
            {bounds_max_y},
            background_tiles
        }};
    }}
}}
"""


def format_grid(grid: List[List[int]], indent: str = "            ") -> str:
    rows = []
    for row in grid:
        rows.append(indent + ", ".join(str(v) for v in row) + ",")
    if rows:
        rows[-1] = rows[-1].rstrip(",")
    return "\n".join(rows)


def emit_header(
    fg_grid: List[List[int]],
    bg_grid: List[List[int]],
    width: int,
    height: int,
    tile_size: int = 32,
) -> str:
    spawn_tile_x, spawn_tile_y = 69, 29  # preserved from current LevelTotal
    return HEADER_TEMPLATE.format(
        width=width,
        height=height,
        tiles_body=format_grid(fg_grid),
        background_body=format_grid(bg_grid),
        spawn_px_x=spawn_tile_x * tile_size,
        spawn_px_y=spawn_tile_y * tile_size,
        bounds_max_x=width * tile_size,
        bounds_max_y=height * tile_size,
    )


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------

def main() -> int:
    if not os.path.isfile(SCENE_PATH):
        print(f"scene file not found: {SCENE_PATH}", file=sys.stderr)
        return 1

    with open(SCENE_PATH, "r", encoding="utf-8") as f:
        text = f.read()

    print(f"reading {SCENE_PATH} ({len(text)} bytes)")
    docs = split_documents(text)
    go_names = parse_gameobjects(docs)
    tilemaps = parse_tilemaps(docs, go_names)

    print(f"found Tilemaps: {sorted(tilemaps.keys())}")
    for name, block in tilemaps.items():
        print(f"  {name}: {len(block.cells)} cells, {len(block.asset_guids)} tile assets")

    missing = [n for n in ("foreground", "background") if n not in tilemaps]
    if missing:
        print(f"missing Tilemap layers: {missing}", file=sys.stderr)
        return 1

    fg_grid = block_to_grid(
        tilemaps["foreground"],
        FOREGROUND_GUID_TO_TILEID,
        CROP_ORIGIN_X, CROP_ORIGIN_Y, CROP_WIDTH, CROP_HEIGHT,
    )
    bg_grid = block_to_grid(
        tilemaps["background"],
        BACKGROUND_GUID_TO_TILEID,
        CROP_ORIGIN_X, CROP_ORIGIN_Y, CROP_WIDTH, CROP_HEIGHT,
    )

    if not FOREGROUND_GUID_TO_TILEID:
        print(
            "\n[note] FOREGROUND_GUID_TO_TILEID is empty — foreground will be all 0.\n"
            "       Edit tools/unity_to_level.py and re-run once you have the mapping.",
            file=sys.stderr,
        )

    out = emit_header(fg_grid, bg_grid, CROP_WIDTH, CROP_HEIGHT)
    with open(OUTPUT_PATH, "w", encoding="utf-8", newline="\n") as f:
        f.write(out)
    print(f"wrote {OUTPUT_PATH}")
    return 0


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