#!/usr/bin/env python3
"""Lightweight regression guard for the buildless Tarinai app.

Checks static-file consistency, generated-load order, syntax, and the ActionSpec
registry contract. This intentionally avoids save-data migration checks; save
compatibility was intentionally dropped in compact save v2.
"""
from __future__ import annotations

from pathlib import Path
import json
import re
import subprocess
import sys
import tempfile

ROOT = Path(__file__).resolve().parents[1]
MANIFEST = ROOT / "app_manifest.json"


def fail(message: str) -> None:
    print(f"[FAIL] {message}", file=sys.stderr)
    raise SystemExit(1)


def ok(message: str) -> None:
    print(f"[OK] {message}")


def read_text(path: Path) -> str:
    return path.read_text(encoding="utf-8")


def manifest() -> dict:
    try:
      data = json.loads(read_text(MANIFEST))
    except Exception as exc:  # pragma: no cover - diagnostic path
      fail(f"cannot read app_manifest.json: {exc}")
    for key in ("version", "css", "js"):
      if key not in data:
        fail(f"manifest missing {key}")
    return data


def check_files_exist(data: dict) -> None:
    missing = [p for p in [*data["css"], *data["js"]] if not (ROOT / p).exists()]
    if missing:
        fail("manifest references missing files: " + ", ".join(missing))
    ok("manifest file references exist")


def check_versions(data: dict) -> None:
    version = str(data["version"])
    version_js = read_text(ROOT / "js/version.js")
    service_worker = read_text(ROOT / "service-worker.js")
    if f'APP_VERSION = "{version}"' not in version_js:
        fail("js/version.js APP_VERSION does not match manifest")
    if f'APP_VERSION = "{version}"' not in service_worker:
        fail("service-worker.js APP_VERSION does not match manifest")
    ok(f"version synchronized: {version}")


def check_index_order(data: dict) -> None:
    index = read_text(ROOT / "index.html")
    css = re.findall(r'<link rel="stylesheet" href="([^"]+)"\s*/>', index)
    scripts = re.findall(r'<script src="([^"]+)" defer></script>', index)
    css_clean = [entry.split("?", 1)[0] for entry in css if entry.startswith("css/")]
    script_clean = [entry.split("?", 1)[0] for entry in scripts if entry.startswith("js/")]
    if css_clean[: len(data["css"])] != data["css"]:
        fail("index.html CSS order differs from manifest")
    if script_clean[: len(data["js"])] != data["js"]:
        fail("index.html JS order differs from manifest")
    ok("index.html load order matches manifest")


def check_service_worker_order(data: dict) -> None:
    sw = read_text(ROOT / "service-worker.js")
    match = re.search(r"const coreScriptNames = \[\s*(.*?)\s*\];", sw, re.S)
    if not match:
        fail("service-worker.js coreScriptNames not found")
    names = re.findall(r'"([^"]+)"', match.group(1))
    expected = [Path(p).stem for p in data["js"]]
    if names != expected:
        fail("service-worker.js coreScriptNames differs from manifest JS order")
    ok("service-worker.js core script order matches manifest")


def node_check(paths: list[Path]) -> None:
    node = "node"
    for path in paths:
        result = subprocess.run([node, "--check", str(path)], cwd=ROOT, text=True, capture_output=True)
        if result.returncode != 0:
            sys.stderr.write(result.stdout)
            sys.stderr.write(result.stderr)
            fail(f"node --check failed: {path.relative_to(ROOT)}")
    ok(f"node --check passed for {len(paths)} files")


