"""
NASAR dataset — PyTorch DataLoader interface.

Usage
-----
from NASAR.nasar_dataset import NASARRTCDataset, NASARInSARDataset
from torch.utils.data import DataLoader

rtc_ds = NASARRTCDataset(
    nasar_root="/home/haozhesi/EventCentricGFM/data/NASAR",
    parquet_path="/home/haozhesi/EventCentricGFM/dataset_construction/OPERA_meta/rtc_patch_index_128.parquet",
)
loader = DataLoader(rtc_ds, batch_size=32, shuffle=True, num_workers=4)

# Each batch:
#   {
#     "patch_id":         list[str],
#     "rtc_view_0":       torch.Tensor (B, 2, 128, 128),  — [co-pol, cross-pol] (VV/HH, VH/HV)
#     "inc_angle_view_0": torch.Tensor (B, 1, 128, 128),
#     "rtc_view_1":       torch.Tensor (B, 2, 128, 128),  — [co-pol, cross-pol] (VV/HH, VH/HV)
#     "inc_angle_view_1": torch.Tensor (B, 1, 128, 128),
#   }

# Each item (rtc):
#   {
#     "patch_id":         str,
#     "rtc_view_0":       np.ndarray (2, 128, 128) float32  — [VV, VH], channel zero-padded if absent,
#     "inc_angle_view_0": np.ndarray (1, 128, 128) float32,
#     "rtc_view_1":       np.ndarray (2, 128, 128) float32  — [VV, VH], channel zero-padded if absent,
#     "inc_angle_view_1": np.ndarray (1, 128, 128) float32,
#   }

# Each item (insar):
#   {
#     "patch_id":         str,
#     "ifg_view_0":       np.ndarray (2, 128, 128) float32  — [cos(φ), sin(φ)],
#     "coh_view_0":       np.ndarray (1, 128, 128) float32,
#     "dem_view_0":       np.ndarray (1, 128, 128) float32,  — optional when dem_root is set,
#     "dem_relief_view_0": np.ndarray (1, 128, 128) float32, — optional when dem_root is set,
#     "slope_view_0":     np.ndarray (1, 128, 128) float32,  — optional when dem_root is set,
#     "inc_angle_view_0": np.ndarray (1, 128, 128) float32,
#     "ifg_view_1":       np.ndarray (2, 128, 128) float32  — [cos(φ), sin(φ)],
#     "coh_view_1":       np.ndarray (1, 128, 128) float32,
#     "dem_view_1":       np.ndarray (1, 128, 128) float32,  — optional when dem_root is set,
#     "dem_relief_view_1": np.ndarray (1, 128, 128) float32, — optional when dem_root is set,
#     "slope_view_1":     np.ndarray (1, 128, 128) float32,  — optional when dem_root is set,
#     "inc_angle_view_1": np.ndarray (1, 128, 128) float32,
#   }
"""

from __future__ import annotations

from io import BytesIO
import json
import os
from pathlib import Path
import tarfile

import numpy as np
import pandas as pd
import rasterio
import torch.distributed as dist
from torch.utils.data import IterableDataset, get_worker_info

# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------

RTC_COPOL_NORM_STATS = (0.15, 2.39)
RTC_XPOL_NORM_STATS = (0.01, 1.09)
DEFAULT_RTC_NORM_STATS = (RTC_COPOL_NORM_STATS, RTC_XPOL_NORM_STATS)
RTCNormStats = tuple[float, float] | tuple[tuple[float, float], tuple[float, float]]
DEFAULT_NASAR_RAW_ROOT = Path("/archive/NASAR_raw")
DEFAULT_DEM_SUBDIR = "NASAR-Dem"
# Global-land robust elevation range in meters.  This avoids baking NASAR's
# spatial sampling bias into the DEM channel while still clipping extremes.
DEM_ELEVATION_NORM_STATS = (-100.0, 4000.0)
DEM_SLOPE_DEG_NORM_STATS = (0.0, 45.0)
DEM_NODATA_VALUE = -9999.0
DEM_RELIEF_PERCENTILES = (5.0, 95.0)
DEMElevationNormStats = tuple[float, float]

def _read_tif(path: str | Path) -> np.ndarray:
    """Read a single-band GeoTIFF and return a (1, 128, 128) float32 array."""
    with rasterio.open(path) as src:
        arr = src.read(1).astype(np.float32)
    return _center_crop(arr[np.newaxis])  # (1, 128, 128)


