code/dataloader.py

from __future__ import annotations

import argparse
import json
import shutil
from datetime import datetime, timezone
from pathlib import Path
from typing import Iterable

import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler


PROJECT_ROOT = Path(".")
PATCH_SIZE = 29
CELLS_PER_PATCH = PATCH_SIZE * PATCH_SIZE
WEATHER_DAY_MAP = {
    1: [0],
    2: [-1, 0],
    3: [-2, -1, 0],
    4: [-3, -2, -1, 0],
    5: [-4, -3, -2, -1, 0],
}

TASKS = {
    "ia_failure": {
        "target_column": "ia_failure_label",
        "task_type": "binary_classification",
        "raw_column": None,
    },
    "containment_time": {
        "target_column": "log_containment_hours",
        "task_type": "regression",
        "raw_column": "containment_hours",
    },
}

PROTOCOL_GROUPS = {
    "metadata": ["metadata"],
    "firms": ["fire_strict"],
    "fire": ["fire_strict"],
    "fire_wide": ["fire_strict", "fire_wide"],
    "weather": ["weather_aggregate", "fire_danger_aggregate"],
    "fuel": ["fuel"],
    "vegetation": ["vegetation"],
    "topography": ["topography"],
    "access": ["access"],
    "human": ["human"],
    "metadata_vegetation": ["metadata", "vegetation"],
    "metadata_fuel": ["metadata", "fuel"],
    "metadata_topography": ["metadata", "topography"],
    "metadata_access": ["metadata", "access"],
    "metadata_human": ["metadata", "human"],
    "all": [
        "metadata",
        "fire_strict",
        "weather_aggregate",
        "fire_danger_aggregate",
        "fuel",
        "vegetation",
        "topography",
        "access",
        "human",
    ],
    "all_without_fire": [
        "metadata",
        "weather_aggregate",
        "fire_danger_aggregate",
        "fuel",
        "vegetation",
        "topography",
        "access",
        "human",
    ],
    "all_without_weather": [
        "metadata",
        "fire_strict",
        "fuel",
        "vegetation",
        "topography",
        "access",
        "human",
    ],
    "all_without_vegetation": [
        "metadata",
        "fire_strict",
        "weather_aggregate",
        "fire_danger_aggregate",
        "fuel",
        "topography",
        "access",
        "human",
    ],
    "all_without_fuel": [
        "metadata",
        "fire_strict",
        "weather_aggregate",
        "fire_danger_aggregate",
        "vegetation",
        "topography",
        "access",
        "human",
    ],
    "all_without_topography": [
        "metadata",
        "fire_strict",
        "weather_aggregate",
        "fire_danger_aggregate",
        "fuel",
        "vegetation",
        "access",
        "human",
    ],
    "all_without_access": [
        "metadata",
        "fire_strict",
        "weather_aggregate",
        "fire_danger_aggregate",
        "fuel",
        "vegetation",
        "topography",
        "human",
    ],
    "all_without_human": [
        "metadata",
        "fire_strict",
        "weather_aggregate",
        "fire_danger_aggregate",
        "fuel",
        "vegetation",
        "topography",
        "access",
    ],
}

TEMPORAL_WEATHER_CHANNELS = [
    "tmmx",
    "tmmn",
    "pr",
    "rmax",
    "rmin",
    "sph",
    "vpd",
    "vs",
    "srad",
    "erc",
    "bi",
    "fm100",
    "fm1000",
    "wind_dir_sin",
    "wind_dir_cos",
]

FUEL_PATCH_CHANNELS = ["fbfm40", "cbd", "cbh", "cc", "ch", "fd", "fvt", "fvc", "fvh"]
VEGETATION_PATCH_CHANNELS = ["evt", "evc", "evh"]
STATIC_PATCH_CHANNELS = [*FUEL_PATCH_CHANNELS, *VEGETATION_PATCH_CHANNELS, "elev", "slope", "aspect_sin", "aspect_cos", "pop_density"]
VIIRS_PATCH_CHANNELS = [
    "viirs_cell_count_D",
    "viirs_cell_sum_frp_D",
    "viirs_cell_max_frp_D",
    "viirs_cell_mean_frp_D",
    "viirs_cell_max_bright_ti4_D",
    "viirs_cell_mean_bright_ti4_D",
    "viirs_cell_day_count_D",
    "viirs_cell_night_count_D",
    "viirs_cell_has_detection_D",
]
OSM_PATCH_CHANNELS = [
    "cell_distance_to_nearest_drivable_road_m",
    "cell_distance_to_nearest_fire_station_m",
    "cell_road_length_375m_m",
    "cell_has_drivable_road",
    "cell_distance_to_nearest_major_road_m",
    "cell_distance_to_nearest_track_or_service_road_m",
]
TOPO_PATCH_CHANNELS = ["elev", "slope", "aspect_sin", "aspect_cos"]
PATCH_METADATA_CHANNELS = ["lat", "lon", "discovery_month", "discovery_doy", "discovery_hour"]

KNOWN_CATEGORICAL_COLUMNS = {
    "state",
    "county",
    "cause_classification",
    "general_cause",
    "fbfm40_point",
    "fd_point",
    "fvt_point",
    "fvc_point",
    "fvh_point",
    "evt_point",
    "evc_point",
    "evh_point",
    "fbfm40_mode_1km",
    "fbfm40_mode_3km",
    "fbfm40_mode_5km",
    "fd_mode_1km",
    "fd_mode_3km",
    "fd_mode_5km",
    "fvt_mode_1km",
    "fvt_mode_3km",
    "fvt_mode_5km",
    "fvc_mode_1km",
    "fvc_mode_3km",
    "fvc_mode_5km",
    "fvh_mode_1km",
    "fvh_mode_3km",
    "fvh_mode_5km",
    "evt_mode_1km",
    "evt_mode_3km",
    "evt_mode_5km",
    "evc_mode_1km",
    "evc_mode_3km",
    "evc_mode_5km",
    "evh_mode_1km",
    "evh_mode_3km",
    "evh_mode_5km",
}

CORE_INDEX_COLUMNS = {"fire_id", "year", "split"}


def protocol_groups(input_protocol: str) -> list[str]:
    if input_protocol not in PROTOCOL_GROUPS:
        raise KeyError(f"Unknown input_protocol: {input_protocol}")
    return PROTOCOL_GROUPS[input_protocol]


def protocol_includes_weather(input_protocol: str) -> bool:
    groups = protocol_groups(input_protocol)
    return "weather_aggregate" in groups or "fire_danger_aggregate" in groups


def ensure_project_path(path: Path) -> Path:
    resolved = path.resolve()
    if not str(resolved).startswith(str(PROJECT_ROOT)):
        raise ValueError(f"Path must stay inside {PROJECT_ROOT}: {resolved}")
    return resolved


def load_json(path: Path) -> dict:
    with path.open("r", encoding="utf-8") as file:
        return json.load(file)


def write_json(path: Path, payload: dict) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8") as file:
        json.dump(payload, file, indent=2, sort_keys=True)
        file.write("\n")


def remove_output_dir(path: Path, overwrite: bool) -> None:
    if path.exists() and overwrite:
        shutil.rmtree(path)
    path.mkdir(parents=True, exist_ok=True)


def created_at() -> str:
    return datetime.now(timezone.utc).isoformat()


