from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
import re
import random

import cv2
from functools import lru_cache


_TIME = re.compile(r"(?P<date>\d{2}-\d{2}-\d{4})[_T](?P<time>\d{2}-\d{2}-\d{2})")
_COLLECTION_DATE = re.compile(r"^\d{4}_\d{1,2}_\d{1,2}$")
_MODALITIES = (
    ("pcd", ".pcd", "point_cloud"),
    ("depth", ".png", "depth_image"),
    ("intensity", ".png", "amplitude_image"),
    ("intensity", ".yaml", "amplitude_image"),
    ("rgb", ".jpg", "rgb_image"),
    ("xyz", ".yaml", "xyz_image"),
)
_VERSION_DIRS = {"all", "none_rectified", "original", "temporal_filter", "with_filter", "without_filter"}


@lru_cache(maxsize=100000)
def _pcd_grid(path):
    width = height = None
    with Path(path).open("rb") as stream:
        for line in stream:
            parts = line.decode("ascii", "ignore").strip().split()
            if len(parts) >= 2 and parts[0].upper() == "WIDTH":
                width = int(parts[1])
            elif len(parts) >= 2 and parts[0].upper() == "HEIGHT":
                height = int(parts[1])
            elif parts and parts[0].upper() == "DATA":
                break
    if width is None or height is None:
        return None
    if height == 1 and width == 307200:
        return (480, 640)
    if height == 1 and width == 23040:
        return (96, 240)
    if height == 1:
        return None
    return (height, width)


@dataclass(frozen=True)
class FrameRecord:
    """One timestamp and one processing variant; files remain source paths."""

    frame_id: str
    group_id: str
    variant: str
    paths: dict[str, Path]
    sensor_config: dict | None = None
    source_sha256: str | None = None
    cache_path: str | None = None
    cache_sha256: str | None = None

    @property
    def pcd(self) -> Path | None:
        return self.paths.get("pcd")

    @property
    def session(self) -> str:
        return self.group_id

    @property
    def resolution_domain(self) -> str:
        """Sensor grid and known FOV caveat, independent of collection session."""
        resolution = "unknown"
        if self.pcd:
            try:
                grid = _pcd_grid(self.pcd)
                if grid:
                    resolution = "{}x{}".format(grid[1], grid[0])
            except (OSError, ValueError):
                pass
        collection = self.frame_id.split("/", 1)[0]
        if resolution == "352x264" and collection == "2025_7_11":
            return "352x264; FOV about 39x30 deg in 2025_7_11"
        if resolution == "352x264":
            return "352x264; FOV varies by batch"
        if resolution in ("640x480", "240x96"):
            return resolution + "; FOV varies by batch"
        return resolution + "; FOV uncertain"

    @property
    def domain(self) -> str:
        return self.sensor_config.get("domain_id", self.resolution_domain) if self.sensor_config else self.resolution_domain

    def to_dict(self) -> dict:
        timestamp_id = self.frame_id.split("#", 1)[0]
        return {
            "frame_id": self.frame_id,
            "capture_id": timestamp_id,
            "group_id": self.group_id,
            "session": self.session,
            "collection": self.frame_id.split("/", 1)[0],
            "domain": self.domain,
            "variant": self.variant,
            "paths": {key: str(value) for key, value in sorted(self.paths.items())},
            "status": "usable" if self.paths else "empty",
            "sensor_config": self.sensor_config,
            "source_sha256": self.source_sha256,
            "cache_path": self.cache_path,
            "cache_sha256": self.cache_sha256,
        }