def _read_dem(path: str | Path, norm_stats: DEMElevationNormStats | None = None) -> np.ndarray:
    """Read a DEM patch as (1, 128, 128) float32, optionally p1/p99-normalized."""
    with rasterio.open(path) as src:
        arr = src.read(1).astype(np.float32)
        valid = np.isfinite(arr)
        if src.nodata is not None and np.isfinite(src.nodata):
            valid &= arr != np.float32(src.nodata)

    if norm_stats is not None:
        p1, p99 = norm_stats
        denom = max(float(p99) - float(p1), 1e-6)
        norm = np.zeros_like(arr, dtype=np.float32)
        norm[valid] = np.clip((arr[valid] - np.float32(p1)) / np.float32(denom), 0.0, 1.0)
        arr = norm
    else:
        arr = np.where(valid, arr, 0.0).astype(np.float32)
    return _center_crop(arr[np.newaxis])


def _read_dem_global_and_relief(
    path: str | Path,
    norm_stats: DEMElevationNormStats = DEM_ELEVATION_NORM_STATS,
) -> tuple[np.ndarray, np.ndarray]:
    """Read DEM as global-normalized elevation and patch-local relief."""
    with rasterio.open(path) as src:
        arr = src.read(1).astype(np.float32)
        valid = np.isfinite(arr)
        if src.nodata is not None and np.isfinite(src.nodata):
            valid &= arr != np.float32(src.nodata)

    p1, p99 = norm_stats
    denom = max(float(p99) - float(p1), 1e-6)
    dem_global = np.zeros_like(arr, dtype=np.float32)
    dem_global[valid] = np.clip((arr[valid] - np.float32(p1)) / np.float32(denom), 0.0, 1.0)

    dem_relief = np.zeros_like(arr, dtype=np.float32)
    values = arr[valid]
    if values.size:
        low, high = np.percentile(values, [5, 95])
        relief_denom = max(float(high - low), 1e-6)
        dem_relief[valid] = np.clip((arr[valid] - np.float32(low)) / np.float32(relief_denom), 0.0, 1.0)
    return _center_crop(dem_global[np.newaxis]), _center_crop(dem_relief[np.newaxis])


def _normalize_dem_global_and_relief_array(
    arr: np.ndarray,
    norm_stats: DEMElevationNormStats = DEM_ELEVATION_NORM_STATS,
    nodata: float | None = DEM_NODATA_VALUE,
    relief_percentiles: DEMElevationNormStats = DEM_RELIEF_PERCENTILES,
) -> tuple[np.ndarray, np.ndarray]:
    """Normalize a raw DEM array into global elevation and local relief channels."""
    arr = np.squeeze(arr).astype(np.float32, copy=False)
    valid = np.isfinite(arr)
    if nodata is not None and np.isfinite(nodata):
        valid &= arr != np.float32(nodata)

    p1, p99 = norm_stats
    denom = max(float(p99) - float(p1), 1e-6)
    dem_global = np.zeros_like(arr, dtype=np.float32)
    dem_global[valid] = np.clip((arr[valid] - np.float32(p1)) / np.float32(denom), 0.0, 1.0)

    dem_relief = np.zeros_like(arr, dtype=np.float32)
    values = arr[valid]
    if values.size:
        low, high = np.percentile(values, relief_percentiles)
        relief_denom = max(float(high - low), 1e-6)
        dem_relief[valid] = np.clip((arr[valid] - np.float32(low)) / np.float32(relief_denom), 0.0, 1.0)
    return _center_crop(dem_global[np.newaxis]), _center_crop(dem_relief[np.newaxis])


def _read_slope(path: str | Path, norm_stats: DEMElevationNormStats = DEM_SLOPE_DEG_NORM_STATS) -> np.ndarray:
    """Read slope degrees as (1, 128, 128) float32, clipped/scaled to [0, 1]."""
    return _read_dem(path, norm_stats)


def _normalize_slope_array(
    arr: np.ndarray,
    norm_stats: DEMElevationNormStats = DEM_SLOPE_DEG_NORM_STATS,
    nodata: float | None = DEM_NODATA_VALUE,
) -> np.ndarray:
    """Normalize raw slope degrees to [0, 1]."""
    arr = np.squeeze(arr).astype(np.float32, copy=False)
    valid = np.isfinite(arr)
    if nodata is not None and np.isfinite(nodata):
        valid &= arr != np.float32(nodata)
    p0, p1 = norm_stats
    denom = max(float(p1) - float(p0), 1e-6)
    out = np.zeros_like(arr, dtype=np.float32)
    out[valid] = np.clip((arr[valid] - np.float32(p0)) / np.float32(denom), 0.0, 1.0)
    return _center_crop(out[np.newaxis])