def canonical_paths(canonical_dir: Path) -> dict[str, Path]:
    return {
        "master": canonical_dir / "master_features_natural_2016_2020.parquet",
        "weather_daily_event": canonical_dir / "gridmet_daily_event_features_natural_2016_2020.parquet",
        "grid_index": canonical_dir / "event_grid_375m_index_natural_2016_2020.parquet",
        "static_patch": canonical_dir / "event_static_patch_375m_natural_2016_2020.parquet",
        "viirs_patch": canonical_dir / "event_viirs_patch_375m_D_natural_2016_2020.parquet",
        "weather_daily_patch": canonical_dir / "event_weather_daily_patch_375m_natural_2016_2020.parquet",
        "weather_aggregate_patch": canonical_dir / "event_weather_aggregate_patch_375m_natural_2016_2020.parquet",
        "osm_patch": canonical_dir / "event_osm_patch_375m_natural_2016_2020.parquet",
        "feature_manifest": canonical_dir / "feature_manifest_natural.json",
        "label_manifest": canonical_dir / "label_manifest_natural.json",
        "patch_manifest": canonical_dir / "event_patch_manifest_375m_natural.json",
        "temporal_manifest": canonical_dir / "temporal_protocol_manifest_natural.json",
    }


def required_path_keys() -> list[str]:
    return [
        "master",
        "weather_daily_event",
        "grid_index",
        "static_patch",
        "viirs_patch",
        "weather_daily_patch",
        "weather_aggregate_patch",
        "osm_patch",
        "feature_manifest",
        "label_manifest",
        "patch_manifest",
        "temporal_manifest",
    ]


def load_manifests(paths: dict[str, Path]) -> tuple[dict, dict, dict, dict]:
    return (
        load_json(paths["feature_manifest"]),
        load_json(paths["label_manifest"]),
        load_json(paths["patch_manifest"]),
        load_json(paths["temporal_manifest"]),
    )


def output_subdir(output_dir: Path, task: str, representation: str, weather_days: int, input_protocol: str) -> Path:
    return output_dir / task / representation / f"weather{weather_days}_{input_protocol}"


def target_info(task: str) -> dict:
    if task not in TASKS:
        raise KeyError(f"Unknown task: {task}")
    return TASKS[task]


def filter_task_samples(master: pd.DataFrame, task: str) -> pd.DataFrame:
    info = target_info(task)
    target_col = info["target_column"]
    if target_col not in master.columns:
        raise KeyError(f"Target column not found in master_features: {target_col}")
    filtered = master.loc[master[target_col].notna()].copy()
    filtered["target"] = filtered[target_col]
    if task == "ia_failure":
        filtered["target"] = filtered["target"].astype(int)
    return filtered


def apply_input_protocol_sample_filter(samples: pd.DataFrame, input_protocol: str) -> pd.DataFrame:
    """Apply protocol-level sample restrictions without changing task labels."""
    if input_protocol != "firms":
        return samples
    match_col = "viirs_num_assigned_detections_D"
    fallback_col = "has_viirs_detection_1km_D"
    filtered = samples.copy()
    if match_col in filtered.columns:
        mask = pd.to_numeric(filtered[match_col], errors="coerce").fillna(0) > 0
    elif fallback_col in filtered.columns:
        mask = pd.to_numeric(filtered[fallback_col], errors="coerce").fillna(0) > 0
    else:
        raise KeyError(
            "input_protocol=firms requires viirs_num_assigned_detections_D "
            "or has_viirs_detection_1km_D in master_features."
        )
    before = len(filtered)
    filtered = filtered.loc[mask].copy()
    print(f"FIRMS-only sample filter retained {len(filtered)} / {before} task samples.")
    return filtered


def normalize_master_metadata(master: pd.DataFrame) -> pd.DataFrame:
    master = master.copy()
    if "year" not in master.columns:
        for candidate in ["year_x", "year_y", "FIRE_YEAR"]:
            if candidate in master.columns:
                master["year"] = master[candidate]
                break
    if "split" not in master.columns and "split_x" in master.columns:
        master["split"] = master["split_x"]
    if "year" in master.columns:
        master["year"] = pd.to_numeric(master["year"], errors="coerce").astype("Int64")
    return master


def build_sample_index(samples: pd.DataFrame, master: pd.DataFrame, task: str) -> pd.DataFrame:
    samples = normalize_master_metadata(samples)
    master = normalize_master_metadata(master)
    info = target_info(task)
    target_col = info["target_column"]
    raw_col = info["raw_column"]
    sample_index = samples.copy()
    recover_cols = ["fire_id", "year", "split", target_col]
    if raw_col:
        recover_cols.append(raw_col)
    missing = [col for col in recover_cols if col not in sample_index.columns]
    if missing:
        recovered = master[[col for col in recover_cols if col in master.columns]].copy()
        recovered["fire_id"] = recovered["fire_id"].astype(str)
        sample_index["fire_id"] = sample_index["fire_id"].astype(str)
        sample_index = sample_index.merge(recovered, on="fire_id", how="left", suffixes=("", "_from_master"))
        for col in missing:
            from_master = f"{col}_from_master"
            if from_master in sample_index.columns:
                sample_index[col] = sample_index[from_master]

    if target_col not in sample_index.columns and "target" in sample_index.columns:
        sample_index[target_col] = sample_index["target"]
    required = ["fire_id", "year", "split", target_col]
    if raw_col:
        required.append(raw_col)
    still_missing = [col for col in required if col not in sample_index.columns]
    if still_missing:
        raise KeyError(f"Sample index is missing required metadata columns: {still_missing}")
    sample_index = sample_index[required].copy()
    sample_index["fire_id"] = sample_index["fire_id"].astype(str)
    return sample_index


def split_frames(samples: pd.DataFrame) -> dict[str, pd.DataFrame]:
    return {
        "train": samples.loc[samples["split"] == "train"].copy(),
        "val": samples.loc[samples["split"] == "val"].copy(),
        "test": samples.loc[samples["split"] == "test"].copy(),
    }


def split_years(split: str) -> list[int]:
    if split == "train":
        return [2016, 2017, 2018]
    if split == "val":
        return [2019]
    if split == "test":
        return [2020]
    raise ValueError(split)


def weather_feature_allowed(col: str, weather_days: int) -> bool:
    suffix_windows = {
        "lag1": 2,
        "mean2": 2,
        "sum2": 2,
        "mean3": 3,
        "sum3": 3,
        "mean4": 4,
        "sum4": 4,
        "mean5": 5,
        "sum5": 5,
    }
    if col.endswith("_day0"):
        return True
    for suffix, min_days in suffix_windows.items():
        if col.endswith(f"_{suffix}"):
            return weather_days >= min_days
    return True


def requested_feature_columns(
    feature_manifest: dict,
    input_protocol: str,
    weather_days: int,
    master_columns: Iterable[str],
    target_col: str,
) -> tuple[list[str], list[str]]:
    forbidden = set(feature_manifest.get("forbidden_as_features", []))
    forbidden.update(
        [
            target_col,
            "fire_size_acres",
            "fire_size_ha",
            "ia_failure_label",
            "contain_dt",
            "containment_hours",
            "log_containment_hours",
            "log_fire_size_ha",
        ]
    )
    master_columns = set(master_columns)
    requested = []
    for group in protocol_groups(input_protocol):
        requested.extend(feature_manifest.get(group, []))
    requested = list(dict.fromkeys(requested))
    removed = [col for col in requested if col in forbidden]
    selected = []
    missing = []
    for col in requested:
        if col in forbidden:
            continue
        if col not in master_columns:
            missing.append(col)
            continue
        if col in feature_manifest.get("weather_aggregate", []) or col in feature_manifest.get("fire_danger_aggregate", []):
            if not weather_feature_allowed(col, weather_days):
                removed.append(col)
                continue
        selected.append(col)
    return selected, sorted(set(removed + missing))


