from pathlib import Path
from dataclasses import replace
import struct

import pytest

import numpy as np
from PIL import Image

from pallet.data import (scan_dataset, read_pcd, load_frame, fit_normalization,
                         apply_normalization, split_groups, leave_one_domain,
                         canonical_records)


def _pcd(path: Path, mode: str = "ascii") -> None:
    header = ("# .PCD v0.7\nVERSION .7\nFIELDS x y z intensity\nSIZE 4 4 4 4\n"
              "TYPE F F F F\nCOUNT 1 1 1 1\nWIDTH 2\nHEIGHT 1\nPOINTS 2\nDATA " + mode + "\n").encode()
    if mode == "ascii":
        payload = b"1 2 3 4\n5 6 7 8\n"
    elif mode == "binary_compressed":
        # PCL's compressed payload stores each field as one contiguous array.
        raw = np.array([1, 5, 2, 6, 3, 7, 4, 8], dtype="<f4").tobytes()
        payload = struct.pack("<II", len(raw) + 1, len(raw)) + bytes([len(raw) - 1]) + raw
    else:
        payload = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], dtype="<f4").tobytes()
    path.write_bytes(header + payload)


def test_pcd_ascii_and_binary(tmp_path):
    for mode in ("ascii", "binary", "binary_compressed"):
        path = tmp_path / f"{mode}.pcd"
        _pcd(path, mode)
        header, points = read_pcd(path)
        assert header["WIDTH"] == ["2"]
        np.testing.assert_allclose(points, [[1, 2, 3, 4], [5, 6, 7, 8]])


def test_manifest_groups_processing_versions_and_omits_empty_files(tmp_path):
    stamp = "29-11-2024_07-17-08"
    base = tmp_path / "2024_11_29"
    for version in ("all", "none_rectified"):
        folder = base / version
        folder.mkdir(parents=True)
        _pcd(folder / f"point_cloud_xyzi_{stamp}.pcd")
    Image.fromarray(np.array([[11, 12]], dtype=np.uint16)).save(
        base / "none_rectified" / f"depth_image_{stamp}.png")
    (base / "all" / f"rgb_image_{stamp}.jpg").touch()
    rows = scan_dataset(tmp_path)
    assert len(rows) == 2
    assert len({row.group_id for row in rows}) == 1
    assert {row.variant for row in rows} == {"all", "none_rectified"}
    assert all("rgb" not in row.paths for row in rows)
    assert rows[0].to_dict()["group_id"] == rows[1].to_dict()["group_id"]
    assert rows[0].domain == "unknown; FOV uncertain"
    assert rows[0].frame_id != rows[1].frame_id
    parts = split_groups(rows, seed=5)
    flattened = [r for values in parts.values() for r in values]
    assert sorted(flattened, key=lambda r: (r.group_id, r.variant)) == rows
    assert len([values for values in parts.values() if values]) == 1
    held_out = leave_one_domain(rows, rows[0].domain)
    assert len(held_out["test"]) == 2 and not held_out["train"]
    canonical = canonical_records(rows)
    assert len(canonical) == 1
    assert "pcd" in canonical[0].paths and "depth" in canonical[0].paths


def test_four_channel_loader_and_training_normalization(tmp_path):
    folder = tmp_path / "2024_11_29" / "all"
    folder.mkdir(parents=True)
    stamp = "29-11-2024_07-17-08"
    _pcd(folder / f"point_cloud_xyzi_{stamp}.pcd")
    Image.fromarray(np.array([[100, 0]], dtype=np.uint16)).save(folder / f"depth_image_{stamp}.png")
    Image.fromarray(np.array([[10, 20]], dtype=np.uint16)).save(folder / f"amplitude_image_{stamp}.png")
    record = replace(scan_dataset(tmp_path)[0], sensor_config={
        "grid": [1, 2], "depth_source": "depth", "depth_available": True,
        "scale_to_mm": 1, "rasters_aligned": True})
    frame = load_frame(record)
    assert frame.shape == (1, 2, 4)
    np.testing.assert_allclose(frame[0], [[100, 4, 1, 1], [0, 8, 0, 1]])
    stats = fit_normalization([record])
    normalized = apply_normalization(frame, stats)
    assert normalized.dtype == np.float32
    assert normalized[..., :2].max() <= 1