def _read_rtc_band(path: str | Path, log_scale: bool, alpha: float) -> np.ndarray:
    """Read one RTC band and return a (H, W) float32 array, optionally log-compressed."""
    with rasterio.open(path) as src:
        arr = src.read(1).astype(np.float32)
        if src.nodata is not None:
            arr[arr == src.nodata] = 0.0
    # Replace NaN/inf (nodata stored as IEEE NaN) and negative values before log
    arr = np.where(np.isfinite(arr) & (arr > 0.0), arr, 0.0)
    if log_scale:
        arr = np.log1p(alpha * arr)
    return arr


def _normalize_rtc(arr: np.ndarray, norm_stats: RTCNormStats) -> np.ndarray:
    """Clip to channel p1/p99 and rescale to [0, 1]. Zeros (nodata) stay zero.

    ``norm_stats`` can be a single ``(p1, p99)`` tuple for backward-compatible
    shared-channel normalization or ``((co_p1, co_p99), (x_p1, x_p99))`` for
    separate co-pol/cross-pol normalization.
    """
    out = arr.astype(np.float32, copy=True)
    if out.ndim < 3:
        raise ValueError("RTC arrays must have shape (C, H, W) or (C, ...)")

    first = norm_stats[0]
    if isinstance(first, (tuple, list, np.ndarray)):
        channel_stats = norm_stats
    else:
        channel_stats = (norm_stats,) * out.shape[0]

    for ch, (p1, p99) in enumerate(channel_stats[: out.shape[0]]):
        valid = out[ch] > 0
        out[ch] = np.where(valid, np.clip((out[ch] - p1) / (p99 - p1), 0.0, 1.0), 0.0)
    return out


def _scan_rtc_dir(rtc_dir: Path) -> tuple[Path | None, Path | None]:
    """Return (copol_path, xpol_path) without calling iterdir at load time."""
    copol, xpol = None, None
    for p in rtc_dir.iterdir():
        n = p.name
        if n.endswith("_VV.tif") or (copol is None and n.endswith("_HH.tif")):
            copol = p
        elif n.endswith("_VH.tif") or (xpol is None and n.endswith("_HV.tif")):
            xpol = p
    return copol, xpol


def _read_rtc(rtc_dir: str | Path, log_scale: bool, alpha: float,
              norm_stats: RTCNormStats | None = None) -> np.ndarray:
    """Read co-pol and cross-pol bands from an RTC directory, (2, 128, 128) float32.

    Channel 0: co-pol  — VV, or HH for dual-HH/HV acquisitions (zero-padded if absent)
    Channel 1: cross-pol — VH, or HV for dual-HH/HV acquisitions (zero-padded if absent)

    HH/HV are treated as direct substitutes for VV/VH so the tensor layout is
    consistent regardless of polarisation mode. Callers that need to distinguish
    modes should inspect the source filenames before loading.

    If log_scale=True, applies log1p(alpha · value) per band before stacking.
    """
    rtc_dir = Path(rtc_dir)
    names = {p.name: p for p in rtc_dir.iterdir() if p.is_file()}

    # Co-pol: prefer VV, fall back to HH
    copol_path = next(
        (p for name, p in names.items() if name.endswith("_VV.tif")), None
    ) or next(
        (p for name, p in names.items() if name.endswith("_HH.tif")), None
    )
    # Cross-pol: prefer VH, fall back to HV
    xpol_path = next(
        (p for name, p in names.items() if name.endswith("_VH.tif")), None
    ) or next(
        (p for name, p in names.items() if name.endswith("_HV.tif")), None
    )

    if copol_path is None and xpol_path is None:
        raise FileNotFoundError(f"No backscatter tif (VV/VH/HH/HV) found in {rtc_dir}")

    copol = _read_rtc_band(copol_path, log_scale, alpha) if copol_path is not None else None
    xpol  = _read_rtc_band(xpol_path,  log_scale, alpha) if xpol_path  is not None else None

    # Zero-pad whichever channel is missing
    if copol is None:
        copol = np.zeros_like(xpol)
    if xpol is None:
        xpol = np.zeros_like(copol)

    out = _center_crop(np.stack([copol, xpol], axis=0))  # (2, 128, 128)
    if norm_stats is not None and log_scale:
        out = _normalize_rtc(out, norm_stats)
    return out