def static_protocol_columns(
    feature_manifest: dict,
    input_protocol: str,
    weather_days: int,
    master_columns: Iterable[str],
    target_col: str,
) -> tuple[list[str], list[str]]:
    if input_protocol == "weather":
        return [], []
    if input_protocol == "all" or input_protocol.startswith("all_without_"):
        groups = [
            group
            for group in protocol_groups(input_protocol)
            if group not in {"weather_aggregate", "fire_danger_aggregate"}
        ]
    elif input_protocol == "fire_wide":
        groups = ["fire_strict", "fire_wide"]
    else:
        groups = protocol_groups(input_protocol)
    pseudo_manifest = dict(feature_manifest)
    selected_requested = []
    for group in groups:
        selected_requested.extend(feature_manifest.get(group, []))
    pseudo_manifest["_static"] = selected_requested
    old = PROTOCOL_GROUPS.get("_static")
    PROTOCOL_GROUPS["_static"] = ["_static"]
    try:
        cols, removed = requested_feature_columns(pseudo_manifest, "_static", weather_days, master_columns, target_col)
    finally:
        if old is None:
            PROTOCOL_GROUPS.pop("_static", None)
        else:
            PROTOCOL_GROUPS["_static"] = old
    return cols, removed


def infer_categorical_columns(df: pd.DataFrame, columns: list[str]) -> list[str]:
    categorical = []
    for col in columns:
        if col in KNOWN_CATEGORICAL_COLUMNS:
            categorical.append(col)
        elif (
            pd.api.types.is_object_dtype(df[col])
            or pd.api.types.is_string_dtype(df[col])
            or isinstance(df[col].dtype, pd.CategoricalDtype)
        ):
            categorical.append(col)
    return categorical


def fit_transform_event_features(
    train_df: pd.DataFrame,
    val_df: pd.DataFrame,
    test_df: pd.DataFrame,
    feature_cols: list[str],
    standardize: bool,
) -> tuple[dict[str, np.ndarray], list[str], dict]:
    if not feature_cols:
        arrays = {
            "train": np.zeros((len(train_df), 0), dtype=np.float32),
            "val": np.zeros((len(val_df), 0), dtype=np.float32),
            "test": np.zeros((len(test_df), 0), dtype=np.float32),
        }
        return arrays, [], {
            "categorical_columns": [],
            "numeric_columns": [],
            "imputer_policy": "none",
            "scaler_policy": "none",
        }

    categorical_cols = infer_categorical_columns(train_df, feature_cols)
    numeric_cols = [col for col in feature_cols if col not in categorical_cols]

    numeric_train = train_df[numeric_cols].apply(pd.to_numeric, errors="coerce") if numeric_cols else pd.DataFrame(index=train_df.index)
    numeric_val = val_df[numeric_cols].apply(pd.to_numeric, errors="coerce") if numeric_cols else pd.DataFrame(index=val_df.index)
    numeric_test = test_df[numeric_cols].apply(pd.to_numeric, errors="coerce") if numeric_cols else pd.DataFrame(index=test_df.index)

    medians = numeric_train.median()
    medians = medians.fillna(0.0)
    numeric_train = numeric_train.fillna(medians)
    numeric_val = numeric_val.fillna(medians)
    numeric_test = numeric_test.fillna(medians)

    scaler_metadata = {"standardize": bool(standardize), "mean": {}, "scale": {}}
    if standardize and numeric_cols:
        scaler = StandardScaler()
        train_numeric_values = scaler.fit_transform(numeric_train.to_numpy(dtype=np.float64))
        val_numeric_values = scaler.transform(numeric_val.to_numpy(dtype=np.float64))
        test_numeric_values = scaler.transform(numeric_test.to_numpy(dtype=np.float64))
        scaler_metadata["mean"] = dict(zip(numeric_cols, scaler.mean_.tolist()))
        scaler_metadata["scale"] = dict(zip(numeric_cols, scaler.scale_.tolist()))
    else:
        train_numeric_values = numeric_train.to_numpy(dtype=np.float64)
        val_numeric_values = numeric_val.to_numpy(dtype=np.float64)
        test_numeric_values = numeric_test.to_numpy(dtype=np.float64)

    if categorical_cols:
        train_cat = pd.get_dummies(train_df[categorical_cols].fillna("Unknown").astype(str), columns=categorical_cols)
        val_cat = pd.get_dummies(val_df[categorical_cols].fillna("Unknown").astype(str), columns=categorical_cols)
        test_cat = pd.get_dummies(test_df[categorical_cols].fillna("Unknown").astype(str), columns=categorical_cols)
        cat_cols = list(train_cat.columns)
        val_cat = val_cat.reindex(columns=cat_cols, fill_value=0)
        test_cat = test_cat.reindex(columns=cat_cols, fill_value=0)
        train_values = np.concatenate([train_numeric_values, train_cat.to_numpy(dtype=np.float64)], axis=1)
        val_values = np.concatenate([val_numeric_values, val_cat.to_numpy(dtype=np.float64)], axis=1)
        test_values = np.concatenate([test_numeric_values, test_cat.to_numpy(dtype=np.float64)], axis=1)
    else:
        cat_cols = []
        train_values = train_numeric_values
        val_values = val_numeric_values
        test_values = test_numeric_values

    feature_names = numeric_cols + cat_cols
    arrays = {
        "train": train_values.astype(np.float32),
        "val": val_values.astype(np.float32),
        "test": test_values.astype(np.float32),
    }
    metadata = {
        "categorical_columns": categorical_cols,
        "numeric_columns": numeric_cols,
        "categorical_encoder": "pandas.get_dummies_fit_on_train_align_val_test",
        "categorical_dummy_columns": cat_cols,
        "imputer_policy": "numeric train median, categorical Unknown",
        "numeric_medians": medians.to_dict(),
        "scaler_policy": "StandardScaler fit on train numeric columns" if standardize and numeric_cols else "not_standardized",
        "scaler": scaler_metadata,
    }
    return arrays, feature_names, metadata


def write_sample_index_outputs(
    out_dir: Path,
    split: str,
    n_rows: int,
    y: np.ndarray,
    sample_index: pd.DataFrame,
    task: str,
) -> None:
    target_col = target_info(task)["target_column"]
    raw_col = target_info(task)["raw_column"]
    expected_cols = ["fire_id", "year", "split", target_col]
    if raw_col:
        expected_cols.append(raw_col)
    missing = [col for col in expected_cols if col not in sample_index.columns]
    if missing:
        raise KeyError(f"sample_index for {split} missing columns: {missing}")
    if n_rows != len(y):
        raise ValueError(f"{split}: n_rows={n_rows} does not match len(y)={len(y)}")
    if n_rows != len(sample_index):
        raise ValueError(f"{split}: n_rows={n_rows} does not match len(sample_index)={len(sample_index)}")
    target_values = sample_index[target_col].to_numpy()
    if not np.allclose(y.astype(float), target_values.astype(float), equal_nan=True):
        raise ValueError(f"{split}: y array order/values do not match sample_index {target_col}")
    fire_ids = sample_index["fire_id"].astype(str).to_numpy()
    if len(fire_ids) != n_rows:
        raise ValueError(f"{split}: fire_id order length does not match row count")

    np.save(out_dir / f"y_{split}.npy", y)
    np.save(out_dir / f"fire_id_{split}.npy", fire_ids)
    saved_fire_ids = np.load(out_dir / f"fire_id_{split}.npy", allow_pickle=True).astype(str)
    if not np.array_equal(saved_fire_ids, fire_ids):
        raise ValueError(f"{split}: saved fire_id array does not match sample_index order")
    if raw_col:
        np.save(out_dir / f"{raw_col}_{split}.npy", sample_index[raw_col].to_numpy(dtype=np.float32))
    sample_index[expected_cols].to_parquet(out_dir / f"sample_index_{split}.parquet", index=False)