def test_pcd_only_depth_and_bad_zero_yaml_intensity_fallback(tmp_path):
    folder = tmp_path / "2023_10_7" / "scene"
    folder.mkdir(parents=True)
    stamp = "07-10-2023_01-02-03"
    path = folder / f"point_cloud_xyzi_{stamp}.pcd"
    header = ("# .PCD v0.7\nVERSION .7\nFIELDS x y z intensity\nSIZE 4 4 4 4\n"
              "TYPE F F F F\nCOUNT 1 1 1 1\nWIDTH 4\nHEIGHT 1\nPOINTS 4\nDATA binary\n").encode()
    path.write_bytes(header + np.array([[1, 0, 0, 10], [2, 0, 0, 20],
                                        [3, 0, 0, 30], [4, 0, 0, 40]], dtype="<f4").tobytes())
    (folder / f"amplitude_image_{stamp}.yaml").write_text(
        "%YAML:1.0\n---\namplitude_image: !!opencv-matrix\n   rows: 2\n"
        "   cols: 2\n   dt: u\n   data: [0, 0, 0, 0]\n")
    record = replace(scan_dataset(tmp_path)[0], sensor_config={
        "grid": [2, 2], "depth_source": "pcd", "depth_available": True,
        "scale_to_mm": 1000, "depth_axis": 0})
    frame, metadata = load_frame(record, return_metadata=True)
    np.testing.assert_allclose(frame[..., 0], [[1000, 2000], [3000, 4000]])
    np.testing.assert_allclose(frame[..., 1], [[10, 20], [30, 40]])
    assert np.all(frame[..., 3] == 1)
    assert metadata["depth_source"] == "pcd"
    assert metadata["depth_units"] == "mm"
    assert metadata["intensity_source"] == "PCD native intensity"
    unknown_policy = replace(record, sensor_config={"grid": [2, 2]})
    missing, reason = load_frame(unknown_policy, return_metadata=True)
    assert np.all(missing[..., 0] == 0) and np.all(missing[..., 2] == 0)
    assert reason["depth_unavailable_reason"]
    with pytest.raises(ValueError, match="positive metric scale"):
        load_frame(replace(record, sensor_config={"grid": [2, 2], "depth_source": "pcd",
                  "depth_available": True, "depth_axis": 0}))
    with pytest.raises(ValueError, match="axial-depth policy"):
        load_frame(replace(record, sensor_config={"grid": [2, 2], "depth_source": "pcd",
                  "depth_available": True, "scale_to_mm": 1000}))
    unknown = folder / "point_cloud_xyzi_07-10-2023_01-03-03.pcd"
    _pcd(unknown)
    unorganized = next(r for r in scan_dataset(tmp_path) if r.pcd == unknown)
    try:
        load_frame(unorganized)
    except ValueError as exc:
        assert "no loadable" in str(exc)
    else:
        raise AssertionError("unknown flat cloud was treated as an image grid")


def test_flattened_pcd_grid_restoration_and_session_grouping(tmp_path):
    folder = tmp_path / "2024_11_27" / "all"
    folder.mkdir(parents=True)
    for stamp in ("27-11-2024_07-01-10", "27-11-2024_07-02-48"):
        path = folder / f"point_cloud_xyzi_{stamp}.pcd"
        header = ("# .PCD v0.7\nVERSION .7\nFIELDS x y z intensity\nSIZE 4 4 4 4\n"
                  "TYPE F F F F\nCOUNT 1 1 1 1\nWIDTH 23040\nHEIGHT 1\nPOINTS 23040\nDATA binary\n").encode()
        points = np.zeros((23040, 4), dtype="<f4")
        points[:, 0] = 250
        points[:, 3] = 5
        path.write_bytes(header + points.tobytes())
    rows = scan_dataset(tmp_path)
    assert len(rows) == 2
    assert rows[0].group_id == rows[1].group_id
    assert rows[0].domain.startswith("240x96;")
    frame = load_frame(replace(rows[0], sensor_config={
        "grid": [96, 240], "depth_source": "pcd", "depth_available": True,
        "scale_to_mm": 1, "depth_axis": 0}))
    assert frame.shape == (96, 240, 4)
    assert np.all(frame[..., 2] == 1)


def test_same_shape_does_not_merge_sibling_modalities(tmp_path):
    stamp = "07-10-2023_01-02-03"
    depth_dir = tmp_path / "2023_10_7" / "scene_a"
    intensity_dir = tmp_path / "2023_10_7" / "scene_b"
    depth_dir.mkdir(parents=True)
    intensity_dir.mkdir(parents=True)
    Image.fromarray(np.ones((2, 2), dtype=np.uint16)).save(
        depth_dir / f"depth_image_{stamp}.png")
    Image.fromarray(np.ones((2, 2), dtype=np.uint16)).save(
        intensity_dir / f"amplitude_image_{stamp}.png")
    rows = canonical_records(scan_dataset(tmp_path))
    assert len(rows) == 2
    assert all(len(row.paths) == 1 for row in rows)
    assert {next(iter(row.paths)) for row in rows} == {"depth", "intensity"}