def _read_ifg(path: str | Path) -> np.ndarray:
    """Read an interferogram phase (radians) and return (2, 128, 128) float32 [cos, sin].

    The raw phase is cyclic (-π to π), so decomposing into cos/sin gives a
    continuous 2-channel representation that avoids the wraparound discontinuity.
    """
    with rasterio.open(path) as src:
        phase = src.read(1).astype(np.float32)
    return _center_crop(np.stack([np.cos(phase), np.sin(phase)], axis=0))  # (2, 128, 128)


def _find_file(directory: str | Path, suffix: str) -> Path:
    """Return the first file in *directory* whose name ends with *suffix*."""
    for p in Path(directory).iterdir():
        if p.name.endswith(suffix):
            return p
    raise FileNotFoundError(f"No file ending with '{suffix}' in {directory}")


def _center_crop(arr: np.ndarray, size: int = 128) -> np.ndarray:
    """Center-crop a (..., H, W) array to (..., size, size)."""
    h, w = arr.shape[-2], arr.shape[-1]
    top  = (h - size) // 2
    left = (w - size) // 2
    return arr[..., top:top + size, left:left + size]


def _prepare_npz_rtc(
    arr: np.ndarray,
    log_scale: bool,
    alpha: float,
    norm_stats: RTCNormStats | None = None,
) -> np.ndarray:
    """Apply the same RTC preprocessing used by NASARRTCDataset to a stored array."""
    arr = arr.astype(np.float32, copy=True)
    arr = np.where(np.isfinite(arr) & (arr > 0.0), arr, 0.0)
    if log_scale:
        arr = np.log1p(alpha * arr)
    if norm_stats is not None and log_scale:
        arr = _normalize_rtc(arr, norm_stats)
    return arr


def _copy_npz_array(arr: np.ndarray) -> np.ndarray:
    """Return a detached float32 array from an opened np.load handle."""
    return arr.astype(np.float32, copy=True)


# ---------------------------------------------------------------------------
# Item loaders
# ---------------------------------------------------------------------------

def _load_rtc_item(
    patch_dir: Path,
    patch_id: str,
    log_scale: bool,
    alpha: float,
    use_secondary: bool = False,
    norm_stats: RTCNormStats | None = None,
) -> dict:
    # Both views use the same temporal choice so the cross-view pair stays synchronised.
    # Incidence angle is orbit-geometry only and does not vary with acquisition date.
    prefix = "secondary_rtc" if use_secondary else "prime_rtc"
    return {
        "patch_id":         patch_id,
        "rtc_view_0":       _read_rtc(patch_dir / f"{prefix}_view_0", log_scale, alpha, norm_stats),
        "inc_angle_view_0": _read_tif(_find_file(patch_dir / "incident_angle_view_0", "_incidence_angle.tif")),
        "rtc_view_1":       _read_rtc(patch_dir / f"{prefix}_view_1", log_scale, alpha, norm_stats),
        "inc_angle_view_1": _read_tif(_find_file(patch_dir / "incident_angle_view_1", "_incidence_angle.tif")),
    }


def _load_insar_item(
    patch_dir: Path,
    patch_id: str,
    *,
    dem_root: Path | None = None,
    dem_norm_stats: DEMElevationNormStats | None = None,
    missing_dem: str = "error",
) -> dict:
    item = {
        "patch_id":         patch_id,
        "ifg_view_0":       _read_ifg(patch_dir / "insar_dir_view_0" / "ifg.tif"),
        "coh_view_0":       _read_tif(patch_dir / "insar_dir_view_0" / "coh.tif"),
        "inc_angle_view_0": _read_tif(_find_file(patch_dir / "incident_angle_view_0", "_incidence_angle.tif")),
        "ifg_view_1":       _read_ifg(patch_dir / "insar_dir_view_1" / "ifg.tif"),
        "coh_view_1":       _read_tif(patch_dir / "insar_dir_view_1" / "coh.tif"),
        "inc_angle_view_1": _read_tif(_find_file(patch_dir / "incident_angle_view_1", "_incidence_angle.tif")),
    }
    if dem_root is None:
        return item

    dem_path = dem_root / patch_id / "dem.tif"
    slope_path = dem_root / patch_id / "slope_deg.tif"
    if dem_path.exists() and slope_path.exists():
        dem, dem_relief = _read_dem_global_and_relief(dem_path, dem_norm_stats or DEM_ELEVATION_NORM_STATS)
        slope = _read_slope(slope_path)
    elif missing_dem == "zeros":
        dem = np.zeros((1, 128, 128), dtype=np.float32)
        dem_relief = np.zeros((1, 128, 128), dtype=np.float32)
        slope = np.zeros((1, 128, 128), dtype=np.float32)
    else:
        missing = [str(path) for path in (dem_path, slope_path) if not path.exists()]
        raise FileNotFoundError(f"Missing DEM files for {patch_id}: {missing}")
    # DEM is static per spatial patch, so both orbit views receive the same channel.
    item["dem_view_0"] = dem
    item["dem_view_1"] = dem.copy()
    item["dem_relief_view_0"] = dem_relief
    item["dem_relief_view_1"] = dem_relief.copy()
    item["slope_view_0"] = slope
    item["slope_view_1"] = slope.copy()
    return item