def action_spec_smoke() -> None:
    source = read_text(ROOT / "js/tarinai_action_spec.js")
    js = f"""
const vm = require('vm');
const context = {{ console, globalThis: null }};
context.globalThis = context;
context.window = context;
vm.createContext(context);
vm.runInContext({source!r}, context, {{ filename: 'tarinai_action_spec.js' }});
const action = context.registerTarinaiActionSpec({{
  id: 'smoke_action',
  need: 'fulfill',
  label: 'smoke',
  selectTarget() {{ return {{ id: 'target-1' }}; }},
  canStart(t, world, ctx) {{ const target = ctx.target || this.selectTarget(t, world, ctx); return target && target.id === 'target-1'; }},
  start(t, world, ctx) {{ t.startedWith = ctx.target.id; return true; }},
  tick() {{ return 'finished'; }},
  finish(t) {{ t.finished = true; return true; }},
}});
const subject = {{}};
if (!context.canStartTarinaiAction('smoke_action', subject, {{}})) throw new Error('canStart failed');
if (!context.startTarinaiAction(action, subject, {{}})) throw new Error('start failed');
if (subject.startedWith !== 'target-1') throw new Error('selectTarget/start context failed');
if (context.tickTarinaiAction('smoke_action', subject, {{}}, 0.1, {{}}) !== 'finished') throw new Error('tick failed');
if (!context.finishTarinaiAction('smoke_action', subject, {{}}, {{ phase: 'finished' }})) throw new Error('finish failed');
"""
    with tempfile.NamedTemporaryFile("w", encoding="utf-8", suffix=".js", delete=False) as f:
        f.write(js)
        tmp = Path(f.name)
    try:
        result = subprocess.run(["node", str(tmp)], cwd=ROOT, text=True, capture_output=True)
    finally:
        tmp.unlink(missing_ok=True)
    if result.returncode != 0:
        sys.stderr.write(result.stdout)
        sys.stderr.write(result.stderr)
        fail("ActionSpec smoke test failed")
    ok("ActionSpec lifecycle smoke test passed")


def behavior_state_smoke() -> None:
    source = read_text(ROOT / "js/tarinai_behavior_state.js")
    js = f"""
const vm = require('vm');
const context = {{ console, globalThis: null }};
context.globalThis = context;
context.window = context;
context.Tarinai = class Tarinai {{}};
vm.createContext(context);
vm.runInContext({source!r}, context, {{ filename: 'tarinai_behavior_state.js' }});
const t = new context.Tarinai();
t.world = {{ time: 12 }};
t.state = 'seek_food';
context.setTarinaiBehavior(t, {{ id: 'eat_food', need: 'food', label: 'eat', reasonText: 'hungry', tiedNeeds: ['food', 'sleep'], forced: true, forcedId: 'f1', source: 'test', forcedRequest: {{ uid: 'f1', id: 'eat_food', source: 'test', priority: 99, reasonText: 'forced hungry', status: 'active' }} }});
if (context.getTarinaiBehaviorId(t) !== 'eat_food') throw new Error('behavior id mismatch');
if (context.getTarinaiBehaviorNeed(t) !== 'food') throw new Error('behavior need mismatch');
if (!context.isTarinaiBehaviorForced(t)) throw new Error('forced flag not visible');
const forced = context.getTarinaiForcedBehavior(t);
if (!forced || forced.uid !== 'f1' || forced.priority !== 99) throw new Error('forced request not normalized');
if (t.intent.actionId !== 'eat_food' || t.currentAction.need !== 'food' || t.activeForcedBehavior.uid !== 'f1') throw new Error('legacy views not synced');
context.setTarinaiForcedBehavior(t, null);
if (context.currentTarinaiBehavior(t).forced || context.getTarinaiForcedBehavior(t)) throw new Error('forced flag not cleared');
context.clearTarinaiBehavior(t);
if (context.currentTarinaiBehavior(t) !== null) throw new Error('behavior not cleared');
"""
    with tempfile.NamedTemporaryFile("w", encoding="utf-8", suffix=".js", delete=False) as f:
        f.write(js)
        tmp = Path(f.name)
    try:
        result = subprocess.run(["node", str(tmp)], cwd=ROOT, text=True, capture_output=True)
    finally:
        tmp.unlink(missing_ok=True)
    if result.returncode != 0:
        sys.stderr.write(result.stdout)
        sys.stderr.write(result.stderr)
        fail("Behavior state smoke test failed")
    ok("behavior state smoke test passed")


def check_legacy_behavior_refs() -> None:
    allowed = {"js/tarinai.js", "js/tarinai_behavior_state.js"}
    tokens = re.compile(r"\b(activeBehavior|currentAction|activeForcedBehavior|intent)\b")
    offenders = []
    for path in (ROOT / "js").glob("*.js"):
        rel = path.relative_to(ROOT).as_posix()
        if rel in allowed:
            continue
        for i, line in enumerate(read_text(path).splitlines(), start=1):
            if tokens.search(line) and "intentLockTimer" not in line and "//" not in line:
                offenders.append(f"{rel}:{i}")
    if offenders:
        fail("legacy behavior fields outside compatibility layer: " + ", ".join(offenders[:20]))
    ok("legacy behavior fields isolated to compatibility layer")




