"""
Diagnose 3DGS PLY parameter spaces and quantization artifacts.

Use this before blaming the Transformer. It checks whether scale/opacity/rotation
fields look like standard 3DGS raw parameters, and optionally compares a
quantized/reconstructed PLY against the original PLY.

Examples:
    python diagnose_ply_fields.py original.ply
    python diagnose_ply_fields.py original.ply --compare reconstructed.ply
"""

import argparse
import os

import numpy as np

try:
    from plyfile import PlyData
except ModuleNotFoundError:
    PlyData = None


PERCENTILES = [0, 1, 50, 90, 95, 99, 99.9, 100]

PLY_DTYPE_MAP = {
    "char": "i1",
    "int8": "i1",
    "uchar": "u1",
    "uint8": "u1",
    "short": "i2",
    "int16": "i2",
    "ushort": "u2",
    "uint16": "u2",
    "int": "i4",
    "int32": "i4",
    "uint": "u4",
    "uint32": "u4",
    "float": "f4",
    "float32": "f4",
    "double": "f8",
    "float64": "f8",
}


def sigmoid(x: np.ndarray) -> np.ndarray:
    x = np.clip(x, -80.0, 80.0)
    return 1.0 / (1.0 + np.exp(-x))


def read_vertex_without_plyfile(ply_path: str) -> np.ndarray:
    with open(ply_path, "rb") as f:
        first = f.readline().decode("ascii", errors="replace").strip()
        if first != "ply":
            raise ValueError(f"{ply_path} is not a PLY file")

        fmt = None
        vertex_count = None
        vertex_props = []
        current_element = None

        while True:
            line_b = f.readline()
            if not line_b:
                raise ValueError(f"{ply_path} ended before end_header")
            line = line_b.decode("ascii", errors="replace").strip()
            if line == "end_header":
                data_start = f.tell()
                break
            if not line or line.startswith("comment"):
                continue
            parts = line.split()
            if parts[0] == "format":
                fmt = parts[1]
            elif parts[0] == "element":
                current_element = parts[1]
                if current_element == "vertex":
                    vertex_count = int(parts[2])
            elif parts[0] == "property" and current_element == "vertex":
                if parts[1] == "list":
                    raise ValueError("List properties inside vertex are not supported by the fallback reader.")
                prop_type, prop_name = parts[1], parts[2]
                if prop_type not in PLY_DTYPE_MAP:
                    raise ValueError(f"Unsupported PLY property type: {prop_type}")
                vertex_props.append((prop_name, PLY_DTYPE_MAP[prop_type]))

        if fmt is None or vertex_count is None:
            raise ValueError(f"{ply_path} missing format or vertex element in header")
        if not vertex_props:
            raise ValueError(f"{ply_path} has no vertex properties")

        if fmt == "binary_little_endian":
            dtype = np.dtype(vertex_props).newbyteorder("<")
            f.seek(data_start)
            data = np.fromfile(f, dtype=dtype, count=vertex_count)
            if data.shape[0] != vertex_count:
                raise ValueError(f"Expected {vertex_count} vertices, read {data.shape[0]}")
            return data

        if fmt == "binary_big_endian":
            dtype = np.dtype(vertex_props).newbyteorder(">")
            f.seek(data_start)
            data = np.fromfile(f, dtype=dtype, count=vertex_count)
            if data.shape[0] != vertex_count:
                raise ValueError(f"Expected {vertex_count} vertices, read {data.shape[0]}")
            return data

        if fmt == "ascii":
            f.seek(data_start)
            rows = []
            for _ in range(vertex_count):
                line = f.readline().decode("ascii", errors="replace").strip()
                rows.append(line.split())
            raw = np.asarray(rows, dtype=np.float64)
            dtype = np.dtype(vertex_props)
            data = np.empty(vertex_count, dtype=dtype)
            for i, (name, _) in enumerate(vertex_props):
                data[name] = raw[:, i].astype(data.dtype[name])
            return data

        raise ValueError(f"Unsupported PLY format: {fmt}")


def read_vertex(ply_path: str) -> np.ndarray:
    if PlyData is not None:
        plydata = PlyData.read(ply_path)
        return plydata["vertex"].data
    return read_vertex_without_plyfile(ply_path)


def read_fields(ply_path: str) -> dict:
    vertex = read_vertex(ply_path)
    names = vertex.dtype.names

    required = [
        "scale_0",
        "scale_1",
        "scale_2",
        "opacity",
        "rot_0",
        "rot_1",
        "rot_2",
        "rot_3",
    ]
    missing = [name for name in required if name not in names]
    if missing:
        raise ValueError(f"{ply_path} missing fields: {missing}")

    scale = np.stack(
        [vertex["scale_0"], vertex["scale_1"], vertex["scale_2"]], axis=1
    ).astype(np.float64)
    opacity = np.asarray(vertex["opacity"], dtype=np.float64)
    rot = np.stack(
        [vertex["rot_0"], vertex["rot_1"], vertex["rot_2"], vertex["rot_3"]], axis=1
    ).astype(np.float64)

    xyz = None
    if all(name in names for name in ["x", "y", "z"]):
        xyz = np.stack([vertex["x"], vertex["y"], vertex["z"]], axis=1).astype(
            np.float64
        )

    return {
        "scale": scale,
        "opacity": opacity,
        "rot": rot,
        "xyz": xyz,
        "n": scale.shape[0],
    }