# ---------------------------------------------------------------------------
# PyTorch Dataset wrappers
# ---------------------------------------------------------------------------

class _NASARBase:
    """Shared logic for PyTorch-style NASAR datasets."""

    def __init__(
        self,
        nasar_root: str,
        parquet_path: str,
        years: list[int] | None = None,
        min_quality_score: float | None = None,
    ) -> None:
        self.raw_root = Path(nasar_root)
        # New raw layout: <nasar_root>/NASAR and <nasar_root>/NASAR-Dem.
        # Keep backward compatibility with callers that pass the patch tree directly.
        self.root = self.raw_root / "NASAR" if (self.raw_root / "NASAR").is_dir() else self.raw_root
        need_quality = min_quality_score is not None
        cols = ["patch_id"]
        if years is not None:
            cols.append("prime_date_view_0")
        if need_quality:
            cols.append("quality_score")
        # Read only needed columns; fall back to all columns if quality_score absent
        try:
            df = pd.read_parquet(parquet_path, columns=cols)
        except Exception:
            df = pd.read_parquet(parquet_path)
        if years is not None:
            year_set = set(years)
            prime_years = pd.to_datetime(df["prime_date_view_0"], utc=True).dt.year
            df = df[prime_years.isin(year_set)]
        if need_quality:
            if "quality_score" not in df.columns:
                raise ValueError(
                    "min_quality_score requested but 'quality_score' column not found in "
                    f"{parquet_path}. Run dataset_construction/build_NASAR/rtc_quality_score.py first."
                )
            df = df[df["quality_score"] >= min_quality_score]
        self.patch_ids: list[str] = df["patch_id"].tolist()

    def __len__(self) -> int:
        return len(self.patch_ids)