def scan_dataset(root: str | Path) -> list[FrameRecord]:
    """Index recognized, nonempty sensor files without extracting archives.

    Duplicate modalities under different processing directories become separate
    records. A group id is shared across versions of the same timestamp within
    a top-level collection directory, keeping versions together in splits.
    """
    root = Path(root).expanduser().resolve()
    if not root.is_dir():
        raise FileNotFoundError(f"dataset directory does not exist: {root}")
    rows: dict[tuple[str, str], dict[str, Path]] = {}
    sessions = {}
    for path in sorted(root.rglob("*")):
        if not path.is_file() or path.stat().st_size == 0:
            continue
        match = _TIME.search(path.name)
        if not match:
            continue
        modality = next((m for m, ext, prefix in _MODALITIES
                         if path.suffix.lower() == ext and path.name.lower().startswith(prefix)), None)
        if modality is None:
            continue
        rel = path.relative_to(root)
        batch = root.name if _COLLECTION_DATE.match(root.name) else (rel.parts[0] if len(rel.parts) > 1 else ".")
        timestamp = f"{match.group('date')}_{match.group('time')}"
        capture_id = f"{batch}/{timestamp}"
        # A variant is the relative parent directory below the collection batch.
        variant = "/".join(rel.parts[1:-1]) or "default"
        session_parts = [p for p in rel.parts[1:-1] if p.lower() not in _VERSION_DIRS]
        # Without an acquisition boundary, keep the entire collection together.
        # Clock-minute boundaries are never evidence of independent captures.
        if session_parts:
            session = batch + "/scene/" + "/".join(session_parts)
        else:
            session = batch + "/session/unspecified"
        key = (capture_id, variant)
        # If multiple candidates have identical modality in a variant, retain
        # the first deterministic path; other variants remain visible.
        rows.setdefault(key, {}).setdefault(modality, path)
        sessions[key] = session

    # Join variants of a capture and adjacent captures from the same scene
    # session. This is intentionally conservative: a session stays in one split.
    keys = list(rows)
    parent = list(range(len(keys)))
    def find(i):
        while parent[i] != i:
            parent[i] = parent[parent[i]]
            i = parent[i]
        return i
    def union(a, b):
        ra, rb = find(a), find(b)
        if ra != rb:
            parent[rb] = ra
    by_capture, by_session = {}, {}
    for i, key in enumerate(keys):
        by_capture.setdefault(key[0], []).append(i)
        by_session.setdefault(sessions[key], []).append(i)
    for bucket in list(by_capture.values()) + list(by_session.values()):
        for i in bucket[1:]:
            union(bucket[0], i)
    roots = {}
    for i, key in enumerate(keys):
        roots.setdefault(find(i), []).append(key)
    group_for = {}
    for members in roots.values():
        group_id = min(sessions[key] for key in members)
        for key in members:
            group_for[key] = group_id
    records = [FrameRecord(capture_id + "#" + variant, group_for[(capture_id, variant)], variant, paths)
               for (capture_id, variant), paths in rows.items()]
    return sorted(records, key=lambda r: (r.group_id, r.variant))


def split_groups(records, seed: int = 42, fractions=(0.7, 0.15, 0.15)) -> dict:
    """Split records by timestamp group, keeping all processing versions together."""
    names = ("train", "val", "test")
    if len(fractions) != 3 or any(value < 0 for value in fractions) or sum(fractions) <= 0:
        raise ValueError("fractions must be three nonnegative values with a positive sum")
    total = float(sum(fractions))
    fractions = [value / total for value in fractions]
    groups = {}
    for record in records:
        groups.setdefault(record.group_id, []).append(record)
    keys = list(groups)
    random.Random(seed).shuffle(keys)
    targets = [len(records) * value for value in fractions]
    result = dict((name, []) for name in names)
    counts = [0, 0, 0]
    for key in keys:
        size = len(groups[key])
        idx = min(range(3), key=lambda i: (counts[i] - targets[i], counts[i]))
        result[names[idx]].extend(groups[key])
        counts[idx] += size
    return result


def leave_one_domain(records, domain: str) -> dict:
    """Hold out a sensor-resolution domain; report FOV uncertainty in its name."""
    if not any(record.domain == domain for record in records):
        raise ValueError("unknown domain: {}".format(domain))
    return {
        "train": [record for record in records if record.domain != domain],
        "test": [record for record in records if record.domain == domain],
    }


def canonical_records(records):
    """Select documented processing variants without mixing their pixel grids.

    A second-precision timestamp does not establish capture identity across
    independent scene folders. Only the batches whose copied/processed layout
    was independently audited are collapsed on timestamp alone.
    """
    by_capture = {}
    def quality(record):
        score = 0
        score += 8 if "pcd" in record.paths else 0
        score += 4 if "depth" in record.paths else 0
        score += 2 if "intensity" in record.paths else 0
        score += 1 if "rgb" in record.paths else 0
        return (score, record.variant == "all", record.variant)
    for record in records:
        capture_id = record.frame_id.split("#", 1)[0]
        by_capture.setdefault(capture_id, []).append(record)
    canonical = []
    documented_batches = {"2024_10_30", "2024_11_27", "2024_11_29"}
    for capture_id, candidates in by_capture.items():
        if capture_id.split("/", 1)[0] in documented_batches:
            base = max(candidates, key=quality)
            canonical.append(base)
        else:
            canonical.extend(candidates)
    return sorted(canonical, key=lambda r: r.frame_id)


@lru_cache(maxsize=100000)
def _modality_shape(path):
    if path is None:
        return None
    if path.suffix.lower() == ".yaml":
        try:
            storage = cv2.FileStorage(str(path), cv2.FILE_STORAGE_READ)
            if not storage.isOpened():
                return None
            try:
                node = storage.getFirstTopLevelNode()
                return (int(node.getNode("rows").real()), int(node.getNode("cols").real()))
            finally:
                storage.release()
        except (OSError, ValueError, cv2.error):
            return None
    try:
        from PIL import Image
        with Image.open(path) as im:
            return (im.height, im.width)
    except (ImportError, OSError):
        return None
