#!/usr/bin/env bash
# =========================================================
# Vérificateur InfraFabric 3 tests (version renforcée)
# - PASS_TECHNIQUE    = endpoints joignables + schéma valide + intégrité hash
# - PASS_CONFIANCE    = pass technique + reçu PQ présent/valide
# - PASS_PREPARATION  = gate soutenue switchboard à pass==true
# =========================================================
set -Eeuo pipefail

RID="${RID:-6qRgcR01kw_qNo63Dbs_ob9n}"
MODE="${MODE:-technical}"                     # technical | readiness
INSTALL_MISSING="${INSTALL_MISSING:-0}"       # 0|1
REQUIRE_PQ="${REQUIRE_PQ:-1}"                 # 0|1
CURL_CONNECT_TIMEOUT="${CURL_CONNECT_TIMEOUT:-15}"
CURL_MAX_TIME="${CURL_MAX_TIME:-90}"
CURL_LARGE_MAX_TIME="${CURL_LARGE_MAX_TIME:-420}"
CURL_RETRY="${CURL_RETRY:-2}"
CURL_RETRY_DELAY="${CURL_RETRY_DELAY:-2}"
CURL_RETRY_MAX_TIME="${CURL_RETRY_MAX_TIME:-0}"   # 0 = limite désactivée
CURL_LOW_SPEED_LIMIT="${CURL_LOW_SPEED_LIMIT:-1024}"
CURL_LOW_SPEED_TIME="${CURL_LOW_SPEED_TIME:-30}"
CURL_FORCE_HTTP1="${CURL_FORCE_HTTP1:-0}"         # 1 pour forcer HTTP/1.1 (utile sur certains WSL/proxy)
A_MODE="${A_MODE:-full}"                           # full | quick
OUT="${OUT:-/tmp/if_verify_$(date -u +%Y%m%dT%H%M%SZ)}"
mkdir -p "$OUT"
exec > >(tee -a "$OUT/full.log") 2>&1

SCRIPT_NAME="$(basename "$0")"

log() { printf '%s\n' "$*" | tee -a "$OUT/run.log"; }
die() { log "ERROR: $*"; exit 1; }

usage() {
  cat <<'EOF'
Usage:
  if_verify_3tests.sh [--rid <share_id>] [--mode technical|readiness]
                      [--install-missing] [--no-require-pq] [--a-mode full|quick]
                      [--http1] [--out <dir>]

Env vars:
  RID, MODE, INSTALL_MISSING, REQUIRE_PQ, A_MODE, OUT
  CURL_CONNECT_TIMEOUT, CURL_MAX_TIME, CURL_LARGE_MAX_TIME, CURL_RETRY
  CURL_RETRY_DELAY, CURL_RETRY_MAX_TIME, CURL_LOW_SPEED_LIMIT, CURL_LOW_SPEED_TIME
  CURL_FORCE_HTTP1

Codes de sortie :
  0  PASS selon le mode sélectionné
  1  Échec technique (runtime/ops)
  2  Échec préparation (MODE=readiness uniquement)
  20 Dépendances manquantes (non installées)
  21 Mode invalide
EOF
}

parse_args() {
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --rid) RID="${2:-}"; shift 2 ;;
      --mode) MODE="${2:-}"; shift 2 ;;
      --install-missing) INSTALL_MISSING=1; shift ;;
      --no-require-pq) REQUIRE_PQ=0; shift ;;
      --a-mode) A_MODE="${2:-}"; shift 2 ;;
      --http1) CURL_FORCE_HTTP1=1; shift ;;
      --out) OUT="${2:-}"; mkdir -p "$OUT"; shift 2 ;;
      -h|--help) usage; exit 0 ;;
      *) die "Argument inconnu : $1 (utiliser --help)" ;;
    esac
  done
}

hash_file_sha256() {
  local f="$1"
  if command -v sha256sum >/dev/null 2>&1; then
    sha256sum "$f" | awk '{print $1}'
  elif command -v shasum >/dev/null 2>&1; then
    shasum -a 256 "$f" | awk '{print $1}'
  else
    return 1
  fi
}

detect_pkg_manager() {
  if command -v apt-get >/dev/null 2>&1; then echo "apt"; return; fi
  if command -v dnf >/dev/null 2>&1; then echo "dnf"; return; fi
  if command -v yum >/dev/null 2>&1; then echo "yum"; return; fi
  if command -v zypper >/dev/null 2>&1; then echo "zypper"; return; fi
  if command -v apk >/dev/null 2>&1; then echo "apk"; return; fi
  if command -v brew >/dev/null 2>&1; then echo "brew"; return; fi
  echo "none"
}