class NASARRTCDataset(_NASARBase):
    """PyTorch Dataset for RTC contrastive learning.

    Args:
        nasar_root:      Root directory of the NASAR processed patches.
        parquet_path:    Path to the rtc_patch_index parquet metadata file.
        log_scale:       If True (default), applies log1p(alpha · value) to
                         compress the long-tailed linear backscatter distribution.
        alpha:           Scaling factor before log1p (default: 20).
        years:           Optional list of years to filter by prime_date_view_0.
                         Useful for debugging with a small subset of data.
        random_temporal: If True, randomly pick the prime or secondary acquisition
                         at each __getitem__ call.  Both views always use the same
                         temporal choice so the cross-view pair stays synchronised.
                         Effectively doubles dataset diversity.  Default: True.

    Returns dicts with numpy arrays (2, 128, 128) float32 for rtc (VV+VH),
    (1, 128, 128) for inc_angle. DataLoader auto-collates into (B, C, H, W) tensors.
    """

    def __init__(
        self,
        nasar_root: str,
        parquet_path: str,
        log_scale: bool = True,
        alpha: float = 20.0,
        years: list[int] | None = None,
        random_temporal: bool = True,
        min_quality_score: float | None = 0.53,
        norm_stats: RTCNormStats | None = DEFAULT_RTC_NORM_STATS,
    ) -> None:
        super().__init__(nasar_root, parquet_path, years=years, min_quality_score=min_quality_score)
        self.log_scale = log_scale
        self.alpha = alpha
        self.random_temporal = random_temporal
        self.norm_stats = norm_stats

        # Pre-scan rtc directories once so __getitem__ needs no iterdir syscalls.
        # Stored as list[tuple] parallel to self.patch_ids.
        # Each entry: (prime_v0_copol, prime_v0_xpol, prime_v1_copol, prime_v1_xpol,
        #              sec_v0_copol,   sec_v0_xpol,   sec_v1_copol,   sec_v1_xpol,
        #              inc_v0, inc_v1)
        self._path_cache: list[tuple] = []
        for pid in self.patch_ids:
            d = self.root / pid
            pv0c, pv0x = _scan_rtc_dir(d / "prime_rtc_view_0")
            pv1c, pv1x = _scan_rtc_dir(d / "prime_rtc_view_1")
            sv0c, sv0x = _scan_rtc_dir(d / "secondary_rtc_view_0")
            sv1c, sv1x = _scan_rtc_dir(d / "secondary_rtc_view_1")
            try:
                ia0 = _find_file(d / "incident_angle_view_0", "_incidence_angle.tif")
                ia1 = _find_file(d / "incident_angle_view_1", "_incidence_angle.tif")
            except FileNotFoundError:
                ia0 = ia1 = None
            self._path_cache.append((pv0c, pv0x, pv1c, pv1x,
                                     sv0c, sv0x, sv1c, sv1x, ia0, ia1))

    def __getitem__(self, idx: int) -> dict:
        patch_id = self.patch_ids[idx]
        pv0c, pv0x, pv1c, pv1x, sv0c, sv0x, sv1c, sv1x, ia0, ia1 = self._path_cache[idx]
        use_secondary = self.random_temporal and bool(np.random.randint(2))

        if use_secondary:
            c0, x0, c1, x1 = sv0c, sv0x, sv1c, sv1x
        else:
            c0, x0, c1, x1 = pv0c, pv0x, pv1c, pv1x

        def _load(copol, xpol, rtc_label: str):
            if copol is None and xpol is None:
                raise FileNotFoundError(
                    f"No backscatter tif (VV/VH/HH/HV) found for patch "
                    f"{patch_id} in {rtc_label}"
                )
            arr0 = _read_rtc_band(copol, self.log_scale, self.alpha) if copol else None
            arr1 = _read_rtc_band(xpol,  self.log_scale, self.alpha) if xpol  else None
            if arr0 is None: arr0 = np.zeros_like(arr1)
            if arr1 is None: arr1 = np.zeros_like(arr0)
            out = _center_crop(np.stack([arr0, arr1], axis=0))
            if self.norm_stats is not None and self.log_scale:
                out = _normalize_rtc(out, self.norm_stats)
            return out

        return {
            "patch_id":         patch_id,
            "rtc_view_0":       _load(c0, x0, "view_0"),
            "inc_angle_view_0": _read_tif(ia0) if ia0 else np.zeros((1, 128, 128), np.float32),
            "rtc_view_1":       _load(c1, x1, "view_1"),
            "inc_angle_view_1": _read_tif(ia1) if ia1 else np.zeros((1, 128, 128), np.float32),
        }


class NASARInSARDataset(_NASARBase):
    """PyTorch Dataset for InSAR contrastive learning.

    Args:
        nasar_root:   Root directory of the NASAR processed patches.
        parquet_path: Path to the rtc_patch_index parquet metadata file.
        years:        Optional list of years to filter by prime_date_view_0.
                      Useful for debugging with a small subset of data.
        include_dem:  If True, load <nasar_root>/NASAR-Dem/<patch_id>/dem.tif
                      and slope_deg.tif. Adds global-normalized elevation,
                      patch-local relief, and slope channels.

    Returns dicts with numpy arrays (1, 128, 128) or (2, 128, 128) float32.
    DataLoader auto-collates these into (B, C, H, W) tensors.
    """

    def __init__(
        self,
        nasar_root: str,
        parquet_path: str,
        years: list[int] | None = None,
        min_quality_score: float | None = None,
        include_dem: bool = True,
        missing_dem: str = "error",
        dem_norm_stats: DEMElevationNormStats = DEM_ELEVATION_NORM_STATS,
    ) -> None:
        super().__init__(nasar_root, parquet_path, years=years, min_quality_score=min_quality_score)
        if missing_dem not in {"error", "zeros"}:
            raise ValueError("missing_dem must be one of: error, zeros")
        self.dem_root = self.raw_root / DEFAULT_DEM_SUBDIR if include_dem else None
        self.dem_norm_stats = dem_norm_stats
        self.missing_dem = missing_dem

    def __getitem__(self, idx: int) -> dict:
        patch_id = self.patch_ids[idx]
        return _load_insar_item(
            self.root / patch_id,
            patch_id,
            dem_root=self.dem_root,
            dem_norm_stats=self.dem_norm_stats,
            missing_dem=self.missing_dem,
        )


