#!/usr/bin/env bash
set -euo pipefail

ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
LDM_CDF_CFG="configs/latent-diffusion/cin-ldm-vq-f8-cdf.yaml"
DEFAULT_RATIOS="0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0"

usage() {
  cat <<'EOF'
CDF/CST experiment helper.

Usage:
  ./run_cdf_experiments.sh <command> [options]

LDM training:
  ldm-train-cst
  ldm-train-cst-fa
  ldm-train-frft
  ldm-train-senior-only
  ldm-train-fmgt

LDM evaluation:
  ldm-eval-nft
  ldm-eval-cst
  ldm-eval-frft
  ldm-eval-senior-only
  ldm-eval-fmgt
  ldm-eval-cst-fa

DiT/SD pass-through commands:
  dit-eval-nft
  dit-train-cst
  dit-train-cst-fa
  dit-train-frft
  dit-train-senior-only
  dit-train-fmgt
  sd-train-cst
  sd-train-cst-fa
  sd-eval-nft

Common LDM train options:
  --ratios 0.1,0.2,...       Ratios for fixed-ratio loops.
  --schedule cosine          fixed, linear, cosine, cst_v1, cst_v2, staircase.
  --ratio-start 0.1
  --ratio-end 0.9
  --logdir logs/cdf/ldm/run
  --max-steps 200000
  --batch-size 64
  --num-workers 0          LDM DataLoader workers. Use 0 when /dev/shm is small.
  --num-sanity-val-steps 0 LDM validation sanity steps before training.
  --learning-rate 1e-5
  --scale-lr false         LDM LR scaling. Keep false so --learning-rate is the effective LR.
  --resume /path/last.ckpt Resume an interrupted LDM run. Use one ratio/schedule at a time.
  --allow-lr-mismatch false
                          Require checkpoint optimizer LR to match current effective LR.
  --gpus 0,
  --fa-weight 0.1
  --fa-boundary-width 10

Run logging:
  CDF_RUN_LOG_MODE=pty      Default in interactive shells. Preserve progress bars in run_logs via script(1).
  CDF_RUN_LOG_MODE=tee      Use plain tee logging. Some progress bars may not render.
  CDF_DISABLE_RUN_LOG=1     Disable automatic run_logs capture.

Common LDM eval options:
  --eval-ratios 0.0,0.1,...  Ratios to sample.
  --num-fid-samples 5000
  --num-sampling-steps 100
  --cfg-scale 3.0
  --output-dir outputs/cdf/ldm/run
  --ref-batch /path/to/ref.npz
  --ldm-s-path ldm/pretrained_models/ldm_s.ckpt
  --ldm-path ldm/pretrained_models/ldm.ckpt
  --ae-ckpt ldm/pretrained_models/vq-f8/model.ckpt
  --nproc-per-node 8

Common DiT eval options:
  --vae-model /path/to/sd-vae-ft-ema
                          Local VAE path. Use this on offline clusters.

Examples:
  ./run_cdf_experiments.sh ldm-train-cst --schedule cosine --logdir logs/cdf/ldm/cst_cosine
  ./run_cdf_experiments.sh ldm-train-frft --ratios 0.1,0.5,0.9 --logdir logs/cdf/ldm/frft
  ./run_cdf_experiments.sh ldm-eval-nft --output-dir outputs/cdf/ldm/nft --ref-batch /path/to/adm_ref.npz
EOF
}

strip_double_dash() {
  if [[ "${1:-}" == "--" ]]; then
    shift
  fi
  printf '%s\n' "$@"
}

split_csv() {
  local csv="$1"
  csv="${csv// /}"
  IFS=',' read -r -a SPLIT_CSV_RESULT <<< "$csv"
}