def check_basic_action_spec_migration() -> None:
    source = read_text(ROOT / "js/tarinai_needs_items.js")
    required = {
        "eat_food": "createConsumableActionSpec",
        "drink_water": "createConsumableActionSpec",
        "use_medicine": "createConsumableActionSpec",
        "sleep_in_bed": "createSleepInBedActionSpec",
        "sleep_build_grass_bed": "createSleepBuildGrassBedActionSpec",
        "sleep_anywhere": "createSleepAnywhereActionSpec",
        "rest_to_recover": "createRestActionSpec",
        "sunbath": "createSunbathActionSpec",
        "wander_lightly": "createWanderActionSpec",
    }
    for action_id, factory in required.items():
        if factory not in source:
            fail(f"basic ActionSpec factory missing for {action_id}: {factory}")
    forbidden_late_ticks = [
        'set("eat_food",',
        'set("drink_water",',
        'set("use_medicine",',
        'set("sunbath",',
    ]
    offenders = [token for token in forbidden_late_ticks if token in source]
    if offenders:
        fail("basic actions still patched in configureTarinaiNeedActions: " + ", ".join(offenders))
    ok("basic need actions migrated into ActionSpec factories")



def check_social_action_spec_migration() -> None:
    source = read_text(ROOT / "js/tarinai_needs_items.js")
    required_factories = [
        "createPanicEscapeActionSpec",
        "createFleeActionSpec",
        "createApproachFriendActionSpec",
        "createApproachFamilyActionSpec",
        "createApproachMateActionSpec",
        "createFightRivalActionSpec",
        "createIntimidateEnemyActionSpec",
        "createBirthRitualActionSpec",
    ]
    for factory in required_factories:
        if factory not in source:
            fail(f"social/combat ActionSpec factory missing: {factory}")
    definitions_match = re.search(r"const TARINAI_ACTION_DEFINITIONS = \[(.*?)\];", source, re.S)
    if not definitions_match:
        fail("TARINAI_ACTION_DEFINITIONS block missing")
    definitions = definitions_match.group(1)
    for factory in required_factories:
        if f"{factory}()" not in definitions:
            fail(f"{factory} is not registered in TARINAI_ACTION_DEFINITIONS")
    if "function configureTarinaiNeedActions" in source:
        fail("configureTarinaiNeedActions should not be needed after ActionSpec runtime migration")
    forbidden_late_ticks = [
        'set("panic_escape",',
        'set("flee",',
        'set("approach_friend",',
        'set("approach_parent_or_child",',
        'set("approach_mate",',
        'set("fight_rival",',
        'set("intimidate_enemy",',
        'set("sunbath",',
        "birthRitualAction",
        "TARINAI_ACTIONS.push",
    ]
    offenders = [token for token in forbidden_late_ticks if token in source]
    if offenders:
        fail("actions still patched late: " + ", ".join(offenders))
    ok("social/fear/combat/mate/birth/sunbath actions migrated into ActionSpec factories")

def check_runtime_diagnostics_hooks() -> None:
    spatial_budget = read_text(ROOT / "js/world_spatial_budget.js")
    debug_tools = read_text(ROOT / "js/debug_tools.js")
    world_update = read_text(ROOT / "js/world_update.js")
    if "runtimeDiagnostics()" not in spatial_budget:
        fail("World.runtimeDiagnostics hook missing")
    if "lastRuntimeDiagnostics" not in world_update:
        fail("world update does not publish lastRuntimeDiagnostics")
    if "spatial rebuild" not in debug_tools or "behavior forced" not in debug_tools:
        fail("debug overlay is missing runtime diagnostic lines")
    ok("runtime diagnostics hooks present")

def check_social_balance_guards() -> None:
    needs = read_text(ROOT / "js/tarinai_needs_items.js")
    world_social = read_text(ROOT / "js/world_family_social.js")
    social_move = read_text(ROOT / "js/tarinai_social_move_life.js")
    required_need_tokens = [
        "fight_rival: 56",
        "intimidate_enemy: 42",
        "approach_mate: 68",
        "approach_friend: 66",
        "return ({ conflict: 34, mate: 24, family: 12, bond: 14",
        "if (subNeed !== \"conflict\" && subValue >= threshold) return true",
        "subValue >= threshold && subValue >= socialPull * 0.82",
    ]
    for token in required_need_tokens:
        if token not in needs:
            fail(f"social balance guard token missing: {token}")
    if "canStart: basicCanStartWithTarget,\n    start(t, world, ctx = {}) {\n      const rival" in needs:
        fail("intimidate_enemy reverted to ungated basicCanStart")
    required_world_tokens = [
        "fightPairCooldowns",
        "fightPairKey(a, b)",
        "fightPairCooldownRemaining(a, b)",
        "markFightPairCooldown(a, b",
        "isAlreadyFightingPair(a, b)",
        "if (this.isAlreadyFightingPair?.(a, b)) return true",
    ]
    for token in required_world_tokens:
        if token not in world_social:
            fail(f"fight re-entry guard missing: {token}")
    if "dt * (battleDrug ? 0.23 : 0.085)" not in social_move:
        fail("ordinary proximity fight probability guard missing")
    ok("social balance and fight re-entry guards present")