# ---------------------------------------------------------------------------
# WebDataset-style tar shard datasets
# ---------------------------------------------------------------------------

def _dist_info() -> tuple[int, int]:
    """Return (rank, world_size), defaulting to single-process training."""
    if dist.is_available() and dist.is_initialized():
        return dist.get_rank(), dist.get_world_size()
    return int(os.environ.get("RANK", 0)), int(os.environ.get("WORLD_SIZE", 1))


class _NASARShardDataset(IterableDataset):
    """Shared streaming logic for NA-SAR WebDataset tar shards."""

    def __init__(
        self,
        nasar_root: str = "/datasets/disk3/NA-SAR-HF",
        shard_pattern: str = "data/nasar-train-*.tar",
        shuffle_shards: bool = True,
        shuffle_buffer: int = 2048,
        seed: int = 0,
    ) -> None:
        self.root = Path(nasar_root)
        self.shard_pattern = shard_pattern
        self.shuffle_shards = shuffle_shards
        self.shuffle_buffer = shuffle_buffer
        self.seed = seed
        self.shards = sorted(self.root.glob(shard_pattern))
        if not self.shards:
            raise FileNotFoundError(f"No shards matched {self.root / shard_pattern}")
        self._length = self._read_length()

    def _read_length(self) -> int:
        summary_path = self.root / "webdataset_summary.json"
        if summary_path.exists():
            with open(summary_path) as f:
                summary = json.load(f)
            if "samples" in summary:
                return int(summary["samples"])
        metadata_path = self.root / "metadata.parquet"
        if metadata_path.exists():
            return len(pd.read_parquet(metadata_path, columns=["sample_key"]))
        return 0

    def __len__(self) -> int:
        _, world_size = _dist_info()
        return (self._length + world_size - 1) // world_size

    def _assigned_shards(self) -> list[Path]:
        rank, world_size = _dist_info()
        worker = get_worker_info()
        worker_id = worker.id if worker is not None else 0
        num_workers = worker.num_workers if worker is not None else 1
        partition = rank * num_workers + worker_id
        partitions = world_size * num_workers
        shards = [s for i, s in enumerate(self.shards) if i % partitions == partition]
        if self.shuffle_shards:
            rng = np.random.default_rng(self.seed + rank * 1009 + worker_id)
            rng.shuffle(shards)
        return shards

    def _iter_npz_samples(self):
        for shard in self._assigned_shards():
            with tarfile.open(shard, "r|") as tar:
                for member in tar:
                    if not member.isfile() or not member.name.endswith(".npz"):
                        continue
                    extracted = tar.extractfile(member)
                    if extracted is None:
                        continue
                    data = extracted.read()
                    with np.load(BytesIO(data)) as z:
                        yield member.name[:-4], z

    def __iter__(self):
        iterator = (self._decode_sample(key, z) for key, z in self._iter_npz_samples())
        if self.shuffle_buffer <= 1:
            yield from iterator
            return

        rank, _ = _dist_info()
        worker = get_worker_info()
        worker_id = worker.id if worker is not None else 0
        rng = np.random.default_rng(self.seed + rank * 1009 + worker_id)
        buffer: list[dict] = []
        for item in iterator:
            buffer.append(item)
            if len(buffer) >= self.shuffle_buffer:
                j = int(rng.integers(len(buffer)))
                yield buffer.pop(j)
        while buffer:
            j = int(rng.integers(len(buffer)))
            yield buffer.pop(j)

    def _decode_sample(self, key: str, z) -> dict:
        raise NotImplementedError