def write_split_outputs(
    out_dir: Path,
    split: str,
    X: np.ndarray,
    y: np.ndarray,
    sample_index: pd.DataFrame,
    task: str,
) -> None:
    write_sample_index_outputs(out_dir, split, len(X), y, sample_index, task)
    np.save(out_dir / f"X_{split}.npy", X)


def write_seq_split_outputs(
    out_dir: Path,
    split: str,
    X_seq: np.ndarray,
    X_static: np.ndarray,
    y: np.ndarray,
    sample_index: pd.DataFrame,
    task: str,
) -> None:
    if len(X_seq) != len(y):
        raise ValueError(f"{split}: len(X_seq)={len(X_seq)} does not match len(y)={len(y)}")
    if len(X_static) != len(y):
        raise ValueError(f"{split}: len(X_static)={len(X_static)} does not match len(y)={len(y)}")
    write_sample_index_outputs(out_dir, split, len(X_seq), y, sample_index, task)
    np.save(out_dir / f"X_seq_{split}.npy", X_seq)
    np.save(out_dir / f"X_static_{split}.npy", X_static)


def save_metadata(out_dir: Path, metadata: dict) -> None:
    write_json(out_dir / "metadata.json", metadata)


def build_tabular_cache(args, paths: dict[str, Path], feature_manifest: dict) -> Path:
    out_dir = output_subdir(args.output_dir, args.task, "tabular", args.weather_days, args.input_protocol)
    if (out_dir / "X_train.npy").exists() and not args.overwrite:
        print(f"Reusing existing tabular cache: {out_dir}")
        return out_dir
    remove_output_dir(out_dir, args.overwrite)

    master = normalize_master_metadata(read_parquet_robust(paths["master"]))
    samples = apply_input_protocol_sample_filter(filter_task_samples(master, args.task), args.input_protocol)
    splits = split_frames(samples)
    sample_index_splits = split_frames(build_sample_index(samples, master, args.task))
    target_col = target_info(args.task)["target_column"]
    feature_cols, removed = requested_feature_columns(
        feature_manifest, args.input_protocol, args.weather_days, master.columns, target_col
    )
    arrays, feature_names, preprocessing = fit_transform_event_features(
        splits["train"], splits["val"], splits["test"], feature_cols, args.standardize
    )
    for split, frame in splits.items():
        y = frame["target"].to_numpy(dtype=np.float32)
        write_split_outputs(out_dir, split, arrays[split], y, sample_index_splits[split], args.task)
    write_json(out_dir / "feature_names.json", {"feature_names": feature_names})
    save_metadata(
        out_dir,
        {
            "task": args.task,
            "representation": "tabular",
            "input_protocol": args.input_protocol,
            "weather_days": args.weather_days,
            "feature_names": feature_names,
            "source_feature_columns": feature_cols,
            "target_column": target_col,
            "split_counts": {split: int(len(frame)) for split, frame in splits.items()},
            "forbidden_columns_removed": removed,
            "missing_value_policy": preprocessing["imputer_policy"],
            "imputer_policy": preprocessing["imputer_policy"],
            "scaler_policy": preprocessing["scaler_policy"],
            "preprocessing": preprocessing,
            "created_at": created_at(),
        },
    )
    print(f"Wrote tabular cache: {out_dir}")
    return out_dir


def train_weather_medians(weather_daily: pd.DataFrame, train_fire_ids: np.ndarray, rel_days: list[int], channels: list[str]) -> pd.Series:
    train_weather = weather_daily.loc[
        weather_daily["fire_id"].astype(str).isin(set(train_fire_ids.astype(str)))
        & weather_daily["relative_day"].isin(rel_days)
    ]
    medians = train_weather[channels].apply(pd.to_numeric, errors="coerce").median()
    return medians.fillna(0.0)


def build_sequence_array(
    weather_daily: pd.DataFrame,
    sample_df: pd.DataFrame,
    rel_days: list[int],
    channels: list[str],
    medians: pd.Series,
    scaler: StandardScaler | None,
) -> np.ndarray:
    n = len(sample_df)
    t = len(rel_days)
    if not channels:
        return np.zeros((n, t, 0), dtype=np.float32)
    fire_order = sample_df[["fire_id"]].copy()
    fire_order["fire_order"] = np.arange(n)
    base = pd.MultiIndex.from_product(
        [sample_df["fire_id"].astype(str).to_list(), rel_days],
        names=["fire_id", "relative_day"],
    ).to_frame(index=False)
    base = base.merge(fire_order, on="fire_id", how="left")
    weather = weather_daily[["fire_id", "relative_day"] + channels].copy()
    weather["fire_id"] = weather["fire_id"].astype(str)
    merged = base.merge(weather, on=["fire_id", "relative_day"], how="left")
    values = merged[channels].apply(pd.to_numeric, errors="coerce").fillna(medians).to_numpy(dtype=np.float64)
    if scaler is not None and channels:
        values = scaler.transform(values)
    merged_values = values.reshape(n, t, len(channels))
    return merged_values.astype(np.float32)


def build_temporal_cache(args, paths: dict[str, Path], feature_manifest: dict) -> Path:
    out_dir = output_subdir(args.output_dir, args.task, "temporal", args.weather_days, args.input_protocol)
    if (out_dir / "X_seq_train.npy").exists() and not args.overwrite:
        print(f"Reusing existing temporal cache: {out_dir}")
        return out_dir
    remove_output_dir(out_dir, args.overwrite)

    master = normalize_master_metadata(read_parquet_robust(paths["master"]))
    weather_daily = read_parquet_robust(paths["weather_daily_event"])
    samples = apply_input_protocol_sample_filter(filter_task_samples(master, args.task), args.input_protocol)
    splits = split_frames(samples)
    sample_index_splits = split_frames(build_sample_index(samples, master, args.task))
    rel_days = WEATHER_DAY_MAP[args.weather_days]
    target_col = target_info(args.task)["target_column"]

    seq_channels = TEMPORAL_WEATHER_CHANNELS if protocol_includes_weather(args.input_protocol) else []
    seq_channels = [col for col in seq_channels if col in weather_daily.columns]
    medians = train_weather_medians(weather_daily, splits["train"]["fire_id"].astype(str).to_numpy(), rel_days, seq_channels) if seq_channels else pd.Series(dtype=float)
    seq_scaler = None
    if args.standardize and seq_channels:
        train_long = weather_daily.loc[
            weather_daily["fire_id"].astype(str).isin(set(splits["train"]["fire_id"].astype(str)))
            & weather_daily["relative_day"].isin(rel_days),
            seq_channels,
        ].apply(pd.to_numeric, errors="coerce").fillna(medians)
        seq_scaler = StandardScaler().fit(train_long.to_numpy(dtype=np.float64))

    static_cols, removed = static_protocol_columns(
        feature_manifest, args.input_protocol, args.weather_days, master.columns, target_col
    )
    static_arrays, static_feature_names, static_preprocessing = fit_transform_event_features(
        splits["train"], splits["val"], splits["test"], static_cols, args.standardize
    )

    for split, frame in splits.items():
        X_seq = build_sequence_array(weather_daily, frame, rel_days, seq_channels, medians, seq_scaler)
        X_static = static_arrays[split]
        y = frame["target"].to_numpy(dtype=np.float32)
        write_seq_split_outputs(out_dir, split, X_seq, X_static, y, sample_index_splits[split], args.task)
    write_json(out_dir / "temporal_feature_names.json", {"feature_names": seq_channels})
    write_json(out_dir / "static_feature_names.json", {"feature_names": static_feature_names})
    save_metadata(
        out_dir,
        {
            "task": args.task,
            "representation": "temporal",
            "input_protocol": args.input_protocol,
            "weather_days": args.weather_days,
            "relative_days": rel_days,
            "temporal_feature_names": seq_channels,
            "static_feature_names": static_feature_names,
            "target_column": target_col,
            "split_counts": {split: int(len(frame)) for split, frame in splits.items()},
            "forbidden_columns_removed": removed,
            "missing_value_policy": "weather numeric train median; static uses tabular policy",
            "scaler_policy": "StandardScaler fit on train only" if args.standardize else "not_standardized",
            "static_preprocessing": static_preprocessing,
            "created_at": created_at(),
        },
    )
    print(f"Wrote temporal cache: {out_dir}")
    return out_dir