def check_item_bucket_polish() -> None:
    spatial_budget = read_text(ROOT / "js/world_spatial_budget.js")
    required_tokens = [
        "markItemBucketsDirty(reason",
        "ensureItemBuckets(reason",
        "addItem(item",
        "itemById(id)",
        "itemsOfType(type)",
        "liveItemsOfType(type",
        "this.itemIdMap = new Map()",
        "bucketRebuildsTotal",
    ]
    for token in required_tokens:
        if token not in spatial_budget:
            fail(f"item bucket polish helper missing: {token}")
    if "return item && !item.dead ? item : null" not in spatial_budget:
        fail("itemById must not return dead items")
    debug_tools = read_text(ROOT / "js/debug_tools.js")
    if "bucket" not in debug_tools.lower() and "id-map" not in debug_tools.lower():
        fail("debug overlay is missing item bucket/id-map diagnostics")
    routed_files = {
        "js/world_placement_log.js": "addItem?.(item",
        "js/world_update.js": "addItem?.(drop",
        "js/world_combat_effects.js": "addItem?.(it",
        "js/ants.js": "addItem?.(corpse",
        "js/tarinai_social_move_life.js": "addItem?.(new Item(\"trace\"",
        "js/tarinai_needs_items.js": "addItem?.(structure",
    }
    for rel, token in routed_files.items():
        if token not in read_text(ROOT / rel):
            fail(f"runtime item creation path is not routed through addItem: {rel}")
    ok("runtime item bucket/id-map polish present")


def check_compact_save_v2() -> None:
    snapshot = read_text(ROOT / "js/snapshot_system.js")
    save = read_text(ROOT / "js/save_system.js")
    required_snapshot = [
        "const SNAPSHOT_VERSION = 2",
        "function compactWorld",
        "function compactTarinai",
        "function compactItem",
        "function compactAnt",
        "logs = []",
        "worldRef.family = {}",
        "recordFamily",
    ]
    for token in required_snapshot:
        if token not in snapshot:
            fail(f"compact save v2 snapshot token missing: {token}")
    forbidden_snapshot = [
        "logs: clonePlain",
        "effects: (worldRef.effects",
        "summary:",
        "app: \"tarinai_colony_game\"",
    ]
    offenders = [token for token in forbidden_snapshot if token in snapshot]
    if offenders:
        fail("old broad snapshot fields still present: " + ", ".join(offenders))
    required_save = [
        'STORAGE_PREFIX = "tarinai_save_slot_v2_"',
        'EXPORT_PREFIX = "TN2!"',
        "SAVE_TEXT_ALPHABET",
        "base91Encode",
        "base91Decode",
        'CompressionStream("deflate-raw")',
        "DecompressionStream",
        "async function encodeSnapshot",
        "async function decodeSnapshot",
    ]
    for token in required_save:
        if token not in save:
            fail(f"compact save v2 encoder token missing: {token}")
    if "TARINAI_SAVE_V1" in save or "tarinai_save_slot_v1" in save:
        fail("old save v1 prefix still present")
    ok("compact save v2 snapshot and encoder present")

def main() -> None:
    data = manifest()
    check_files_exist(data)
    check_versions(data)
    check_index_order(data)
    check_service_worker_order(data)
    node_check([*(ROOT / "js").glob("*.js"), ROOT / "service-worker.js"])
    action_spec_smoke()
    behavior_state_smoke()
    check_basic_action_spec_migration()
    check_social_action_spec_migration()
    check_runtime_diagnostics_hooks()
    check_social_balance_guards()
    check_item_bucket_polish()
    check_compact_save_v2()
    check_legacy_behavior_refs()


if __name__ == "__main__":
    main()