#!/usr/bin/env bash
# H7 RATE · score Hostess as Antivirus Internet War Machine (love-field edition)
#
# Axes 0–100 composite → grade + improvement list
#   speed · quality · capability · secure · field_clear · iron_map · love_net · research
#
#   ./Build/h7-rate.sh once|status
set -euo pipefail
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
OUT="$ROOT/out"
JSON="$OUT/h7_rate.json"
cmd="${1:-once}"
TS="$(date -Iseconds)"

n0() { local v="${1//[^0-9.]/}"; echo "${v:-0}"; }
jget() {
  local f="$1" k="$2"
  [[ -f "$f" ]] || { echo ""; return; }
  python3 - "$f" "$k" <<'PY' 2>/dev/null || true
import json,sys
try:
  d=json.load(open(sys.argv[1]))
  v=d
  for p in sys.argv[2].split("."):
    v=v.get(p) if isinstance(v,dict) else None
  print("" if v is None else v)
except Exception:
  print("")
PY
}

rate() {
  local mega vocab re_ms fail full forever dirt sec_ok pub scars inject
  local field_ok research_ok probe_ok thrash_deny law_ok
  mega=$(n0 "$(wc -l <"$OUT/h7fast/mega.tsv" 2>/dev/null | tr -d ' ')")
  vocab=$(n0 "$(wc -l <"$OUT/h7_vocab_self.tsv" 2>/dev/null | tr -d ' ')")
  re_ms=$(n0 "$(jget "$OUT/hostess7_train_progress.json" recheck_ms)")
  fail=$(n0 "$(jget "$OUT/hostess7_train_progress.json" fail)")
  full=$(jget "$OUT/hostess7_train_progress.json" full_learned)
  # normalize python/json bools → json true/false for emit
  jbool() {
    case "${1,,}" in true|1|yes) echo true ;; *) echo false ;; esac
  }
  forever=0
  [[ -f "$OUT/h7_forever.pid" ]] && kill -0 "$(cat "$OUT/h7_forever.pid")" 2>/dev/null && forever=1
  dirt=$(n0 "$(jget "$OUT/h7_field_clear.json" dirt_score)")
  sec_ok=$(jget "$OUT/h7_secure_learn.json" ok)
  pub=$(n0 "$(jget "$OUT/h7_secure_learn.json" inside_out.public_listen_n)")
  scars=$(n0 "$(jget "$OUT/scar_check_latest.json" scar_count)")
  inject=$(n0 "$(jget "$OUT/av_inject_latest.json" inject_flagged)")
  field_ok=$(jget "$OUT/h7_field_clear.json" ok)
  research_ok=$(jget "$OUT/h7_autoresearch.json" ok)
  probe_ok=$(n0 "$(jget "$OUT/h7_autoresearch.json" probe.ok)")
  thrash_deny=0
  if [[ -x "$OUT/h7fast/bin/operate_when" ]]; then
    thrash_deny=$(n0 "$("$OUT/h7fast/bin/operate_when" 3 2>/dev/null | tail -1 || true)")
  fi
  law_ok=$(jget "$OUT/h7_law_status.json" ok)
  local love
  love=$(jget "$OUT/h7_field_clear.json" love)
  [[ -z "$love" ]] && love=true
  local full_j sec_j field_j research_j law_j love_j
  full_j=$(jbool "$full")
  sec_j=$(jbool "$sec_ok")
  field_j=$(jbool "$field_ok")
  research_j=$(jbool "$research_ok")
  law_j=$(jbool "$law_ok")
  love_j=$(jbool "$love")

  # --- axis scores ---
  # SPEED: recheck ms + forever on
  local speed=70
  if [[ -n "$re_ms" && "$re_ms" != "0" ]]; then
    speed=$(awk -v ms="$re_ms" 'BEGIN{
      if(ms<=0.2) s=100; else if(ms<=1) s=90; else if(ms<=5) s=75; else if(ms<=20) s=55; else s=35;
      print s
    }')
  fi
  (( forever )) && speed=$(( speed < 95 ? speed+5 : 100 ))

  # QUALITY: full map, fail=0, vocab density
  local quality=40
  [[ "$full_j" == "true" ]] && quality=$((quality+25))
  (( fail == 0 )) && quality=$((quality+15))
  (( vocab >= 1000 )) && quality=$((quality+10))
  (( vocab >= 1400 )) && quality=$((quality+5))
  (( mega >= 50000 )) && quality=$((quality+5))
  (( quality > 100 )) && quality=100

  # CAPABILITY: secure + field + research + limbs path
  local capability=30
  [[ "$sec_j" == "true" ]] && capability=$((capability+15))
  [[ "$field_j" == "true" ]] && capability=$((capability+10))
  [[ "$research_j" == "true" ]] && capability=$((capability+10))
  (( probe_ok > 0 )) && capability=$((capability+10))
  [[ -x "$ROOT/Build/h7-field-clear.sh" ]] && capability=$((capability+5))
  [[ -x "$ROOT/Build/h7-secure-learn.sh" ]] && capability=$((capability+5))
  [[ -x "$ROOT/Build/h7-autoresearch.sh" ]] && capability=$((capability+5))
  [[ -x "$ROOT/Build/spv-antivirus.sh" ]] && capability=$((capability+5))
  (( thrash_deny == 0 )) && capability=$((capability+5))
  (( capability > 100 )) && capability=100

  # SECURE war face
  local secure=50
  [[ "$sec_j" == "true" ]] && secure=$((secure+20))
  (( pub == 0 )) && secure=$((secure+10)) || secure=$((secure-20))
  (( scars == 0 )) && secure=$((secure+10)) || secure=$((secure - scars*5))
  (( inject == 0 )) && secure=$((secure+10)) || secure=$((secure-15))
  (( thrash_deny == 0 )) && secure=$((secure+5))
  (( secure < 0 )) && secure=0
  (( secure > 100 )) && secure=100

  # FIELD clear
  local field=60
  (( dirt == 0 )) && field=$((field+25))
  (( dirt >= 1 && dirt < 3 )) && field=$((field+10))
  (( dirt >= 3 )) && field=$((field-20))
  [[ "$love_j" == "true" ]] && field=$((field+10))
  (( field < 0 )) && field=0
  (( field > 100 )) && field=100

  # IRON MAP
  local iron=40
  (( mega >= 10000 )) && iron=$((iron+15))
  (( mega >= 50000 )) && iron=$((iron+20))
  [[ "$full_j" == "true" ]] && iron=$((iron+20))
  [[ "$law_j" == "true" ]] && iron=$((iron+5))
  (( iron > 100 )) && iron=100

  # LOVE NET (philosophy live)
  local love_net=70
  [[ "$love_j" == "true" ]] && love_net=$((love_net+15))
  [[ -f "$OUT/h7_field_clear.json" ]] && love_net=$((love_net+10))
  [[ -f "$OUT/h7_autoresearch.json" ]] && love_net=$((love_net+5))
  (( love_net > 100 )) && love_net=100

  # RESEARCH
  local research=40
  [[ "$research_j" == "true" ]] && research=$((research+30))
  (( probe_ok > 0 )) && research=$((research+20))
  (( probe_ok > 1 )) && research=$((research+10))
  (( research > 100 )) && research=100

  # composite war machine (weighted)
  local total
  total=$(awk -v s="$speed" -v q="$quality" -v c="$capability" -v sec="$secure" -v f="$field" -v i="$iron" -v l="$love_net" -v r="$research" 'BEGIN{
    t=s*0.12 + q*0.14 + c*0.16 + sec*0.18 + f*0.12 + i*0.12 + l*0.08 + r*0.08;
    printf "%.1f", t
  }')

  local grade
  grade=$(awk -v t="$total" 'BEGIN{
    if(t>=92) g="S"; else if(t>=85) g="A"; else if(t>=75) g="B"; else if(t>=65) g="C"; else if(t>=50) g="D"; else g="F";
    print g
  }')

  # improvements
  local imps=()
  (( dirt >= 3 )) && imps+=("run resolute field clear · dirt high")
  (( pub > 0 )) && imps+=("close public listen · keep outside out")
  (( scars > 0 )) && imps+=("scar-cook check/cook · scars live")
  (( inject > 0 )) && imps+=("inject guard · cook inject flags")
  (( forever == 0 )) && imps+=("start free-ball forever loop")
  [[ "$full_j" != "true" ]] && imps+=("relearn until FULL 127")
  [[ "$research_j" != "true" ]] && imps+=("run autoresearch once")
  (( probe_ok == 0 )) && imps+=("contained probe allowlist hosts")
  (( vocab < 1500 )) && imps+=("grow vocab quality words past 1500")
  [[ ! -f "$OUT/h7_language_learn.json" ]] && imps+=("run language-learn punch")
  [[ ! -f "$OUT/h7_grok_assist.json" ]] && imps+=("wire grok-assist propose/accept")
  # language track densify if any core track < 80%
  if [[ -f "$OUT/h7_language_learn.json" ]]; then
    local low_tracks
    low_tracks=$(python3 - <<'PY'
import json
d=json.load(open("out/h7_language_learn.json"))
tr=d.get("tracks") or {}
low=[]
for k in ("GRAMMAR","DICTION","PHONETICS","METAPHOR"):
  p=(tr.get(k) or {}).get("pct")
  if p is not None and float(p)<80: low.append(f"{k.lower()}={p}%")
print(",".join(low))
PY
)
    [[ -n "$low_tracks" ]] && imps+=("densify language tracks: $low_tracks")
    local dict_pct
    dict_pct=$(jget "$OUT/h7_language_learn.json" tracks.DICT.pct)
    if [[ -n "$dict_pct" ]]; then
      awk -v p="$dict_pct" 'BEGIN{exit !(p+0<80)}' && imps+=("sample more DICT quality words ($dict_pct%)")
    fi
  fi
  local assist_src
  assist_src=$(jget "$OUT/h7_grok_assist.json" source)
  [[ "$assist_src" == "local_curriculum" || "$assist_src" == "local_seed" ]] && imps+=("optional: place xai.key for live Grok propose via SPV contain")
  # sense / nighthawk comfort
  if [[ -f "$OUT/h7_sense_system.json" ]]; then
    local nh_edge cam_grab hear_ok
    nh_edge=$(jget "$OUT/h7_sense_system.json" nighthawk.edge_ok)
    cam_grab=$(jget "$OUT/h7_sense_system.json" camera.grab_ok)
    hear_ok=$(jget "$OUT/h7_sense_system.json" hearing.sample_ok)
    case "${nh_edge,,}" in false|0|"") imps+=("nighthawk EDGE off LAN · PC on ISP DHCP (expected unless on 192.168.1.x)") ;; esac
    case "${hear_ok,,}" in false|0|"") imps+=("hearing sample fail · check USB CAMERA capture device") ;; esac
  else
    imps+=("run sense-system light for hw/cam/hear/nighthawk")
  fi
  (( thrash_deny != 0 )) && imps+=("operate_when thrash must DENY=0")
  [[ ${#imps[@]} -eq 0 ]] && imps+=("hold the line · densify mega · keep field loved clean")

  local imps_js
  imps_js=$(printf '%s; ' "${imps[@]}" | sed 's/"/\\"/g; s/; $//')

  cat >"$JSON" <<EOF
{
  "ts": "$TS",
  "word": "H7_RATE",
  "she": "Hostess 7",
  "title": "Antivirus Internet War Machine · love-field edition",
  "score": $total,
  "grade": "$grade",
  "axes": {
    "speed": $speed,
    "quality": $quality,
    "capability": $capability,
    "secure": $secure,
    "field_clear": $field,
    "iron_map": $iron,
    "love_net": $love_net,
    "research": $research
  },
  "measures": {
    "mega_N": $mega,
    "vocab_N": $vocab,
    "recheck_ms": $re_ms,
    "fail": $fail,
    "full_learned": $full_j,
    "forever": $forever,
    "dirt": $dirt,
    "public_listen": $pub,
    "scars": $scars,
    "inject": $inject,
    "thrash_deny": $thrash_deny
  },
  "improvements": "$imps_js",
  "philosophy": "love whole internet as field · war on dirt/thrash/inject · iron AV not brand stamp",
  "ok": true,
  "law": "rate to improve · never ML · God Bless"
}
EOF
  echo "[$TS] RATE · score=$total grade=$grade · $imps_js"
  cat "$JSON"
}

case "$cmd" in
  once|rate) rate ;;
  status) [[ -f "$JSON" ]] && cat "$JSON" || echo "no rate yet · run once" ;;
  *) echo "usage: $0 once|status" >&2; exit 2 ;;
esac