def parquet_files_under(path: Path) -> list[Path]:
    if path.is_file():
        return [path]
    return sorted(p for p in path.rglob("*.parquet") if p.is_file())


def _file_parquet_columns(path: Path) -> set[str]:
    try:
        import pyarrow.parquet as pq

        return set(pq.ParquetFile(path).schema.names)
    except Exception:
        return set(pd.read_parquet(path).columns)


def _read_parquet_file_existing_columns(path: Path, columns: list[str] | None = None) -> pd.DataFrame:
    if columns is None:
        return pd.read_parquet(path)
    available = _file_parquet_columns(path)
    keep = [col for col in columns if col in available]
    if not keep:
        return pd.DataFrame(index=range(0))
    return pd.read_parquet(path, columns=keep)


def read_parquet_robust(path: Path, columns: list[str] | None = None) -> pd.DataFrame:
    """Read parquet files without asking pyarrow to merge hive partitions."""
    path = Path(path)
    if path.is_file():
        return _read_parquet_file_existing_columns(path, columns=columns)
    files = parquet_files_under(path)
    if not files:
        return pd.DataFrame()
    frames = [_read_parquet_file_existing_columns(part, columns=columns) for part in files]
    return pd.concat(frames, ignore_index=True)


def read_parquet_parts_sample(path: Path, columns: list[str] | None = None, max_parts: int = 2) -> pd.DataFrame:
    """Read a few physical parquet part files for cheap validation."""
    path = Path(path)
    files = parquet_files_under(path)[:max_parts]
    if not files:
        return pd.DataFrame()
    frames = [_read_parquet_file_existing_columns(part, columns=columns) for part in files]
    return pd.concat(frames, ignore_index=True)


def read_parquet_files(files: list[Path], columns: list[str] | None = None) -> pd.DataFrame:
    if not files:
        return pd.DataFrame()
    return pd.concat([_read_parquet_file_existing_columns(file, columns=columns) for file in files], ignore_index=True)


def read_patch_table(path: Path, years: list[int], columns: list[str] | None = None, relative_days: list[int] | None = None) -> pd.DataFrame:
    files = []
    if path.is_file():
        frame = read_parquet_robust(path, columns=columns)
        if "year" in frame.columns:
            frame = frame.loc[frame["year"].isin(years)]
        if relative_days is not None and "relative_day" in frame.columns:
            frame = frame.loc[frame["relative_day"].isin(relative_days)]
        return frame
    for year in years:
        year_dir = path / f"year={year}"
        if not year_dir.exists():
            continue
        if relative_days is None:
            files.extend(parquet_files_under(year_dir))
        else:
            for rel in relative_days:
                rel_dir = year_dir / f"relative_day={rel}"
                files.extend(parquet_files_under(rel_dir))
    return read_parquet_files(files, columns=columns)


def protocol_patch_sources(input_protocol: str, weather_days: int) -> dict[str, list[str]]:
    sources = {"metadata": [], "static": [], "viirs": [], "weather": [], "osm": []}
    if input_protocol.startswith("metadata_"):
        sources["metadata"] = PATCH_METADATA_CHANNELS
        input_protocol = input_protocol.replace("metadata_", "", 1)
    if input_protocol in {"firms", "fire"}:
        sources["viirs"] = VIIRS_PATCH_CHANNELS
    elif input_protocol == "fire_wide":
        sources["viirs"] = VIIRS_PATCH_CHANNELS
    elif input_protocol == "weather":
        sources["weather"] = None
    elif input_protocol == "fuel":
        sources["static"] = FUEL_PATCH_CHANNELS
    elif input_protocol == "vegetation":
        sources["static"] = VEGETATION_PATCH_CHANNELS
    elif input_protocol == "topography":
        sources["static"] = TOPO_PATCH_CHANNELS
    elif input_protocol == "access":
        sources["osm"] = OSM_PATCH_CHANNELS
    elif input_protocol == "human":
        sources["static"] = ["pop_density"]
    elif input_protocol == "all":
        sources["static"] = STATIC_PATCH_CHANNELS
        sources["viirs"] = VIIRS_PATCH_CHANNELS
        sources["weather"] = None
        sources["osm"] = OSM_PATCH_CHANNELS
    elif input_protocol.startswith("all_without_"):
        removed = input_protocol.replace("all_without_", "", 1)
        static_channels = list(STATIC_PATCH_CHANNELS)
        if removed == "fire":
            sources["static"] = static_channels
            sources["weather"] = None
            sources["osm"] = OSM_PATCH_CHANNELS
        elif removed == "weather":
            sources["static"] = static_channels
            sources["viirs"] = VIIRS_PATCH_CHANNELS
            sources["osm"] = OSM_PATCH_CHANNELS
        elif removed == "vegetation":
            sources["static"] = [ch for ch in static_channels if ch not in VEGETATION_PATCH_CHANNELS]
            sources["viirs"] = VIIRS_PATCH_CHANNELS
            sources["weather"] = None
            sources["osm"] = OSM_PATCH_CHANNELS
        elif removed == "fuel":
            sources["static"] = [ch for ch in static_channels if ch not in FUEL_PATCH_CHANNELS]
            sources["viirs"] = VIIRS_PATCH_CHANNELS
            sources["weather"] = None
            sources["osm"] = OSM_PATCH_CHANNELS
        elif removed == "topography":
            sources["static"] = [ch for ch in static_channels if ch not in TOPO_PATCH_CHANNELS]
            sources["viirs"] = VIIRS_PATCH_CHANNELS
            sources["weather"] = None
            sources["osm"] = OSM_PATCH_CHANNELS
        elif removed == "access":
            sources["static"] = static_channels
            sources["viirs"] = VIIRS_PATCH_CHANNELS
            sources["weather"] = None
        elif removed == "human":
            sources["static"] = [ch for ch in static_channels if ch != "pop_density"]
            sources["viirs"] = VIIRS_PATCH_CHANNELS
            sources["weather"] = None
            sources["osm"] = OSM_PATCH_CHANNELS
        else:
            raise KeyError(input_protocol)
    elif input_protocol == "metadata":
        sources["metadata"] = PATCH_METADATA_CHANNELS
    else:
        raise KeyError(input_protocol)
    return sources


def weather_aggregate_patch_channels(path: Path, years: list[int], weather_days: int) -> list[str]:
    sample = read_patch_table(path, years[:1], columns=None)
    if sample.empty:
        return []
    key_cols = {"fire_id", "year", "split", "row", "col", "cell_id"}
    channels = [col for col in sample.columns if col not in key_cols and weather_feature_allowed(col, weather_days)]
    return channels