require_single_csv_when_resuming() {
  local label="$1"
  if [[ -n "${resume:-}" && ${#SPLIT_CSV_RESULT[@]} -ne 1 ]]; then
    echo "--resume with $label requires exactly one entry. Resume each ratio/schedule separately." >&2
    exit 1
  fi
}

latest_checkpoint_in_dir() {
  local dir="$1"
  if [[ -f "$dir/checkpoints/last.ckpt" ]]; then
    printf '%s\n' "$dir/checkpoints/last.ckpt"
    return
  fi
  if [[ -f "$dir/last.ckpt" ]]; then
    printf '%s\n' "$dir/last.ckpt"
    return
  fi

  local latest=""
  shopt -s nullglob
  local candidates=(
    "$dir"/checkpoints/*.ckpt
    "$dir"/checkpoints/*.pt
    "$dir"/*.ckpt
    "$dir"/*.pt
  )
  shopt -u nullglob
  if [[ ${#candidates[@]} -gt 0 ]]; then
    latest="${candidates[$((${#candidates[@]} - 1))]}"
  fi
  printf '%s\n' "$latest"
}

metric_file_complete() {
  local path="$1"
  [[ -f "$path" ]] && grep -q "^FID:" "$path" && grep -q "^Inception Score:" "$path"
}

npz_array_valid() {
  local path="$1"
  local array_name="${2:-arr_0}"
  local min_count="${3:-1}"
  python - "$path" "$array_name" "$min_count" <<'PY'
import sys
import numpy as np

path, array_name, min_count = sys.argv[1], sys.argv[2], int(sys.argv[3])
try:
    with np.load(path) as data:
        if array_name not in data.files:
            print(f"{path}: missing array {array_name}; found {data.files}", file=sys.stderr)
            sys.exit(1)
        shape = data[array_name].shape
        if not shape or shape[0] < min_count:
            print(f"{path}: {array_name} has shape {shape}, expected at least {min_count}", file=sys.stderr)
            sys.exit(1)
except Exception as exc:
    print(f"{path}: invalid npz ({exc})", file=sys.stderr)
    sys.exit(1)
PY
}

run_evaluator() {
  local ref_batch="$1"
  local sample_batch="$2"
  local metric_path="$3"
  local use_gpu="${CDF_EVALUATOR_USE_GPU:-auto}"

  if ! npz_array_valid "$ref_batch" "arr_0" 1; then
    echo "Invalid reference batch: $ref_batch" >&2
    echo "Expected an ADM-style .npz with arr_0 images. Re-download or replace this reference file." >&2
    exit 1
  fi
  if ! npz_array_valid "$sample_batch" "arr_0" 1; then
    echo "Invalid sample batch: $sample_batch" >&2
    echo "Delete the corrupt sample npz and rerun; existing PNGs can be reused by the sampler." >&2
    exit 1
  fi

  if [[ "$use_gpu" == "0" || "$use_gpu" == "cpu" ]]; then
    CDF_EVALUATOR_USE_GPU=0 python "$ROOT_DIR/ldm/evaluator.py" "$ref_batch" "$sample_batch" | tee "$metric_path"
    return
  fi
  if [[ "$use_gpu" == "1" || "$use_gpu" == "gpu" ]]; then
    CDF_EVALUATOR_USE_GPU=1 python "$ROOT_DIR/ldm/evaluator.py" "$ref_batch" "$sample_batch" | tee "$metric_path"
    return
  fi

  echo "Trying TensorFlow evaluator on GPU first. Set CDF_EVALUATOR_USE_GPU=0 to force CPU."
  if CDF_EVALUATOR_USE_GPU=1 python "$ROOT_DIR/ldm/evaluator.py" "$ref_batch" "$sample_batch" | tee "$metric_path"; then
    return
  fi
  echo "GPU evaluator failed; retrying on CPU."
  CDF_EVALUATOR_USE_GPU=0 python "$ROOT_DIR/ldm/evaluator.py" "$ref_batch" "$sample_batch" | tee "$metric_path"
}

setup_run_logging() {
  local command_name="$1"
  shift || true
  case "$command_name" in
    help|-h|--help)
      return
      ;;
  esac
  if [[ "${CDF_DISABLE_RUN_LOG:-0}" == "1" ]]; then
    return
  fi

  local log_file="${CDF_RUN_LOG:-}"
  if [[ -z "$log_file" ]]; then
    local timestamp
    timestamp="$(date +"%Y%m%d-%H%M%S")"
    log_file="$ROOT_DIR/run_logs/$command_name/$timestamp.log"
  fi
  mkdir -p "$(dirname "$log_file")"
  export CDF_RUN_LOG="$log_file"

  if [[ "${CDF_RUN_LOG_ACTIVE:-0}" == "1" ]]; then
    return
  fi

  local log_mode="${CDF_RUN_LOG_MODE:-pty}"
  if [[ "$log_mode" == "pty" && -t 1 ]] && command -v script >/dev/null 2>&1; then
    local quoted_cmd=""
    printf -v quoted_cmd '%q ' "$ROOT_DIR/run_cdf_experiments.sh" "$command_name" "$@"
    if script -q -e -a /dev/null -c "true" >/dev/null 2>&1; then
      {
        echo "Writing run log to $log_file"
        printf 'Run command: %q' "$ROOT_DIR/run_cdf_experiments.sh"
        printf ' %q' "$command_name" "$@"
        printf '\n'
        echo "Run started at $(date -Is)"
        echo "Run log mode: pty"
      } | tee -a "$log_file"
      export CDF_RUN_LOG_ACTIVE=1
      exec script -q -e -a "$log_file" -c "$quoted_cmd"
    fi
  fi

  exec > >(tee -a "$log_file") 2>&1

  echo "Writing run log to $log_file"
  printf 'Run command: %q' "$0"
  printf ' %q' "$command_name" "$@"
  printf '\n'
  echo "Run started at $(date -Is)"
  echo "Run log mode: tee"
}

run_ldm_train_one() {
  local train_mode="$1"
  local ratio_schedule="$2"
  local ratio_start="$3"
  local ratio_end="$4"
  local logdir="$5"
  local max_steps="$6"
  local batch_size="$7"
  local learning_rate="$8"
  local gpus="$9"
  local fa_weight="${10}"
  local fa_boundary_width="${11}"
  local num_workers="${12}"
  local scale_lr="${13}"
  local resume="${14}"
  local allow_lr_mismatch="${15}"
  local num_sanity_val_steps="${16}"

  cd "$ROOT_DIR/ldm"
  resume_args=()
  if [[ -n "$resume" ]]; then
    resume_args+=(--resume "$resume")
  fi
  ldm_data_args=()
  if [[ -n "${data_root:-}" ]]; then
    ldm_data_args+=(
      data.params.train.params.data_root="$data_root"
      data.params.validation.params.data_root="$data_root"
    )
  fi
  python main.py \
    "${resume_args[@]}" \
    --base "$LDM_CDF_CFG" \
    -t True \
    --gpus "$gpus" \
    --logdir "$ROOT_DIR/$logdir" \
    --max_steps "$max_steps" \
    --num_sanity_val_steps "$num_sanity_val_steps" \
    --scale_lr "$scale_lr" \
    --allow_lr_mismatch "$allow_lr_mismatch" \
    model.base_learning_rate="$learning_rate" \
    data.params.batch_size="$batch_size" \
    data.params.num_workers="$num_workers" \
    model.params.train_mode="$train_mode" \
    model.params.small_ratio="$ratio_end" \
    model.params.ratio_start="$ratio_start" \
    model.params.ratio_schedule="$ratio_schedule" \
    model.params.ratio_schedule_steps="$max_steps" \
    model.params.fa_weight="$fa_weight" \
    model.params.fa_boundary_width="$fa_boundary_width" \
    "${ldm_data_args[@]}"
}

parse_ldm_train_options() {
  ratios="0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9"
  schedule="cosine"
  ratio_start="0.1"
  ratio_end="0.9"
  logdir="logs/cdf/ldm/run"
  max_steps="200000"
  batch_size="64"
  num_workers="0"
  num_sanity_val_steps="0"
  learning_rate="1e-5"
  scale_lr="false"
  resume=""
  allow_lr_mismatch="false"
  gpus="0,"
  fa_weight="0.0"
  fa_boundary_width="10"
  data_root=""

  while [[ $# -gt 0 ]]; do
    case "$1" in
      --ratios) ratios="$2"; shift 2 ;;
      --schedule) schedule="$2"; shift 2 ;;
      --ratio-start) ratio_start="$2"; shift 2 ;;
      --ratio-end) ratio_end="$2"; shift 2 ;;
      --logdir) logdir="$2"; shift 2 ;;
      --max-steps) max_steps="$2"; shift 2 ;;
      --batch-size) batch_size="$2"; shift 2 ;;
      --num-workers) num_workers="$2"; shift 2 ;;
      --num-sanity-val-steps) num_sanity_val_steps="$2"; shift 2 ;;
      --learning-rate) learning_rate="$2"; shift 2 ;;
      --scale-lr) scale_lr="$2"; shift 2 ;;
      --resume|--resume-from-checkpoint) resume="$2"; shift 2 ;;
      --allow-lr-mismatch) allow_lr_mismatch="$2"; shift 2 ;;
      --gpus) gpus="$2"; shift 2 ;;
      --fa-weight) fa_weight="$2"; shift 2 ;;
      --fa-boundary-width) fa_boundary_width="$2"; shift 2 ;;
      --data-root) data_root="$2"; shift 2 ;;
      *)
        echo "Unknown LDM train option: $1" >&2
        exit 1
        ;;
    esac
  done
}

parse_ldm_eval_options() {
  eval_ratios="$DEFAULT_RATIOS"
  num_fid_samples="5000"
  num_sampling_steps="100"
  cfg_scale="3.0"
  output_dir="outputs/cdf/ldm/run"
  ref_batch=""
  ldm_s_path="./pretrained_models/ldm_s.ckpt"
  ldm_path="./pretrained_models/ldm.ckpt"
  ae_ckpt="./pretrained_models/vq-f8/model.ckpt"
  nproc_per_node="8"
  per_proc_batch_size="32"
  cfg="$LDM_CDF_CFG"
  cdf_ckpt=""
  checkpoint_dir=""

  while [[ $# -gt 0 ]]; do
    case "$1" in
      --ratios|--eval-ratios) eval_ratios="$2"; shift 2 ;;
      --num-fid-samples) num_fid_samples="$2"; shift 2 ;;
      --num-sampling-steps) num_sampling_steps="$2"; shift 2 ;;
      --cfg-scale) cfg_scale="$2"; shift 2 ;;
      --output-dir) output_dir="$2"; shift 2 ;;
      --ref-batch) ref_batch="$2"; shift 2 ;;
      --ldm-s-path) ldm_s_path="$2"; shift 2 ;;
      --ldm-path) ldm_path="$2"; shift 2 ;;
      --ae-ckpt) ae_ckpt="$2"; shift 2 ;;
      --nproc-per-node) nproc_per_node="$2"; shift 2 ;;
      --per-proc-batch-size) per_proc_batch_size="$2"; shift 2 ;;
      --cfg) cfg="$2"; shift 2 ;;
      --checkpoint) cdf_ckpt="$2"; shift 2 ;;
      --checkpoint-dir) checkpoint_dir="$2"; shift 2 ;;
      *)
        echo "Unknown LDM eval option: $1" >&2
        exit 1
        ;;
    esac
  done
}

run_ldm_eval_ratios() {
  mkdir -p "$ROOT_DIR/$output_dir"
  split_csv "$eval_ratios"
  for ratio in "${SPLIT_CSV_RESULT[@]}"; do
    cd "$ROOT_DIR/ldm"
    cdf_args=()
    if [[ -n "$cdf_ckpt" ]]; then
      cdf_args+=(--cdf_ckpt "$cdf_ckpt")
    fi
    local npz_path="$ROOT_DIR/$output_dir/samples/seed-0-steps-${num_sampling_steps}-images-${num_fid_samples}-ratio-${ratio}.npz"
    if [[ -f "$npz_path" ]] && npz_array_valid "$npz_path" "arr_0" "$num_fid_samples"; then
      echo "Found existing samples for ratio ${ratio}: $npz_path"
    else
      if [[ -f "$npz_path" ]]; then
        echo "Existing sample npz is invalid or incomplete; regenerating: $npz_path"
      fi
      python -m torch.distributed.launch \
        --nproc_per_node="$nproc_per_node" \
        --master_port 1236 \
        --use_env \
        scripts/sample_imagenet_ddp_t_stitch.py \
        --sample-dir "$ROOT_DIR/$output_dir/samples" \
        --per-proc-batch-size "$per_proc_batch_size" \
        --num-fid-samples "$num_fid_samples" \
        --num-sampling-steps "$num_sampling_steps" \
        --cfg-scale "$cfg_scale" \
        --ratio "$ratio" \
        --cfg "$cfg" \
        --ldm_s_path "$ldm_s_path" \
        --ldm_path "$ldm_path" \
        --ae_ckpt "$ae_ckpt" \
        "${cdf_args[@]}"
    fi

    if [[ -n "$ref_batch" ]]; then
      local metric_path="$ROOT_DIR/$output_dir/metrics-ratio-${ratio}.txt"
      if metric_file_complete "$metric_path"; then
        echo "Found existing metrics for ratio ${ratio}: $metric_path"
      else
        run_evaluator "$ref_batch" "$npz_path" "$metric_path"
      fi
    fi
  done
  python "$ROOT_DIR/cdf_collect_metrics.py" --output-dir "$ROOT_DIR/$output_dir"
}

run_ldm_eval_checkpoint_dir() {
  local root="$checkpoint_dir"
  if [[ -z "$root" ]]; then
    run_ldm_eval_ratios
    return
  fi

  shopt -s nullglob
  local dirs=("$root"/ratio-* "$root"/*)
  shopt -u nullglob
  local ran=0
  for dir in "${dirs[@]}"; do
    [[ -d "$dir" ]] || continue
    local ckpt
    ckpt="$(latest_checkpoint_in_dir "$dir")"
    [[ -n "$ckpt" ]] || continue
    local name
    name="$(basename "$dir")"
    local prev_output_dir="$output_dir"
    local prev_cdf_ckpt="$cdf_ckpt"
    output_dir="$prev_output_dir/$name"
    cdf_ckpt="$ckpt"
    run_ldm_eval_ratios
    output_dir="$prev_output_dir"
    cdf_ckpt="$prev_cdf_ckpt"
    ran=1
  done

  if [[ "$ran" == "0" ]]; then
    local ckpt
    ckpt="$(latest_checkpoint_in_dir "$root")"
    if [[ -z "$ckpt" ]]; then
      echo "No checkpoint found under $root" >&2
      exit 1
    fi
    cdf_ckpt="$ckpt"
    run_ldm_eval_ratios
  else
    python "$ROOT_DIR/cdf_collect_cross_ratio.py" --root "$ROOT_DIR/$output_dir" --method "ldm"
  fi
}

parse_dit_train_options() {
  ratios="0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9"
  schedule="cosine"
  ratio_start="0.1"
  ratio_end="0.9"
  results_dir="results_cdf"
  data_path=""
  small_model="DiT-S/2"
  large_model="DiT-XL/2"
  small_ckpt="pretrained_models/dit_s_256.pt"
  large_ckpt="pretrained_models/dit_xl_256.pt"
  epochs="1400"
  global_batch_size="256"
  learning_rate="1e-5"
  fa_weight="0.0"
  fa_boundary_width="10"
  train_mode="junior"
  nproc_per_node="1"

  while [[ $# -gt 0 ]]; do
    case "$1" in
      --ratios) ratios="$2"; shift 2 ;;
      --schedule) schedule="$2"; shift 2 ;;
      --ratio-start) ratio_start="$2"; shift 2 ;;
      --ratio-end|--ratio) ratio_end="$2"; shift 2 ;;
      --results-dir|--logdir) results_dir="$2"; shift 2 ;;
      --data-path) data_path="$2"; shift 2 ;;
      --small-model) small_model="$2"; shift 2 ;;
      --large-model) large_model="$2"; shift 2 ;;
      --small-ckpt) small_ckpt="$2"; shift 2 ;;
      --large-ckpt) large_ckpt="$2"; shift 2 ;;
      --epochs) epochs="$2"; shift 2 ;;
      --global-batch-size) global_batch_size="$2"; shift 2 ;;
      --learning-rate|--lr) learning_rate="$2"; shift 2 ;;
      --fa-weight) fa_weight="$2"; shift 2 ;;
      --fa-boundary-width) fa_boundary_width="$2"; shift 2 ;;
      --train-mode) train_mode="$2"; shift 2 ;;
      --nproc-per-node) nproc_per_node="$2"; shift 2 ;;
      *)
        echo "Unknown DiT train option: $1" >&2
        exit 1
        ;;
    esac
  done

  if [[ -z "$data_path" ]]; then
    echo "--data-path is required for DiT training." >&2
    exit 1
  fi
}

parse_dit_eval_options() {
  eval_ratios="$DEFAULT_RATIOS"
  num_fid_samples="5000"
  num_sampling_steps="100"
  cfg_scale="1.5"
  output_dir="outputs/cdf/dit/run"
  ref_batch=""
  small_model="DiT-S/2"
  large_model="DiT-XL/2"
  small_ckpt=""
  large_ckpt=""
  solver="ddim"
  nproc_per_node="8"
  per_proc_batch_size="32"
  cdf_ckpt=""
  checkpoint_dir=""
  vae_model=""

  while [[ $# -gt 0 ]]; do
    case "$1" in
      --ratios|--eval-ratios) eval_ratios="$2"; shift 2 ;;
      --num-fid-samples) num_fid_samples="$2"; shift 2 ;;
      --num-sampling-steps) num_sampling_steps="$2"; shift 2 ;;
      --cfg-scale) cfg_scale="$2"; shift 2 ;;
      --output-dir) output_dir="$2"; shift 2 ;;
      --ref-batch) ref_batch="$2"; shift 2 ;;
      --small-model) small_model="$2"; shift 2 ;;
      --large-model) large_model="$2"; shift 2 ;;
      --small-ckpt) small_ckpt="$2"; shift 2 ;;
      --large-ckpt) large_ckpt="$2"; shift 2 ;;
      --solver) solver="$2"; shift 2 ;;
      --nproc-per-node) nproc_per_node="$2"; shift 2 ;;
      --per-proc-batch-size) per_proc_batch_size="$2"; shift 2 ;;
      --checkpoint) cdf_ckpt="$2"; shift 2 ;;
      --checkpoint-dir) checkpoint_dir="$2"; shift 2 ;;
      --vae-model) vae_model="$2"; shift 2 ;;
      *)
        echo "Unknown DiT eval option: $1" >&2
        exit 1
        ;;
    esac
  done
}

run_dit_train_one() {
  local train_mode="$1"
  local ratio_schedule="$2"
  local ratio_start="$3"
  local ratio_end="$4"
  local fa_weight="$5"
  local fa_boundary_width="$6"
  cd "$ROOT_DIR/dit"
  torchrun --master_port=29501 --nnodes=1 --nproc_per_node="$nproc_per_node" train_t_stitch.py \
    --data-path "$data_path" \
    --results-dir "$ROOT_DIR/$results_dir" \
    --small-model "$small_model" \
    --large-model "$large_model" \
    --small-ckpt "$small_ckpt" \
    --large-ckpt "$large_ckpt" \
    --ratio "$ratio_end" \
    --ratio-schedule "$ratio_schedule" \
    --ratio-start "$ratio_start" \
    --train-mode "$train_mode" \
    --epochs "$epochs" \
    --global-batch-size "$global_batch_size" \
    --lr "$learning_rate" \
    --fa-weight "$fa_weight" \
    --fa-boundary-width "$fa_boundary_width"
}

run_dit_eval() {
  mkdir -p "$ROOT_DIR/$output_dir"
  cd "$ROOT_DIR/dit"
  dit_args=(
    --sample-dir "$ROOT_DIR/$output_dir/samples"
    --num-fid-samples "$num_fid_samples"
    --solver "$solver"
    --num-sampling-steps "$num_sampling_steps"
    --cfg-scale "$cfg_scale"
    --small-model "$small_model"
    --large-model "$large_model"
    --per-proc-batch-size "$per_proc_batch_size"
  )
  if [[ -n "$small_ckpt" ]]; then
    dit_args+=(--small-ckpt "$small_ckpt")
  fi
  if [[ -n "$large_ckpt" ]]; then
    dit_args+=(--large-ckpt "$large_ckpt")
  fi
  if [[ -n "$cdf_ckpt" ]]; then
    dit_args+=(--cdf-ckpt "$cdf_ckpt")
  fi
  if [[ -n "$vae_model" ]]; then
    dit_args+=(--vae-model "$vae_model")
  fi

  torchrun --nnodes=1 --nproc_per_node="$nproc_per_node" sample_ddp_t_stitch.py "${dit_args[@]}"

  if [[ -n "$ref_batch" ]]; then
    npz_files=("$ROOT_DIR/$output_dir"/samples/*ratio-*.npz)
    for npz in "${npz_files[@]}"; do
      [[ -e "$npz" ]] || continue
      ratio="${npz##*ratio-}"
      ratio="${ratio%.npz}"
      python "$ROOT_DIR/ldm/evaluator.py" "$ref_batch" "$npz" | tee "$ROOT_DIR/$output_dir/metrics-ratio-${ratio}.txt"
    done
  fi
  python "$ROOT_DIR/cdf_collect_metrics.py" --output-dir "$ROOT_DIR/$output_dir"
}

run_dit_eval_checkpoint_dir() {
  local root="$checkpoint_dir"
  if [[ -z "$root" ]]; then
    run_dit_eval
    return
  fi

  shopt -s nullglob
  local dirs=("$root"/ratio-* "$root"/*)
  shopt -u nullglob
  local ran=0
  for dir in "${dirs[@]}"; do
    [[ -d "$dir" ]] || continue
    local ckpt
    ckpt="$(latest_checkpoint_in_dir "$dir")"
    [[ -n "$ckpt" ]] || continue
    local name
    name="$(basename "$dir")"
    local prev_output_dir="$output_dir"
    local prev_cdf_ckpt="$cdf_ckpt"
    output_dir="$prev_output_dir/$name"
    cdf_ckpt="$ckpt"
    run_dit_eval
    output_dir="$prev_output_dir"
    cdf_ckpt="$prev_cdf_ckpt"
    ran=1
  done

  if [[ "$ran" == "0" ]]; then
    local ckpt
    ckpt="$(latest_checkpoint_in_dir "$root")"
    if [[ -z "$ckpt" ]]; then
      echo "No checkpoint found under $root" >&2
      exit 1
    fi
    cdf_ckpt="$ckpt"
    run_dit_eval
  else
    python "$ROOT_DIR/cdf_collect_cross_ratio.py" --root "$ROOT_DIR/$output_dir" --method "dit"
  fi
}

parse_sd_eval_options() {
  prompts=""
  output_dir="outputs/cdf/sd/run"
  ref_batch=""
  limit="5000"
  pipeline="sd"
  steps="50"
  guidance_scale="7.5"
  height="256"
  width="256"
  ratios="$DEFAULT_RATIOS"
  checkpoint=""
  small_unet_path=""
  large_unet_path=""
  deepcache_interval=""
  tome_ratio=""

  while [[ $# -gt 0 ]]; do
    case "$1" in
      --prompts) prompts="$2"; shift 2 ;;
      --output-dir) output_dir="$2"; shift 2 ;;
      --ref-batch) ref_batch="$2"; shift 2 ;;
      --limit) limit="$2"; shift 2 ;;
      --pipeline) pipeline="$2"; shift 2 ;;
      --steps) steps="$2"; shift 2 ;;
      --guidance-scale) guidance_scale="$2"; shift 2 ;;
      --height) height="$2"; shift 2 ;;
      --width) width="$2"; shift 2 ;;
      --ratios|--eval-ratios) ratios="$2"; shift 2 ;;
      --checkpoint) checkpoint="$2"; shift 2 ;;
      --small-unet-path) small_unet_path="$2"; shift 2 ;;
      --large-unet-path) large_unet_path="$2"; shift 2 ;;
      --deepcache-interval) deepcache_interval="$2"; shift 2 ;;
      --tome-ratio) tome_ratio="$2"; shift 2 ;;
      *)
        echo "Unknown SD eval option: $1" >&2
        exit 1
        ;;
    esac
  done

  if [[ -z "$prompts" ]]; then
    echo "--prompts is required for SD evaluation." >&2
    exit 1
  fi
}

run_sd_eval() {
  mkdir -p "$ROOT_DIR/$output_dir"
  cd "$ROOT_DIR"
  sd_args=(
    --pipeline "$pipeline"
    --prompts "$prompts"
    --output-dir "$ROOT_DIR/$output_dir"
    --ratios "$ratios"
    --limit "$limit"
    --height "$height"
    --width "$width"
    --steps "$steps"
    --guidance-scale "$guidance_scale"
  )
  if [[ -n "$checkpoint" ]]; then
    sd_args+=(--checkpoint "$checkpoint")
  fi
  if [[ -n "$small_unet_path" ]]; then
    sd_args+=(--small-unet-path "$small_unet_path")
  fi
  if [[ -n "$large_unet_path" ]]; then
    sd_args+=(--large-unet-path "$large_unet_path")
  fi
  if [[ -n "$deepcache_interval" ]]; then
    sd_args+=(--deepcache-interval "$deepcache_interval")
  fi
  if [[ -n "$tome_ratio" ]]; then
    sd_args+=(--tome-ratio "$tome_ratio")
  fi
  python sd/generate_tstitch_prompts.py "${sd_args[@]}"

  ratio_dirs=("$ROOT_DIR/$output_dir"/ratio-*)
  for ratio_dir in "${ratio_dirs[@]}"; do
    [[ -d "$ratio_dir" ]] || continue
    ratio="${ratio_dir##*ratio-}"
    python sd/images_to_npz.py \
      --image-dir "$ratio_dir" \
      --output "$ROOT_DIR/$output_dir/ratio-${ratio}.npz" \
      --limit "$limit" \
      --size "$height"
    python sd/clip_score.py \
      --metadata "$ratio_dir/metadata.jsonl" \
      --output "$ROOT_DIR/$output_dir/clip-ratio-${ratio}.json"
    if [[ -n "$ref_batch" ]]; then
      metric_path="$ROOT_DIR/$output_dir/metrics-ratio-${ratio}.txt"
      if metric_file_complete "$metric_path"; then
        echo "Found existing metrics for ratio ${ratio}: $metric_path"
      else
        run_evaluator "$ref_batch" "$ROOT_DIR/$output_dir/ratio-${ratio}.npz" "$metric_path"
      fi
    fi
  done
  python "$ROOT_DIR/cdf_collect_metrics.py" --output-dir "$ROOT_DIR/$output_dir"
}

cmd="${1:-help}"
if [[ $# -gt 0 ]]; then
  shift
fi
if [[ "${1:-}" == "--" ]]; then
  shift
fi
setup_run_logging "$cmd" "$@"

case "$cmd" in
  help|-h|--help)
    usage
    ;;

  ldm-train-cst)
    parse_ldm_train_options "$@"
    run_ldm_train_one "junior" "$schedule" "$ratio_start" "$ratio_end" "$logdir" "$max_steps" "$batch_size" "$learning_rate" "$gpus" "$fa_weight" "$fa_boundary_width" "$num_workers" "$scale_lr" "$resume" "$allow_lr_mismatch" "$num_sanity_val_steps"
    ;;

  ldm-train-cst-fa)
    parse_ldm_train_options "$@"
    if [[ "$fa_weight" == "0.0" ]]; then
      fa_weight="0.1"
    fi
    run_ldm_train_one "junior" "$schedule" "$ratio_start" "$ratio_end" "$logdir" "$max_steps" "$batch_size" "$learning_rate" "$gpus" "$fa_weight" "$fa_boundary_width" "$num_workers" "$scale_lr" "$resume" "$allow_lr_mismatch" "$num_sanity_val_steps"
    ;;

  ldm-train-frft)
    parse_ldm_train_options "$@"
    split_csv "$ratios"
    require_single_csv_when_resuming "--ratios"
    for ratio in "${SPLIT_CSV_RESULT[@]}"; do
      run_ldm_train_one "junior" "fixed" "$ratio" "$ratio" "$logdir/ratio-${ratio}" "$max_steps" "$batch_size" "$learning_rate" "$gpus" "$fa_weight" "$fa_boundary_width" "$num_workers" "$scale_lr" "$resume" "$allow_lr_mismatch" "$num_sanity_val_steps"
    done
    ;;

  ldm-train-senior-only)
    parse_ldm_train_options "$@"
    split_csv "$ratios"
    require_single_csv_when_resuming "--ratios"
    for ratio in "${SPLIT_CSV_RESULT[@]}"; do
      run_ldm_train_one "senior" "fixed" "$ratio" "$ratio" "$logdir/ratio-${ratio}" "$max_steps" "$batch_size" "$learning_rate" "$gpus" "0.0" "$fa_boundary_width" "$num_workers" "$scale_lr" "$resume" "$allow_lr_mismatch" "$num_sanity_val_steps"
    done
    ;;

  ldm-train-fmgt)
    parse_ldm_train_options "$@"
    split_csv "$ratios"
    require_single_csv_when_resuming "--ratios"
    for ratio in "${SPLIT_CSV_RESULT[@]}"; do
      run_ldm_train_one "joint" "fixed" "$ratio" "$ratio" "$logdir/ratio-${ratio}" "$max_steps" "$batch_size" "$learning_rate" "$gpus" "$fa_weight" "$fa_boundary_width" "$num_workers" "$scale_lr" "$resume" "$allow_lr_mismatch" "$num_sanity_val_steps"
    done
    ;;

  ldm-train-cst-ablation)
    parse_ldm_train_options "$@"
    schedules="$schedule"
    split_csv "$schedules"
    require_single_csv_when_resuming "--schedule"
    for one_schedule in "${SPLIT_CSV_RESULT[@]}"; do
      run_ldm_train_one "junior" "$one_schedule" "$ratio_start" "$ratio_end" "$logdir/$one_schedule" "$max_steps" "$batch_size" "$learning_rate" "$gpus" "$fa_weight" "$fa_boundary_width" "$num_workers" "$scale_lr" "$resume" "$allow_lr_mismatch" "$num_sanity_val_steps"
    done
    ;;

  ldm-eval-nft|ldm-eval-cst|ldm-eval-frft|ldm-eval-senior-only|ldm-eval-fmgt|ldm-eval-cst-fa|ldm-eval-cst-ablation)
    parse_ldm_eval_options "$@"
    run_ldm_eval_checkpoint_dir
    ;;

  dit-train-cst)
    parse_dit_train_options "$@"
    run_dit_train_one "junior" "$schedule" "$ratio_start" "$ratio_end" "$fa_weight" "$fa_boundary_width"
    ;;

  dit-train-cst-fa)
    parse_dit_train_options "$@"
    if [[ "$fa_weight" == "0.0" ]]; then
      fa_weight="0.1"
    fi
    run_dit_train_one "junior" "$schedule" "$ratio_start" "$ratio_end" "$fa_weight" "$fa_boundary_width"
    ;;

  dit-train-frft)
    parse_dit_train_options "$@"
    split_csv "$ratios"
    for ratio in "${SPLIT_CSV_RESULT[@]}"; do
      run_dit_train_one "junior" "fixed" "$ratio" "$ratio" "0.0" "$fa_boundary_width"
    done
    ;;

  dit-train-senior-only)
    parse_dit_train_options "$@"
    split_csv "$ratios"
    for ratio in "${SPLIT_CSV_RESULT[@]}"; do
      run_dit_train_one "senior" "fixed" "$ratio" "$ratio" "0.0" "$fa_boundary_width"
    done
    ;;

  dit-train-fmgt)
    parse_dit_train_options "$@"
    split_csv "$ratios"
    for ratio in "${SPLIT_CSV_RESULT[@]}"; do
      run_dit_train_one "joint" "fixed" "$ratio" "$ratio" "$fa_weight" "$fa_boundary_width"
    done
    ;;

  dit-eval-nft|dit-eval-cst|dit-eval-frft|dit-eval-senior-only|dit-eval-fmgt|dit-eval-cst-fa)
    parse_dit_eval_options "$@"
    run_dit_eval_checkpoint_dir
    ;;

  sd-train-cst)
    cd "$ROOT_DIR"
    if [[ "${1:-}" == "--" ]]; then
      shift
    fi
    accelerate launch sd/train_sdxl_tstitch.py "$@"
    ;;

  sd-train-cst-fa)
    cd "$ROOT_DIR"
    if [[ "${1:-}" == "--" ]]; then
      shift
    fi
    accelerate launch sd/train_sdxl_tstitch.py --fa_weight 0.1 "$@"
    ;;

  sd-eval-nft)
    parse_sd_eval_options "$@"
    run_sd_eval
    ;;

  sd-eval-cst|sd-eval-cst-fa|sd-eval-deepcache)
    parse_sd_eval_options "$@"
    run_sd_eval
    ;;

  *)
    echo "Unknown command: $cmd" >&2
    echo >&2
    usage
    exit 1
    ;;
esac