class NASARWebRTCDataset(_NASARShardDataset):
    """Streaming tar-shard dataset for RTC pretraining.

    The shards store raw linear RTC backscatter, so this class applies the same
    log compression and normalization as NASARRTCDataset by default.
    """

    def __init__(
        self,
        nasar_root: str = "/datasets/disk3/NA-SAR-HF",
        shard_pattern: str = "data/nasar-train-*.tar",
        log_scale: bool = True,
        alpha: float = 20.0,
        random_temporal: bool = True,
        norm_stats: RTCNormStats | None = DEFAULT_RTC_NORM_STATS,
        shuffle_shards: bool = True,
        shuffle_buffer: int = 2048,
        seed: int = 0,
    ) -> None:
        super().__init__(
            nasar_root=nasar_root,
            shard_pattern=shard_pattern,
            shuffle_shards=shuffle_shards,
            shuffle_buffer=shuffle_buffer,
            seed=seed,
        )
        self.log_scale = log_scale
        self.alpha = alpha
        self.random_temporal = random_temporal
        self.norm_stats = norm_stats

    def _decode_sample(self, key: str, z) -> dict:
        prefix = "secondary_rtc" if self.random_temporal and bool(np.random.randint(2)) else "prime_rtc"
        return {
            "patch_id":         key,
            "rtc_view_0":       _prepare_npz_rtc(
                z[f"{prefix}_view_0"], self.log_scale, self.alpha, self.norm_stats
            ),
            "inc_angle_view_0": _copy_npz_array(z["inc_angle_view_0"]),
            "rtc_view_1":       _prepare_npz_rtc(
                z[f"{prefix}_view_1"], self.log_scale, self.alpha, self.norm_stats
            ),
            "inc_angle_view_1": _copy_npz_array(z["inc_angle_view_1"]),
        }


class NASARWebInSARDataset(_NASARShardDataset):
    """Streaming tar-shard dataset for InSAR pretraining."""

    def __init__(
        self,
        nasar_root: str = "/datasets/disk3/NA-SAR-HF",
        shard_pattern: str = "data/nasar-train-*.tar",
        shuffle_shards: bool = True,
        shuffle_buffer: int = 2048,
        seed: int = 0,
        require_dem: bool = False,
        dem_norm_stats: DEMElevationNormStats = DEM_ELEVATION_NORM_STATS,
        dem_relief_percentiles: DEMElevationNormStats = DEM_RELIEF_PERCENTILES,
        slope_norm_stats: DEMElevationNormStats = DEM_SLOPE_DEG_NORM_STATS,
    ) -> None:
        super().__init__(
            nasar_root=nasar_root,
            shard_pattern=shard_pattern,
            shuffle_shards=shuffle_shards,
            shuffle_buffer=shuffle_buffer,
            seed=seed,
        )
        self.require_dem = require_dem
        self.dem_norm_stats = dem_norm_stats
        self.dem_relief_percentiles = dem_relief_percentiles
        self.slope_norm_stats = slope_norm_stats

    def _decode_static_dem(self, key: str, z) -> dict[str, np.ndarray]:
        if {"dem", "slope_deg"}.issubset(z.files):
            dem, dem_relief = _normalize_dem_global_and_relief_array(
                z["dem"],
                norm_stats=self.dem_norm_stats,
                relief_percentiles=self.dem_relief_percentiles,
            )
            slope = _normalize_slope_array(z["slope_deg"], norm_stats=self.slope_norm_stats)
        elif {"dem", "dem_relief", "slope"}.issubset(z.files):
            dem = _copy_npz_array(z["dem"])
            dem_relief = _copy_npz_array(z["dem_relief"])
            slope = _copy_npz_array(z["slope"])
        elif {"dem_view_0", "dem_relief_view_0", "slope_view_0"}.issubset(z.files):
            dem = _copy_npz_array(z["dem_view_0"])
            dem_relief = _copy_npz_array(z["dem_relief_view_0"])
            slope = _copy_npz_array(z["slope_view_0"])
        else:
            raise KeyError(
                f"Sample {key} has no DEM arrays. Expected static keys "
                "'dem' and 'slope_deg' for raw DEM, or legacy processed "
                "'dem', 'dem_relief', 'slope' arrays."
            )
        return {
            "dem_view_0": dem,
            "dem_view_1": dem.copy(),
            "dem_relief_view_0": dem_relief,
            "dem_relief_view_1": dem_relief.copy(),
            "slope_view_0": slope,
            "slope_view_1": slope.copy(),
        }

    def _decode_sample(self, key: str, z) -> dict:
        item = {
            "patch_id":         key,
            "ifg_view_0":       _copy_npz_array(z["ifg_view_0"]),
            "coh_view_0":       _copy_npz_array(z["coh_view_0"]),
            "inc_angle_view_0": _copy_npz_array(z["inc_angle_view_0"]),
            "ifg_view_1":       _copy_npz_array(z["ifg_view_1"]),
            "coh_view_1":       _copy_npz_array(z["coh_view_1"]),
            "inc_angle_view_1": _copy_npz_array(z["inc_angle_view_1"]),
        }
        try:
            item.update(self._decode_static_dem(key, z))
        except KeyError:
            if self.require_dem:
                raise
        return item