def read_joined_spatial_patch(
    paths: dict[str, Path],
    sample_df: pd.DataFrame,
    input_protocol: str,
    weather_days: int,
    include_weather_daily: bool = False,
    relative_days: list[int] | None = None,
) -> tuple[pd.DataFrame, list[str]]:
    years = sorted(sample_df["year"].unique().tolist())
    fire_ids = set(sample_df["fire_id"].astype(str))
    patch_key_cols = ["fire_id", "row", "col", "cell_id"]
    base_cols = patch_key_cols
    base = read_patch_table(paths["grid_index"], years, columns=base_cols)
    if base.empty:
        raise ValueError("Grid index patch table is empty or missing for requested years.")
    base["fire_id"] = base["fire_id"].astype(str)
    base = base.loc[base["fire_id"].isin(fire_ids)].copy()

    channel_names = []
    sources = protocol_patch_sources(input_protocol, weather_days)

    if sources["metadata"]:
        present = [c for c in sources["metadata"] if c in sample_df.columns]
        if present:
            metadata = sample_df[["fire_id"] + present].copy()
            metadata["fire_id"] = metadata["fire_id"].astype(str)
            base = base.merge(metadata, on="fire_id", how="left")
            channel_names.extend(present)

    if sources["static"]:
        cols = patch_key_cols + sources["static"]
        static = read_patch_table(paths["static_patch"], years, columns=cols)
        static["fire_id"] = static["fire_id"].astype(str)
        keep_cols = [c for c in cols if c in static.columns]
        static = static.loc[static["fire_id"].isin(fire_ids), keep_cols]
        present = [c for c in sources["static"] if c in static.columns]
        base = base.merge(static[["fire_id", "row", "col", "cell_id"] + present], on=["fire_id", "row", "col", "cell_id"], how="left")
        channel_names.extend(present)

    if sources["viirs"]:
        viirs = read_patch_table(paths["viirs_patch"], years, columns=patch_key_cols + sources["viirs"])
        viirs["fire_id"] = viirs["fire_id"].astype(str)
        present = [c for c in sources["viirs"] if c in viirs.columns]
        viirs = viirs.loc[viirs["fire_id"].isin(fire_ids), ["fire_id", "row", "col", "cell_id"] + present]
        base = base.merge(viirs, on=["fire_id", "row", "col", "cell_id"], how="left")
        channel_names.extend(present)

    if sources["weather"] is None and protocol_includes_weather(input_protocol) and not include_weather_daily:
        weather_channels = weather_aggregate_patch_channels(paths["weather_aggregate_patch"], years, weather_days)
        weather = read_patch_table(paths["weather_aggregate_patch"], years, columns=patch_key_cols + weather_channels)
        weather["fire_id"] = weather["fire_id"].astype(str)
        weather = weather.loc[weather["fire_id"].isin(fire_ids), ["fire_id", "row", "col", "cell_id"] + weather_channels]
        base = base.merge(weather, on=["fire_id", "row", "col", "cell_id"], how="left")
        channel_names.extend(weather_channels)

    if sources["osm"]:
        osm = read_patch_table(paths["osm_patch"], years, columns=patch_key_cols + sources["osm"])
        osm["fire_id"] = osm["fire_id"].astype(str)
        present = [c for c in sources["osm"] if c in osm.columns]
        osm = osm.loc[osm["fire_id"].isin(fire_ids), ["fire_id", "row", "col", "cell_id"] + present]
        base = base.merge(osm, on=["fire_id", "row", "col", "cell_id"], how="left")
        channel_names.extend(present)

    return base, list(dict.fromkeys(channel_names))


def patch_to_array(patch: pd.DataFrame, sample_df: pd.DataFrame, channels: list[str]) -> np.ndarray:
    n = len(sample_df)
    c = len(channels)
    if c == 0:
        return np.zeros((n, 0, PATCH_SIZE, PATCH_SIZE), dtype=np.float32)
    order = pd.DataFrame({"fire_id": sample_df["fire_id"].astype(str), "fire_order": np.arange(n)})
    patch = patch.copy()
    patch["fire_id"] = patch["fire_id"].astype(str)
    patch = patch.merge(order, on="fire_id", how="inner")
    patch = patch.sort_values(["fire_order", "row", "col"])
    expected = n * CELLS_PER_PATCH
    if len(patch) != expected:
        raise ValueError(f"Patch cannot reshape: got {len(patch)} rows, expected {expected}.")
    values = patch[channels].apply(pd.to_numeric, errors="coerce").fillna(0.0).to_numpy(dtype=np.float32)
    return values.reshape(n, PATCH_SIZE, PATCH_SIZE, c).transpose(0, 3, 1, 2)


def standardizable_patch_indices(channels: list[str]) -> list[int]:
    skip_exact = {
        "fbfm40",
        "fd",
        "fvt",
        "fvc",
        "fvh",
        "evt",
        "evc",
        "evh",
        "viirs_cell_has_detection_D",
        "cell_has_drivable_road",
    }
    return [idx for idx, ch in enumerate(channels) if ch not in skip_exact and not ch.endswith("_missing_mask")]


def fit_patch_stats_train(X_train: np.ndarray, channels: list[str], spatiotemporal: bool = False) -> dict:
    indices = standardizable_patch_indices(channels)
    if not indices:
        return {"indices": [], "mean": [], "std": []}
    if spatiotemporal:
        mean = X_train[:, :, indices, :, :].mean(axis=(0, 1, 3, 4))
        std = X_train[:, :, indices, :, :].std(axis=(0, 1, 3, 4))
    else:
        mean = X_train[:, indices, :, :].mean(axis=(0, 2, 3))
        std = X_train[:, indices, :, :].std(axis=(0, 2, 3))
    std = np.where(std == 0, 1.0, std)
    return {"indices": indices, "mean": mean.tolist(), "std": std.tolist()}


def apply_patch_standardization(X: np.ndarray, stats: dict, spatiotemporal: bool = False) -> np.ndarray:
    indices = stats["indices"]
    if not indices:
        return X
    mean = np.array(stats["mean"], dtype=np.float32)
    std = np.array(stats["std"], dtype=np.float32)
    X = X.copy()
    if spatiotemporal:
        X[:, :, indices, :, :] = (X[:, :, indices, :, :] - mean.reshape(1, 1, -1, 1, 1)) / std.reshape(1, 1, -1, 1, 1)
    else:
        X[:, indices, :, :] = (X[:, indices, :, :] - mean.reshape(1, -1, 1, 1)) / std.reshape(1, -1, 1, 1)
    return X