def print_percentiles(title: str, values: np.ndarray) -> None:
    pct = np.percentile(values, PERCENTILES, axis=0)
    print(f"\n[{title}]")
    for p, row in zip(PERCENTILES, pct):
        if np.ndim(row) == 0:
            print(f"  p{p:>5}: {float(row): .8g}")
        else:
            joined = "  ".join(f"{float(x): .8g}" for x in np.ravel(row))
            print(f"  p{p:>5}: {joined}")


def diagnose_one(ply_path: str) -> dict:
    data = read_fields(ply_path)
    scale = data["scale"]
    opacity = data["opacity"]
    rot = data["rot"]

    exp_scale = np.exp(np.clip(scale, -80.0, 80.0))
    alpha = sigmoid(opacity)
    rot_norm = np.linalg.norm(rot, axis=1)
    volume = np.exp(np.clip(scale.sum(axis=1), -80.0, 80.0))

    print("\n" + "=" * 88)
    print(f"PLY: {os.path.abspath(ply_path)}")
    print(f"N:   {data['n']:,}")
    print("=" * 88)

    print_percentiles("scale raw fields: scale_0/1/2", scale)
    print_percentiles("exp(scale): renderer physical scale if PLY is standard raw scale", exp_scale)
    print_percentiles("log-volume = scale_0 + scale_1 + scale_2", scale.sum(axis=1))
    print_percentiles("physical volume = exp(sum(scale))", volume)
    print_percentiles("opacity raw field", opacity)
    print_percentiles("sigmoid(opacity): renderer alpha if PLY is standard raw opacity", alpha)
    print_percentiles("rotation L2 norm", rot_norm)

    suspicious_scale_positive = np.mean(scale > 0.0)
    suspicious_exp_big = np.mean(exp_scale > 1.0)
    near_unit_rot = np.mean(np.abs(rot_norm - 1.0) < 1e-3)

    print("\n[quick flags]")
    print(f"  fraction(scale entries > 0):       {suspicious_scale_positive:.4%}")
    print(f"  fraction(exp(scale) entries > 1):  {suspicious_exp_big:.4%}")
    print(f"  fraction(rot norm near 1):         {near_unit_rot:.4%}")

    if np.percentile(scale, 50) > 0.0:
        print("  WARN: median raw scale is positive. If this PLY is loaded by standard 3DGS, exp(scale) may be very large.")
    if np.percentile(exp_scale, 99) > 1.0:
        print("  WARN: exp(scale) p99 > 1.0. This is often huge for standard 3DGS scenes and can create bright blobs.")
    if np.percentile(rot_norm, 99) < 0.5 or np.percentile(rot_norm, 1) > 2.0:
        print("  WARN: rotation norms look unusual before renderer normalization.")

    return data


def compare(original_path: str, compare_path: str) -> None:
    orig = read_fields(original_path)
    comp = read_fields(compare_path)
    if orig["n"] != comp["n"]:
        print("\n[compare skipped]")
        print(f"  Point counts differ: original={orig['n']:,}, compare={comp['n']:,}")
        return

    scale_a = orig["scale"]
    scale_b = comp["scale"]
    rot_a = orig["rot"]
    rot_b = comp["rot"]

    log_volume_delta = scale_b.sum(axis=1) - scale_a.sum(axis=1)
    volume_ratio = np.exp(np.clip(log_volume_delta, -80.0, 80.0))
    scale_abs_err = np.abs(scale_b - scale_a)

    rot_a_norm = rot_a / np.linalg.norm(rot_a, axis=1, keepdims=True).clip(1e-12)
    rot_b_norm = rot_b / np.linalg.norm(rot_b, axis=1, keepdims=True).clip(1e-12)
    dot = np.abs(np.sum(rot_a_norm * rot_b_norm, axis=1)).clip(0.0, 1.0)
    rot_angle_deg = np.degrees(2.0 * np.arccos(dot))

    print("\n" + "=" * 88)
    print("COMPARISON")
    print(f"original: {os.path.abspath(original_path)}")
    print(f"compare:  {os.path.abspath(compare_path)}")
    print("=" * 88)
    print_percentiles("abs scale error per axis", scale_abs_err)
    print_percentiles("log-volume delta: sum(compare_scale - original_scale)", log_volume_delta)
    print_percentiles("volume ratio: exp(log-volume delta)", volume_ratio)
    print_percentiles("rotation angular error in degrees, abs(q dot q')", rot_angle_deg)

    for threshold in [2, 4, 8, 16, 32, 64]:
        count = int(np.sum(volume_ratio > threshold))
        print(f"  count(volume_ratio > {threshold:>2}): {count:,} ({count / len(volume_ratio):.4%})")

    top = np.argsort(volume_ratio)[-10:][::-1]
    print("\n[top 10 volume-ratio points]")
    print("  idx      ratio        orig_scale                  comp_scale")
    for idx in top:
        oscale = " ".join(f"{x: .5f}" for x in scale_a[idx])
        cscale = " ".join(f"{x: .5f}" for x in scale_b[idx])
        print(f"  {idx:<8d} {volume_ratio[idx]:>11.4g}   [{oscale}]   [{cscale}]")


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Diagnose 3DGS PLY scale/opacity/rotation fields.")
    parser.add_argument("ply", help="Original or target PLY to inspect.")
    parser.add_argument("--compare", help="Optional reconstructed/quantized PLY to compare against the first PLY.")
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    diagnose_one(args.ply)
    if args.compare:
        diagnose_one(args.compare)
        compare(args.ply, args.compare)


if __name__ == "__main__":
    main()