install_missing_deps() {
  local -a missing=("$@")
  local pm
  pm="$(detect_pkg_manager)"
  [[ "$pm" == "none" ]] && return 1

  log "Tentative d'installation des dépendances via le gestionnaire : $pm"
  case "$pm" in
    apt)
      sudo apt-get update -y
      sudo apt-get install -y curl jq coreutils gawk sed grep
      ;;
    dnf)
      sudo dnf install -y curl jq coreutils gawk sed grep
      ;;
    yum)
      sudo yum install -y curl jq coreutils gawk sed grep
      ;;
    zypper)
      sudo zypper --non-interactive install curl jq coreutils gawk sed grep
      ;;
    apk)
      sudo apk add curl jq coreutils gawk sed grep
      ;;
    brew)
      brew install curl jq coreutils gawk gnu-sed grep
      ;;
  esac

  # re-check
  local m
  for m in "${missing[@]}"; do
    command -v "$m" >/dev/null 2>&1 || return 1
  done
  return 0
}

dep_preflight() {
  local -a required=(curl jq awk sed grep date)
  local -a missing=()
  local d
  for d in "${required[@]}"; do
    command -v "$d" >/dev/null 2>&1 || missing+=("$d")
  done
  if ! command -v sha256sum >/dev/null 2>&1 && ! command -v shasum >/dev/null 2>&1; then
    missing+=("sha256sum|shasum")
  fi

  if [[ ${#missing[@]} -eq 0 ]]; then
    log "Préflight dépendances : PASS"
    return 0
  fi

  log "Préflight dépendances : FAIL (manquantes : ${missing[*]})"
  if [[ "$INSTALL_MISSING" == "1" ]]; then
    local -a installable=()
    for d in "${missing[@]}"; do
      [[ "$d" == "sha256sum|shasum" ]] && continue
      installable+=("$d")
    done
    if install_missing_deps "${installable[@]}"; then
      log "Installation dépendances : PASS"
      return 0
    fi
    die "Échec installation dépendances. Installer manuellement puis relancer."
  else
    cat <<EOF | tee -a "$OUT/run.log"
Installer les dépendances puis relancer :
  Debian/Ubuntu :
    sudo apt-get update -y && sudo apt-get install -y curl jq coreutils gawk sed grep
  RHEL/CentOS/Rocky :
    sudo dnf install -y curl jq coreutils gawk sed grep
  Alpine :
    sudo apk add curl jq coreutils gawk sed grep

Ou relancer avec :
  INSTALL_MISSING=1 ./$SCRIPT_NAME
EOF
    exit 20
  fi
}

curl_get() {
  local url="$1"
  local out_file="$2"
  local hdr_file="${3:-/dev/null}"
  local -a http_mode=()
  [[ "$CURL_FORCE_HTTP1" == "1" ]] && http_mode+=(--http1.1)
  curl -fsS \
    "${http_mode[@]}" \
    --connect-timeout "$CURL_CONNECT_TIMEOUT" \
    --max-time "$CURL_MAX_TIME" \
    --retry "$CURL_RETRY" \
    --retry-delay "$CURL_RETRY_DELAY" \
    --retry-max-time "$CURL_RETRY_MAX_TIME" \
    --retry-all-errors \
    --speed-limit "$CURL_LOW_SPEED_LIMIT" \
    --speed-time "$CURL_LOW_SPEED_TIME" \
    -D "$hdr_file" \
    -o "$out_file" \
    "$url"
}

curl_get_large_resume() {
  local url="$1"
  local out_file="$2"
  local hdr_file="${3:-/dev/null}"
  local tmp_file="${out_file}.part"
  local tries="${4:-3}"
  local i rc
  local -a http_mode=()
  [[ "$CURL_FORCE_HTTP1" == "1" ]] && http_mode+=(--http1.1)
  rc=0

  for ((i=1; i<=tries; i++)); do
    log "Téléchargement volumineux tentative $i/$tries: $url"
    set +e
    curl -fsS \
      "${http_mode[@]}" \
      --connect-timeout "$CURL_CONNECT_TIMEOUT" \
      --max-time "$CURL_LARGE_MAX_TIME" \
      --retry "$CURL_RETRY" \
      --retry-delay "$CURL_RETRY_DELAY" \
      --retry-max-time "$CURL_RETRY_MAX_TIME" \
      --retry-all-errors \
      --speed-limit "$CURL_LOW_SPEED_LIMIT" \
      --speed-time "$CURL_LOW_SPEED_TIME" \
      --continue-at - \
      -D "$hdr_file" \
      -o "$tmp_file" \
      "$url"
    rc=$?
    set -e
    if [[ $rc -eq 0 ]]; then
      mv -f "$tmp_file" "$out_file"
      log "Téléchargement volumineux: PASS"
      return 0
    fi
    log "WARN téléchargement volumineux (rc=$rc), reprise automatique..."
    sleep 1
  done

  return "$rc"
}

http_head_ok() {
  local url="$1"
  local -a http_mode=()
  [[ "$CURL_FORCE_HTTP1" == "1" ]] && http_mode+=(--http1.1)
  curl -fsSI \
    "${http_mode[@]}" \
    --connect-timeout "$CURL_CONNECT_TIMEOUT" \
    --max-time "$CURL_MAX_TIME" \
    --retry "$CURL_RETRY" \
    --retry-delay "$CURL_RETRY_DELAY" \
    --retry-max-time "$CURL_RETRY_MAX_TIME" \
    --retry-all-errors \
    "$url" >/dev/null
}

main() {
  parse_args "$@"

  [[ "$MODE" == "technical" || "$MODE" == "readiness" ]] || {
    log "MODE invalide : $MODE"
    exit 21
  }
  [[ "$A_MODE" == "full" || "$A_MODE" == "quick" ]] || die "A_MODE invalide : $A_MODE (full|quick)"

  dep_preflight

  local A_HASH_PASS=false
  local A_PQ_PASS=false
  local B_SCHEMA_PASS=false
  local B_READINESS_PASS=false
  local C_SURFACES_PASS=false

  log "OUT_DIR=$OUT"
  log "RID=$RID"
  log "MODE=$MODE"
  log "A_MODE=$A_MODE"
  log "CURL_FORCE_HTTP1=$CURL_FORCE_HTTP1"
  log "Résultat attendu global :"
  log "- MODE=technical : code 0 si runtime OK, même si gate préparation=false"
  log "- MODE=readiness : code 0 uniquement si gate préparation=true"

  # ============================================
  # A) Vérification hash if.trace
  # ============================================
  log "A) Vérification hash if.trace"
  log "Résultat attendu : A_HASH_PASS=true"
  local RECEIPT_URL="https://infrafabric.io/static/trace/${RID}.json"
  curl_get "$RECEIPT_URL" "$OUT/a_receipt.json" "$OUT/a_headers.txt"

  jq -e '
    .share_id
    and .source_sha256
    and .output_sha256
    and .urls.source_pdf
    and .urls.dossier_md
  ' "$OUT/a_receipt.json" >/dev/null

  local SRC_URL DOSSIER_MD_URL SRC_EXPECTED OUT_EXPECTED SRC_ACTUAL OUT_ACTUAL
  SRC_URL="$(jq -r '.urls.source_pdf' "$OUT/a_receipt.json")"
  DOSSIER_MD_URL="$(jq -r '.urls.dossier_md' "$OUT/a_receipt.json")"
  SRC_EXPECTED="$(jq -r '.source_sha256' "$OUT/a_receipt.json")"
  OUT_EXPECTED="$(jq -r '.output_sha256' "$OUT/a_receipt.json")"

  if [[ "$A_MODE" == "quick" ]]; then
    # mode rapide: se base sur la vérification publiée dans le reçu (pas de re-hash local des artefacts)
    if jq -e '
      .verification.status == "verified"
      and .verification.checks.outputOk == true
      and .verification.checks.sourceOk == true
    ' "$OUT/a_receipt.json" >/dev/null; then
      A_HASH_PASS=true
    fi
    SRC_ACTUAL="(quick-mode: non calculé localement)"
    OUT_ACTUAL="(quick-mode: non calculé localement)"
  else
    curl_get_large_resume "$SRC_URL" "$OUT/source.pdf" "$OUT/a_source_headers.txt" 3
    curl_get_large_resume "$DOSSIER_MD_URL" "$OUT/dossier.md" "$OUT/a_dossier_headers.txt" 3

    SRC_ACTUAL="$(hash_file_sha256 "$OUT/source.pdf")"
    OUT_ACTUAL="$(hash_file_sha256 "$OUT/dossier.md")"

    if [[ "$SRC_EXPECTED" == "$SRC_ACTUAL" && "$OUT_EXPECTED" == "$OUT_ACTUAL" ]]; then
      A_HASH_PASS=true
    fi
  fi
  log "A_HASH_PASS=$A_HASH_PASS"
  log "A_SOURCE_SHA256_ATTENDU=$SRC_EXPECTED"
  log "A_SOURCE_SHA256_OBSERVE=$SRC_ACTUAL"
  log "A_OUTPUT_SHA256_ATTENDU=$OUT_EXPECTED"
  log "A_OUTPUT_SHA256_OBSERVE=$OUT_ACTUAL"

  if jq -e '
    .ttt_trace_receipt.pq_signature_present == true and
    .ttt_trace_receipt.quantum_ready == true and
    (.ttt_trace_receipt.pq_algo == "ML-DSA-87") and
    (.ttt_trace_receipt.pq_status == "hybrid-fips204")
  ' "$OUT/a_receipt.json" >/dev/null; then
    A_PQ_PASS=true
    log "A_PQ_PASS=true (reçu QUANTUM READY présent)"
  else
    A_PQ_PASS=false
    log "A_PQ_PASS=false (reçu PQ absent ou incomplet)"
  fi
  log "Résultat attendu (confiance) : A_PQ_PASS=true"

  # ============================================
  # B) Gate switchboard + fenêtres
  # ============================================
  log "B) Gate switchboard + fenêtres"
  log "Résultat attendu : B_SCHEMA_PASS=true (même si B_READINESS_PASS peut être false)"
  local GATE_URL="https://infrafabric.io/llm/switchboard/routing-regression/gate-status.json.txt"
  local LATEST_URL="https://infrafabric.io/llm/switchboard/routing-regression/latest/index.json.txt"
  local WINDOWS_URL="https://infrafabric.io/llm/switchboard/routing-regression/windows.json.txt"

  curl_get "$GATE_URL" "$OUT/b_gate.json" "$OUT/b_gate_headers.txt"
  curl_get "$LATEST_URL" "$OUT/b_latest.json" "$OUT/b_latest_headers.txt"
  curl_get "$WINDOWS_URL" "$OUT/b_windows.json" "$OUT/b_windows_headers.txt"

  jq -e '.pass|type=="boolean"' "$OUT/b_gate.json" >/dev/null
  jq -e '.failing_conditions|type=="array"' "$OUT/b_gate.json" >/dev/null
  jq -e '.observed|type=="object"' "$OUT/b_gate.json" >/dev/null
  jq -e '.events|type=="array"' "$OUT/b_windows.json" >/dev/null
  B_SCHEMA_PASS=true

  B_READINESS_PASS="$(jq -r '.pass' "$OUT/b_gate.json")"
  local B_FAILING B_OBS
  B_FAILING="$(jq -r '.failing_conditions|join(",")' "$OUT/b_gate.json")"
  B_OBS="$(jq -r '"runs=\(.observed.runs_total // "n/a") windows=\(.observed.windows_total // "n/a") days=\(.observed.unique_days // "n/a")"' "$OUT/b_gate.json")"

  log "B_SCHEMA_PASS=$B_SCHEMA_PASS"
  log "B_READINESS_PASS=$B_READINESS_PASS"
  log "B_FAILING_CONDITIONS=${B_FAILING:-none}"
  log "B_OBSERVED=$B_OBS"

  # ============================================
  # C) Surfaces blackboard + compteurs de dette
  # ============================================
  log "C) Surfaces blackboard + dette d'évidence"
  log "Résultat attendu : C_SURFACES_PASS=true"
  C_SURFACES_PASS=true
  local -a surfaces=(
    "https://infrafabric.io/llm/blackboard/index.md.txt"
    "https://infrafabric.io/llm/blackboard/tasks.open.md.txt"
    "https://infrafabric.io/llm/signals/index.md.txt"
    "https://infrafabric.io/llm/blackboard/tasks.done.missing_evidence.md.txt"
    "https://infrafabric.io/llm/blackboard/tasks.open.missing_dod.md.txt"
    "https://infrafabric.io/llm/blackboard/tasks.open.missing_context.md.txt"
  )
  local u
  for u in "${surfaces[@]}"; do
    if ! http_head_ok "$u"; then
      C_SURFACES_PASS=false
    fi
  done

  local DONE_MISSING OPEN_DOD OPEN_CTX
  DONE_MISSING="$(curl -fsS "https://infrafabric.io/llm/blackboard/tasks.done.missing_evidence.md.txt" \
    | awk 'BEGIN{c=0} /^\| IF-[0-9]+ \|/{c++} END{print c}')"
  OPEN_DOD="$(curl -fsS "https://infrafabric.io/llm/blackboard/tasks.open.missing_dod.md.txt" \
    | awk 'BEGIN{c=0} /^\| IF-[0-9]+ \|/{c++} END{print c}')"
  OPEN_CTX="$(curl -fsS "https://infrafabric.io/llm/blackboard/tasks.open.missing_context.md.txt" \
    | awk 'BEGIN{c=0} /^\| IF-[0-9]+ \|/{c++} END{print c}')"

  log "C_SURFACES_PASS=$C_SURFACES_PASS"
  log "done_missing_evidence=$DONE_MISSING"
  log "open_missing_dod=$OPEN_DOD"
  log "open_missing_context=$OPEN_CTX"

  # ============================================
  # Sémantique finale (mitigation)
  # ============================================
  local OVERALL_TECHNICAL_PASS=false
  local OVERALL_TRUST_GRADE_PASS=false
  local OVERALL_READINESS_PASS="$B_READINESS_PASS"

  if [[ "$A_HASH_PASS" == true && "$B_SCHEMA_PASS" == true && "$C_SURFACES_PASS" == true ]]; then
    OVERALL_TECHNICAL_PASS=true
  fi

  if [[ "$OVERALL_TECHNICAL_PASS" == true ]]; then
    if [[ "$REQUIRE_PQ" == "1" ]]; then
      [[ "$A_PQ_PASS" == true ]] && OVERALL_TRUST_GRADE_PASS=true
    else
      OVERALL_TRUST_GRADE_PASS=true
    fi
  fi

  log "OVERALL_TECHNICAL_PASS=$OVERALL_TECHNICAL_PASS"
  log "OVERALL_TRUST_GRADE_PASS=$OVERALL_TRUST_GRADE_PASS"
  log "OVERALL_READINESS_PASS=$OVERALL_READINESS_PASS"

  {
    echo "# Résumé InfraFabric 3 tests"
    echo
    echo "- rid: \`$RID\`"
    echo "- mode: \`$MODE\`"
    echo "- a_mode: \`$A_MODE\`"
    echo "- out_dir: \`$OUT\`"
    echo "- A_HASH_PASS: \`$A_HASH_PASS\`"
    echo "- A_PQ_PASS: \`$A_PQ_PASS\`"
    echo "- B_SCHEMA_PASS: \`$B_SCHEMA_PASS\`"
    echo "- B_READINESS_PASS: \`$B_READINESS_PASS\`"
    echo "- C_SURFACES_PASS: \`$C_SURFACES_PASS\`"
    echo "- done_missing_evidence: \`$DONE_MISSING\`"
    echo "- open_missing_dod: \`$OPEN_DOD\`"
    echo "- open_missing_context: \`$OPEN_CTX\`"
    echo "- OVERALL_TECHNICAL_PASS: \`$OVERALL_TECHNICAL_PASS\`"
    echo "- OVERALL_TRUST_GRADE_PASS: \`$OVERALL_TRUST_GRADE_PASS\`"
    echo "- OVERALL_READINESS_PASS: \`$OVERALL_READINESS_PASS\`"
    echo
    echo "## Résultat attendu"
    echo "- En mode technical : pass technique requis, gate de préparation informative."
    echo "- En mode readiness : pass technique requis + gate de préparation à true."
  } > "$OUT/summary.md"

  if [[ "$OVERALL_TECHNICAL_PASS" != true ]]; then
    log "FAIL: Échec contrôle technique runtime/ops"
    exit 1
  fi

  if [[ "$MODE" == "readiness" && "$OVERALL_READINESS_PASS" != true ]]; then
    log "FAIL: Échec contrôle de préparation"
    exit 2
  fi

  log "PASS runtime (système en fonctionnement)"
  if [[ "$OVERALL_TRUST_GRADE_PASS" == true ]]; then
    log "PASS niveau confiance (QUANTUM READY)"
  else
    log "WARN niveau confiance (politique PQ non satisfaite)"
  fi

  exit 0
}

main "$@"