def build_spatial_cache(args, paths: dict[str, Path]) -> Path:
    out_dir = output_subdir(args.output_dir, args.task, "spatial", args.weather_days, args.input_protocol)
    if (out_dir / "X_train.npy").exists() and not args.overwrite:
        print(f"Reusing existing spatial cache: {out_dir}")
        return out_dir
    remove_output_dir(out_dir, args.overwrite)

    master = normalize_master_metadata(read_parquet_robust(paths["master"]))
    samples = apply_input_protocol_sample_filter(filter_task_samples(master, args.task), args.input_protocol)
    splits = split_frames(samples)
    sample_index_splits = split_frames(build_sample_index(samples, master, args.task))

    split_arrays = {}
    channel_names = None
    for split, frame in splits.items():
        patch, channels = read_joined_spatial_patch(paths, frame, args.input_protocol, args.weather_days)
        if channel_names is None:
            channel_names = channels
        X = patch_to_array(patch, frame, channel_names)
        split_arrays[split] = X

    patch_stats = {"indices": [], "mean": [], "std": []}
    if args.standardize and channel_names:
        patch_stats = fit_patch_stats_train(split_arrays["train"], channel_names, spatiotemporal=False)
        for split in split_arrays:
            split_arrays[split] = apply_patch_standardization(split_arrays[split], patch_stats, spatiotemporal=False)

    for split, frame in splits.items():
        y = frame["target"].to_numpy(dtype=np.float32)
        write_split_outputs(out_dir, split, split_arrays[split], y, sample_index_splits[split], args.task)
    write_json(out_dir / "channel_names.json", {"channel_names": channel_names or []})
    save_metadata(
        out_dir,
        {
            "task": args.task,
            "representation": "spatial",
            "input_protocol": args.input_protocol,
            "weather_days": args.weather_days,
            "target_column": target_info(args.task)["target_column"],
            "channel_names": channel_names or [],
            "split_counts": {split: int(len(frame)) for split, frame in splits.items()},
            "missing_value_policy": "patch NaN filled with 0; no mask channels in v1",
            "scaler_policy": "channel-wise train mean/std for non-categorical non-binary patch channels" if args.standardize else "not_standardized",
            "channel_stats": patch_stats,
            "created_at": created_at(),
        },
    )
    print(f"Wrote spatial cache: {out_dir}")
    return out_dir


def daily_weather_patch_channels(paths: dict[str, Path], years: list[int]) -> list[str]:
    sample = read_patch_table(paths["weather_daily_patch"], years[:1], columns=None, relative_days=[0])
    if sample.empty:
        return []
    key_cols = {"fire_id", "year", "split", "row", "col", "cell_id", "date", "relative_day"}
    return [col for col in sample.columns if col not in key_cols and col in TEMPORAL_WEATHER_CHANNELS]


def weather_daily_patch_to_array(
    paths: dict[str, Path],
    sample_df: pd.DataFrame,
    rel_days: list[int],
    channels: list[str],
) -> np.ndarray:
    n = len(sample_df)
    t = len(rel_days)
    c = len(channels)
    if c == 0:
        return np.zeros((n, t, 0, PATCH_SIZE, PATCH_SIZE), dtype=np.float32)
    years = sorted(sample_df["year"].unique().tolist())
    fire_ids = set(sample_df["fire_id"].astype(str))
    order = pd.DataFrame({"fire_id": sample_df["fire_id"].astype(str), "fire_order": np.arange(n)})
    rel_order = pd.DataFrame({"relative_day": rel_days, "time_order": np.arange(t)})
    weather = read_patch_table(
        paths["weather_daily_patch"],
        years,
        columns=["fire_id", "relative_day", "row", "col", "cell_id"] + channels,
        relative_days=rel_days,
    )
    weather["fire_id"] = weather["fire_id"].astype(str)
    weather = weather.loc[weather["fire_id"].isin(fire_ids), ["fire_id", "relative_day", "row", "col", "cell_id"] + channels]
    weather = weather.merge(order, on="fire_id", how="inner").merge(rel_order, on="relative_day", how="inner")
    weather = weather.sort_values(["fire_order", "time_order", "row", "col"])
    expected = n * t * CELLS_PER_PATCH
    if len(weather) != expected:
        raise ValueError(f"Weather daily patch cannot reshape: got {len(weather)} rows, expected {expected}.")
    values = weather[channels].apply(pd.to_numeric, errors="coerce").fillna(0.0).to_numpy(dtype=np.float32)
    return values.reshape(n, t, PATCH_SIZE, PATCH_SIZE, c).transpose(0, 1, 4, 2, 3)


def build_spatiotemporal_cache(args, paths: dict[str, Path]) -> Path:
    out_dir = output_subdir(args.output_dir, args.task, "spatiotemporal", args.weather_days, args.input_protocol)
    if (out_dir / "X_train.npy").exists() and not args.overwrite:
        print(f"Reusing existing spatiotemporal cache: {out_dir}")
        return out_dir
    remove_output_dir(out_dir, args.overwrite)

    master = normalize_master_metadata(read_parquet_robust(paths["master"]))
    samples = apply_input_protocol_sample_filter(filter_task_samples(master, args.task), args.input_protocol)
    splits = split_frames(samples)
    sample_index_splits = split_frames(build_sample_index(samples, master, args.task))
    rel_days = WEATHER_DAY_MAP[args.weather_days]

    split_arrays = {}
    channel_names = None
    for split, frame in splits.items():
        years = sorted(frame["year"].unique().tolist())
        dynamic_channels = daily_weather_patch_channels(paths, years) if protocol_includes_weather(args.input_protocol) else []
        X_weather = weather_daily_patch_to_array(paths, frame, rel_days, dynamic_channels)

        static_patch, static_channels = read_joined_spatial_patch(
            paths, frame, args.input_protocol, args.weather_days, include_weather_daily=True
        )
        X_static = patch_to_array(static_patch, frame, static_channels)
        X_static_repeated = np.repeat(X_static[:, None, :, :, :], len(rel_days), axis=1)
        X = np.concatenate([X_weather, X_static_repeated], axis=2)
        split_arrays[split] = X
        if channel_names is None:
            channel_names = dynamic_channels + static_channels

    patch_stats = {"indices": [], "mean": [], "std": []}
    if args.standardize and channel_names:
        patch_stats = fit_patch_stats_train(split_arrays["train"], channel_names, spatiotemporal=True)
        for split in split_arrays:
            split_arrays[split] = apply_patch_standardization(split_arrays[split], patch_stats, spatiotemporal=True)

    for split, frame in splits.items():
        y = frame["target"].to_numpy(dtype=np.float32)
        write_split_outputs(out_dir, split, split_arrays[split], y, sample_index_splits[split], args.task)
    write_json(out_dir / "channel_names.json", {"channel_names": channel_names or []})
    write_json(out_dir / "relative_days.json", {"relative_days": rel_days})
    save_metadata(
        out_dir,
        {
            "task": args.task,
            "representation": "spatiotemporal",
            "input_protocol": args.input_protocol,
            "weather_days": args.weather_days,
            "relative_days": rel_days,
            "target_column": target_info(args.task)["target_column"],
            "channel_names": channel_names or [],
            "split_counts": {split: int(len(frame)) for split, frame in splits.items()},
            "fire_signal_policy": "VIIRS discovery-day D patch repeated across all T time steps when selected",
            "missing_value_policy": "patch NaN filled with 0; no mask channels in v1",
            "scaler_policy": "channel-wise train mean/std for non-categorical non-binary patch channels" if args.standardize else "not_standardized",
            "channel_stats": patch_stats,
            "created_at": created_at(),
        },
    )
    print(f"Wrote spatiotemporal cache: {out_dir}")
    return out_dir


def build_representation(args, paths: dict[str, Path], feature_manifest: dict, representation: str) -> Path:
    if representation == "tabular":
        return build_tabular_cache(args, paths, feature_manifest)
    if representation == "temporal":
        return build_temporal_cache(args, paths, feature_manifest)
    if representation == "spatial":
        return build_spatial_cache(args, paths)
    if representation == "spatiotemporal":
        return build_spatiotemporal_cache(args, paths)
    raise ValueError(representation)


def pass_fail(name: str, ok: bool, detail: str = "") -> bool:
    status = "PASS" if ok else "FAIL"
    print(f"[{status}] {name}{': ' + detail if detail else ''}")
    return ok


def validate_patch_table_sample(name: str, path: Path, max_parts: int = 1, sample_fire_count: int = 3) -> bool:
    required = ["fire_id", "row", "col", "cell_id"]
    df = read_parquet_parts_sample(path, columns=required + ["relative_day"], max_parts=max_parts)
    if df.empty:
        return pass_fail(f"patch table sample reshape: {name}", False, "no parquet part files read")
    missing = [col for col in required if col not in df.columns]
    if missing:
        return pass_fail(f"patch table sample reshape: {name}", False, f"missing keys={missing}")

    if "relative_day" in df.columns:
        first_rel = sorted(int(day) for day in df["relative_day"].dropna().unique())[0]
        df = df.loc[df["relative_day"].astype(int) == first_rel].copy()

    fire_ids = df["fire_id"].astype(str).drop_duplicates().head(sample_fire_count).tolist()
    if not fire_ids:
        return pass_fail(f"patch table sample reshape: {name}", False, "no fire_id values in sample")

    details = []
    ok = True
    df = df.copy()
    df["fire_id"] = df["fire_id"].astype(str)
    duplicate_count = int(df.duplicated(subset=required).sum())
    if duplicate_count:
        ok = False
        details.append(f"duplicate key rows={duplicate_count}")

    for fire_id in fire_ids:
        group = df.loc[df["fire_id"] == fire_id]
        checks = {
            "rows": len(group) == CELLS_PER_PATCH,
            "row_range": int(group["row"].min()) == 0 and int(group["row"].max()) == PATCH_SIZE - 1,
            "col_range": int(group["col"].min()) == 0 and int(group["col"].max()) == PATCH_SIZE - 1,
            "cell_id_nunique": int(group["cell_id"].nunique()) == CELLS_PER_PATCH,
        }
        bad = [key for key, passed in checks.items() if not passed]
        if bad:
            ok = False
            details.append(f"fire_id={fire_id} failed {bad}")

    detail = f"sampled_fire_ids={fire_ids}" if ok else "; ".join(details)
    return pass_fail(f"patch table sample reshape: {name}", ok, detail)


def validate(args, paths: dict[str, Path]) -> bool:
    print("Validation checks")
    ok_all = True
    for key in required_path_keys():
        ok_all &= pass_fail(f"canonical input exists: {key}", paths[key].exists(), str(paths[key]))
    if not paths["master"].exists():
        return False

    feature_manifest = load_json(paths["feature_manifest"]) if paths["feature_manifest"].exists() else {"forbidden_as_features": []}
    master = normalize_master_metadata(read_parquet_robust(paths["master"]))
    ok_all &= pass_fail("master_features has one row per fire_id", not master["fire_id"].duplicated().any())

    samples = apply_input_protocol_sample_filter(filter_task_samples(master, args.task), args.input_protocol)
    splits = split_frames(samples)
    ok_all &= pass_fail("task filtering works", len(samples) > 0, f"{len(samples)} samples")
    ok_all &= pass_fail(
        "train/val/test split counts are nonzero",
        all(len(frame) > 0 for frame in splits.values()),
        str({split: len(frame) for split, frame in splits.items()}),
    )

    target_col = target_info(args.task)["target_column"]
    feature_cols, removed = requested_feature_columns(
        feature_manifest, args.input_protocol, args.weather_days, master.columns, target_col
    )
    forbidden = set(feature_manifest.get("forbidden_as_features", []))
    ok_all &= pass_fail("no forbidden columns used as input features", not bool(set(feature_cols) & forbidden))
    ok_all &= pass_fail("target column is not an input feature", target_col not in feature_cols)
    future_cols = [col for col in feature_cols if any(token in col.lower() for token in ["d+1", "dplus", "early_48", "post"])]
    ok_all &= pass_fail("no D+1/D+2/future fire columns are used", len(future_cols) == 0, str(future_cols))

    if paths["weather_daily_event"].exists():
        weather_days = set(
            int(day)
            for day in read_parquet_robust(paths["weather_daily_event"], columns=["relative_day"])["relative_day"].unique()
        )
        need = set(WEATHER_DAY_MAP[args.weather_days])
        ok_all &= pass_fail(
            "weather relative days exist",
            need <= weather_days,
            f"need={sorted(int(day) for day in need)} have={sorted(int(day) for day in weather_days)}",
        )

    patch_tables = {
        "grid_index": paths["grid_index"],
        "static_patch": paths["static_patch"],
        "viirs_patch": paths["viirs_patch"],
        "weather_daily_patch": paths["weather_daily_patch"],
        "weather_aggregate_patch": paths["weather_aggregate_patch"],
        "osm_patch": paths["osm_patch"],
    }
    for name, path in patch_tables.items():
        if path.exists():
            ok_all &= validate_patch_table_sample(name, path)

    if args.representation != "all":
        cache_dir = output_subdir(args.output_dir, args.task, args.representation, args.weather_days, args.input_protocol)
        if (cache_dir / "X_train.npy").exists():
            X = np.load(cache_dir / "X_train.npy", mmap_mode="r")
            ok_all &= pass_fail("output arrays have expected shapes", X.shape[0] == len(splits["train"]), str(X.shape))
            ok_all &= pass_fail("no NaN remains in saved X arrays", not np.isnan(np.asarray(X[: min(len(X), 10)])).any())
        else:
            ok_all &= pass_fail("output arrays have expected shapes", False, f"cache not found: {cache_dir}")
    return ok_all


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Build Phase 2 model-ready wildfire benchmark caches.")
    parser.add_argument("--base_dir", default=".")
    parser.add_argument("--canonical_dir", default="./data/cache/raw_feature_tables")
    parser.add_argument("--output_dir", default="./data/cache/model_ready")
    parser.add_argument("--task", choices=["ia_failure", "containment_time"], default="ia_failure")
    parser.add_argument(
        "--representation",
        choices=["tabular", "temporal", "spatial", "spatiotemporal", "all"],
        default="all",
    )
    parser.add_argument("--weather_days", choices=[1, 2, 3, 4, 5], type=int, default=5)
    parser.add_argument(
        "--input_protocol",
        choices=[
            "metadata",
            "firms",
            "fire",
            "fire_wide",
            "weather",
            "fuel",
            "vegetation",
            "topography",
            "access",
            "human",
            "metadata_vegetation",
            "metadata_fuel",
            "metadata_topography",
            "metadata_access",
            "metadata_human",
            "all_without_fire",
            "all_without_weather",
            "all_without_vegetation",
            "all_without_fuel",
            "all_without_topography",
            "all_without_access",
            "all_without_human",
            "all",
        ],
        default="all",
    )
    parser.add_argument("--standardize", dest="standardize", action="store_true", default=True)
    parser.add_argument("--no-standardize", dest="standardize", action="store_false")
    parser.add_argument("--overwrite", action="store_true")
    parser.add_argument("--validate-only", action="store_true")
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    args.base_dir = ensure_project_path(Path(args.base_dir))
    args.canonical_dir = ensure_project_path(Path(args.canonical_dir))
    args.output_dir = ensure_project_path(Path(args.output_dir))
    paths = canonical_paths(args.canonical_dir)

    if args.validate_only:
        ok = validate(args, paths)
        raise SystemExit(0 if ok else 1)

    missing = [key for key in required_path_keys() if not paths[key].exists()]
    if missing:
        details = "\n".join(f"  {key}: {paths[key]}" for key in missing)
        raise FileNotFoundError(f"Missing required Phase 1 canonical inputs:\n{details}")

    feature_manifest, _, _, _ = load_manifests(paths)
    reps = ["tabular", "temporal", "spatial", "spatiotemporal"] if args.representation == "all" else [args.representation]
    for representation in reps:
        build_representation(args, paths, feature_manifest, representation)


if __name__ == "__main__":
    main()