#!/usr/bin/env python3
"""Advance the Web task ledger to the next executable leaf task.

The command is deliberately deterministic and single-shot: it never marks a
task complete. It continues an existing ``in_progress`` task, or, when that
task is already terminal, claims the first dependency-ready leaf and rebuilds
the isolated context. An agent/external scheduler can call it after each
implementation batch without asking for user confirmation.
"""
from __future__ import annotations

import argparse
import hashlib
import json
import os
import subprocess
import sys
from datetime import datetime, timezone
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))
from web_context import load_cards, predecessor_ids  # noqa: E402
from implementation_first import capability_source_fingerprint, implementation_first_enabled, load_registry, user_validation_deferred  # noqa: E402
from scheduler_progress import batch_retry_details, read as read_progress  # noqa: E402
from failure_reconciliation import pending_keys, pending_business_repair  # noqa: E402
from prepare_feature_capability_batch import stalled_batch_limit  # noqa: E402


ROOT = Path(__file__).resolve().parents[1]
STATE = ROOT / "docs/current/task-state.json"
CHECKPOINT = ROOT / "docs/current/continuation-state.json"
CONTEXT_DIR = ROOT / "docs/current/context"
CANONICAL_MANIFESTS = (
    ROOT / "docs/p6/python-api-manifest.json",
    ROOT / "docs/p6/object-contract-matrix.json",
    ROOT / "docs/p6/workbench-command-matrix.json",
)
MODULE_PIPELINE = ROOT / "docs/current/module-batch-pipeline.json"
CAPABILITY_REGISTRY = ROOT / "docs/current/feature-capability-registry.json"
PROBE_ROOT = ROOT / "freecad-source/src/WebAssembly/FreeCADCoreProbe"
STALLED_BATCH_SIZE = max(1, int(os.environ.get("FREECAD_STALLED_FEATURE_BATCH_SIZE", "4")))
STALLED_BATCH_SECONDS = max(30.0, float(os.environ.get("FREECAD_STALLED_FEATURE_BATCH_SECONDS", "180")))
MIXED_FEATURE_BATCH_SIZE = max(2, int(os.environ.get("FREECAD_MIXED_FEATURE_BATCH_SIZE", "8")))


def run(*args: str) -> None:
    subprocess.run([sys.executable, *args], cwd=ROOT, check=True)


def refresh_feature_registry_if_sources_changed() -> bool:
    """Refresh the cheap capability projection only after probe source edits.

    Feature batches without an outer build target still need their static
    routed/required projection refreshed.  Comparing mtimes avoids rescanning
    probe contents on every cycle while ensuring a just-edited native adapter
    is visible to the next planner pass.
    """
    if not implementation_first_enabled():
        return False
    try:
        registry_mtime = CAPABILITY_REGISTRY.stat().st_mtime_ns
    except OSError:
        registry_mtime = 0
    source_files = list(PROBE_ROOT.glob("*Probe.cpp")) + list(PROBE_ROOT.glob("*DesktopCommands.cpp"))
    if not source_files:
        return False
    try:
        changed = any(path.stat().st_mtime_ns > registry_mtime for path in source_files)
    except OSError:
        return False
    if not changed:
        return False
    result = subprocess.run(
        [sys.executable, "tools/generate_feature_capability_registry.py"],
        cwd=ROOT,
        text=True,
        capture_output=True,
        check=False,
    )
    if result.returncode != 0:
        # Keep the existing projection on a transient source read error; the
        # normal scheduler error path will record the next actionable failure.
        return False
    if result.stdout:
        print(f"FEATURE_REGISTRY_REFRESH: {result.stdout.strip()}")
    return True


def selected_routed_ids(batch: dict) -> set[str]:
    """Return currently routed IDs intersecting the selected feature batch."""
    if batch.get("strategy") != "feature-first-deferred-validation":
        return set()
    try:
        payload = json.loads(CAPABILITY_REGISTRY.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        return set()
    routed = {
        str(row.get("id"))
        for row in payload.get("records", [])
        if isinstance(row, dict) and row.get("implementationStatus") == "routed"
    }
    return {
        str(row[0])
        for row in batch.get("records", [])
        if isinstance(row, list) and row and str(row[0]) in routed
    }


def planner_script() -> str:
    return "tools/prepare_implementation_business_batch.py" if implementation_first_enabled() else "tools/prepare_full_parity_module_batch.py"


def run_continuation_check() -> bool:
    """Validate the checkpoint and report whether a repair changed projections."""
    try:
        run("tools/check_continuation_state.py")
        return False
    except subprocess.CalledProcessError:
        subprocess.run([sys.executable, "tools/compact_continuation_docs.py"], cwd=ROOT, check=False)
        # Compression changes handoff/card hashes; regenerate the active packet
        # before retrying validation so the failure loop cannot use stale data.
        subprocess.run([sys.executable, "tools/prepare_web_task_context.py"], cwd=ROOT, check=False)
        retry_check = subprocess.run(
            [sys.executable, "tools/check_continuation_state.py"], cwd=ROOT, check=False
        )
        if retry_check.returncode == 0:
            return False
        repair = subprocess.run(
            [sys.executable, "tools/repair_continuation_checkpoint.py"],
            cwd=ROOT,
            text=True,
            capture_output=True,
            check=False,
        )
        if repair.returncode != 0:
            raise
        print(repair.stdout, end="")
        subprocess.run([sys.executable, "tools/prepare_web_task_context.py"], cwd=ROOT, check=False)
        run("tools/check_continuation_state.py")
        return True


def feature_batch_replan_size(batch: dict) -> int | None:
    if not implementation_first_enabled():
        return None
    selected = batch.get("selected") if isinstance(batch.get("selected"), dict) else {}
    selected_count = int(selected.get("recordCount", 0) or 0)
    if selected.get("family") == "desktop-command-mixed" and selected_count > MIXED_FEATURE_BATCH_SIZE:
        return MIXED_FEATURE_BATCH_SIZE
    if selected_count <= STALLED_BATCH_SIZE:
        return None
    try:
        pipeline = json.loads(MODULE_PIPELINE.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        pipeline = {}
    return stalled_batch_limit(batch, pipeline)


def batch_requires_refresh() -> bool:
    """Return true for a stale/undersized projection before validation runs."""
    batch_path = ROOT / "docs/current/module-batch-manifest.json"
    if not batch_path.exists():
        return True
    try:
        batch = json.loads(batch_path.read_text(encoding="utf-8"))
        checkpoint = json.loads(CHECKPOINT.read_text(encoding="utf-8"))
        task_state = json.loads(STATE.read_text(encoding="utf-8"))
        selected = batch.get("selected") if isinstance(batch.get("selected"), dict) else {}
        minimum = int(checkpoint.get("batchPolicy", {}).get("minRecords", 2))
        completed_batches = checkpoint.get("latestBatch", {}).get("completed", [])
        batch_checkpoint = checkpoint.get("batch_checkpoint") if isinstance(checkpoint.get("batch_checkpoint"), dict) else {}
        if not batch_checkpoint and isinstance(task_state.get("batch_checkpoint"), dict):
            batch_checkpoint = task_state["batch_checkpoint"]
        batch_id = batch.get("batchId")
        if user_validation_deferred() and selected.get("tier") in {"business-acceptance", "failure-reconciliation"}:
            return True
        if implementation_first_enabled() and batch_retry_details(batch):
            return True
        if implementation_first_enabled() and selected.get("tier") == "feature-workflow":
            from prepare_implementation_business_batch import acceptance_preempts
            if acceptance_preempts(batch):
                return True
        if implementation_first_enabled() and selected.get("tier") == "failure-reconciliation":
            remaining = pending_keys(batch.get("failureKeys", []))
            return (batch.get("status") != "ready" or not batch.get("failureKeys")
                    or len(remaining) != len(batch["failureKeys"]) or pending_business_repair(batch["failureKeys"]))
        if implementation_first_enabled() and selected.get("tier") == "business-acceptance":
            from prepare_business_acceptance_batch import inventory
            pending = {row["id"] for row in inventory()["pending"]}
            ids = {str(row[0]) for row in batch.get("records", []) if row}
            if batch.get("status") != "ready" or not ids or not ids <= pending:
                return True
            generated = datetime.fromisoformat(str(batch.get("generatedAt", "")).replace("Z", "+00:00")).timestamp()
            history = read_progress(ROOT / "docs/current/scheduler-progress.json").get("history", [])
            return any(row.get("batchId") == batch_id and row.get("tier") == "business-acceptance"
                       and row.get("outcome") != "provider_wait" and float(row.get("at", 0)) >= generated for row in history)
        if implementation_first_enabled() and batch.get("strategy") != "feature-first-deferred-validation":
            return True
        if implementation_first_enabled() and batch.get("status") == "no_ready_batch":
            return batch.get("sourceFingerprint") != capability_source_fingerprint()
        # A feature batch can become partially routed from native source edits
        # even when no outer build target exists.  Replan immediately so the
        # next turn receives only the remaining records instead of rereading
        # already implemented commands.
        if implementation_first_enabled() and selected_routed_ids(batch):
            return True
        if feature_batch_replan_size(batch) is not None:
            return True
        implementation_batches = load_registry().get("batches", {}) if implementation_first_enabled() else {}
        if isinstance(implementation_batches, dict) and batch_id in implementation_batches:
            return True
        if batch_records_have_evidence(batch):
            return True
        if batch_id in completed_batches or (
            batch_checkpoint.get("batchId") == batch_id
            and str(batch_checkpoint.get("status", "")) in {"pass", "pass_with_boundaries", "completed", "blocked_native_probe"}
        ):
            return True
        if batch.get("status") != "ready" or batch.get("taskId") not in (None, checkpoint.get("activeTask")):
            return True
        return int(selected.get("recordCount", 0)) < minimum and batch.get("singletonFallback") is not True
    except (OSError, json.JSONDecodeError, TypeError, ValueError):
        return True


def batch_records_have_evidence(batch: dict) -> bool:
    """Detect a completed batch even when its compact checkpoint was interrupted."""
    if implementation_first_enabled():
        # Current business completion is owned by implementation receipts and
        # business acceptance, not the legacy API/object evidence inventories.
        return False
    records = batch.get("records") if isinstance(batch.get("records"), list) else []
    ids = {row[0] for row in records if isinstance(row, list) and row}
    if not ids:
        return False
    found: dict[str, dict] = {}
    batch_id = batch.get("batchId")
    if isinstance(batch_id, str):
        for evidence_path in (ROOT / "docs/p6").glob(f"*{batch_id}*runtime.json"):
            try:
                evidence = json.loads(evidence_path.read_text(encoding="utf-8"))
            except (OSError, json.JSONDecodeError):
                continue
            evidence_state = str(evidence.get("status") or (evidence.get("result") if isinstance(evidence.get("result"), str) else "") or "")
            if not (evidence_state in {"pass", "passed", "pass_with_boundaries", "completed", "blocked_native_probe", "pass_with_restricted_and_pending"} or evidence_state.startswith("pass_with_")):
                continue
            result_payload = evidence.get("result") if isinstance(evidence.get("result"), dict) else {}
            evidence_rows = evidence.get("records", []) if isinstance(evidence.get("records"), list) else result_payload.get("records", [])
            for row in evidence_rows if isinstance(evidence_rows, list) else []:
                if isinstance(row, dict):
                    record_id = row.get("apiId") or row.get("id")
                    if isinstance(record_id, str) and record_id in ids:
                        found[record_id] = row
        if len(found) == len(ids):
            return True
    for path in CANONICAL_MANIFESTS:
        try:
            payload = json.loads(path.read_text(encoding="utf-8"))
        except (OSError, json.JSONDecodeError):
            continue
        rows = payload.get("records", []) if isinstance(payload, dict) else []
        for row in rows:
            if isinstance(row, dict) and row.get("id") in ids:
                found[str(row["id"])] = row
    if len(found) != len(ids):
        return False
    return all(isinstance(row.get("dispositionEvidence"), list) and bool(row["dispositionEvidence"]) for row in found.values())


def context_requires_refresh(active: str) -> bool:
    """Use the materialized manifest as an incremental context fingerprint."""
    manifest_path = CONTEXT_DIR / f"{active}.json"
    try:
        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
        if manifest.get("task_id") != active or manifest.get("active_task") != active:
            return True
        for entry in manifest.get("files", []):
            if entry.get("mode") != "read":
                continue
            path = ROOT / str(entry.get("path", ""))
            if not path.is_file():
                return True
            stat = path.stat()
            # New packets carry size/mtime metadata, so the common unchanged
            # path avoids rereading every context file just to hash it. Keep a
            # hash fallback for older manifests and unusual timestamp changes.
            recorded_size = entry.get("bytes")
            recorded_mtime = entry.get("mtime_ns")
            if recorded_size is None or recorded_mtime is None:
                # Upgrade legacy packets once so subsequent cycles can use the
                # cheap metadata path.
                return True
            if stat.st_size == int(recorded_size) and stat.st_mtime_ns == int(recorded_mtime):
                continue
            if hashlib.sha256(path.read_bytes()).hexdigest() != entry.get("sha256"):
                return True
        return False
    except (OSError, json.JSONDecodeError, TypeError):
        return True
def prepare_module_batch() -> None:
    batch_path = ROOT / "docs/current/module-batch-manifest.json"
    if batch_path.exists():
        try:
            batch = json.loads(batch_path.read_text(encoding="utf-8"))
            checkpoint = json.loads(CHECKPOINT.read_text(encoding="utf-8"))
            task_state = json.loads(STATE.read_text(encoding="utf-8"))
            selected = batch.get("selected") if isinstance(batch.get("selected"), dict) else {}
            minimum = int(checkpoint.get("batchPolicy", {}).get("minRecords", 2))
            completed_batches = checkpoint.get("latestBatch", {}).get("completed", [])
            implementation_batches = load_registry().get("batches", {}) if implementation_first_enabled() else {}
            batch_checkpoint = checkpoint.get("batch_checkpoint") if isinstance(checkpoint.get("batch_checkpoint"), dict) else {}
            if not batch_checkpoint and isinstance(task_state.get("batch_checkpoint"), dict):
                batch_checkpoint = task_state["batch_checkpoint"]
            # A completed implementation batch may have explicitly selected
            # the next family. Preserve that selection across CONTINUE turns;
            # the planner's default ordering would otherwise replay the same
            # unresolved boundary batch indefinitely.
            if (
                batch.get("status") == "ready"
                and not (user_validation_deferred() and selected.get("tier") in {"business-acceptance", "failure-reconciliation"})
                and (not implementation_first_enabled() or batch.get("strategy") == "feature-first-deferred-validation"
                     or selected.get("tier") == "failure-reconciliation" and bool(batch.get("failureKeys"))
                     and len(pending_keys(batch["failureKeys"])) == len(batch["failureKeys"])
                     and not pending_business_repair(batch.get("failureKeys", [])))
                and not batch_retry_details(batch)
                and batch.get("batchId")
                and batch.get("batchId") == checkpoint.get("batchId")
                and batch.get("batchId") not in completed_batches
                and not (isinstance(implementation_batches, dict) and batch.get("batchId") in implementation_batches)
                and not batch_records_have_evidence(batch)
                and not selected_routed_ids(batch)
                and feature_batch_replan_size(batch) is None
                and not (
                    batch_checkpoint.get("batchId") == batch.get("batchId")
                    and str(batch_checkpoint.get("status", "")) in {"pass", "pass_with_boundaries", "completed", "blocked_native_probe"}
                )
                and (int(selected.get("recordCount", 0)) >= minimum or batch.get("singletonFallback") is True)
            ):
                print(
                    f"MODULE_BATCH_PRESERVED: batchId={batch.get('batchId')} "
                    f"module={selected.get('module')} tier={selected.get('tier')} "
                    f"family={selected.get('family')} records={selected.get('recordCount')}"
                )
                return
        except (OSError, json.JSONDecodeError):
            pass
    result = subprocess.run(
        [sys.executable, planner_script()],
        cwd=ROOT,
        text=True,
        capture_output=True,
        check=False,
    )
    if result.stdout:
        print(result.stdout, end="")
    if result.returncode not in (0, 2):
        raise subprocess.CalledProcessError(result.returncode, result.args, result.stdout, result.stderr)
    if batch_path.exists():
        try:
            batch = json.loads(batch_path.read_text(encoding="utf-8"))
            checkpoint = json.loads(CHECKPOINT.read_text(encoding="utf-8"))
            checkpoint["batchManifest"] = "docs/current/module-batch-manifest.json"
            checkpoint["batchId"] = batch.get("batchId")
            checkpoint["batchSelection"] = batch.get("selected")
            selected = batch.get("selected") if isinstance(batch.get("selected"), dict) else {}
            if selected:
                checkpoint["nextAction"] = (
                    f"继续执行 Part batch {batch.get('batchId')} 的 "
                    f"{selected.get('module')}/{selected.get('tier')}/{selected.get('family')} "
                    f"{selected.get('recordCount')} 条记录；复用统一 native dispatcher、Facade 和 Worker，"
                    "仅以真实 FreeCAD/WASM evidence 晋级，其余保留显式边界。"
                )
            CHECKPOINT.write_text(json.dumps(checkpoint, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
        except (OSError, json.JSONDecodeError):
            pass


def update_checkpoint(active: str, card_text: str) -> None:
    checkpoint = json.loads(CHECKPOINT.read_text(encoding="utf-8"))
    checkpoint["activeTask"] = active
    checkpoint["phase"] = "CONTINUE"
    checkpoint["lastCheckpoint"] = "CONTINUE"
    checkpoint["lastTransition"] = datetime.now(timezone.utc).isoformat()
    contract = next((line.split("合同：", 1)[1].strip() for line in card_text.splitlines() if "合同：" in line), "执行当前任务卡中的合同")
    checkpoint["nextAction"] = contract
    CHECKPOINT.write_text(json.dumps(checkpoint, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--dry-run", action="store_true", help="report the next leaf without changing the ledger")
    args = parser.parse_args()
    state = json.loads(STATE.read_text(encoding="utf-8"))
    statuses = state.get("tasks", {})
    active = state.get("active_task")
    # Only parse cards that can participate in this transition. The full card
    # inventory is reserved for the explicit post-implementation validator.
    relevant_ids = [active] if active else []
    relevant_ids.extend(task_id for task_id, status in statuses.items() if status == "planned")
    cards = load_cards(relevant_ids)
    if active and statuses.get(active) == "in_progress":
        if args.dry_run:
            print(f"TASK_CYCLE_ACTIVE: {active} (dry-run; no files changed)")
            return 0
        refresh_feature_registry_if_sources_changed()
        # The outer scheduler prepares the projection before each Codex turn.
        # Rebuild only when the batch/checkpoint fingerprint has changed.
        if batch_requires_refresh():
            prepare_module_batch()
        checkpoint_repaired = run_continuation_check()
        # A repair can change the checkpoint projection, so check once more
        # after validation while preserving an already-ready batch.
        if checkpoint_repaired and batch_requires_refresh():
            prepare_module_batch()
        batch_path = ROOT / "docs/current/module-batch-manifest.json"
        batch = json.loads(batch_path.read_text(encoding="utf-8")) if batch_path.exists() else {}
        if implementation_first_enabled() and batch.get("status") in {"no_ready_batch", "waiting_for_retry"}:
            # The feature registry and runtime-issue ledger are fingerprinted
            # by the planner. Do not rewrite context/checkpoint while idle;
            # that would make the next cycle stale and create perpetual work.
            print(f"TASK_CYCLE_FEATURE_IDLE: active={active} sourceFingerprint={batch.get('sourceFingerprint')}")
            return 0
        if context_requires_refresh(active):
            run("tools/prepare_web_task_context.py")
        else:
            print(f"CONTEXT_PACKET_REUSED: active={active}")
        # Keep the incremental contract check on every cycle, but let it use
        # the manifest's metadata fast path for unchanged inputs.
        if not implementation_first_enabled():
            run("tools/validate_incremental_context.py")
        active_card = cards.get(active)
        if active_card:
            update_checkpoint(active, active_card[2])
        print(f"TASK_CYCLE_CONTINUE: active={active}")
        return 0

    candidates: list[tuple[str, Path, str]] = []
    for task_id, (path, card_status, text) in cards.items():
        if statuses.get(task_id, card_status) != "planned":
            continue
        if path.parent == ROOT / "docs/tasks/p6":
            continue
        predecessors = predecessor_ids(text)
        if all(statuses.get(item) == "completed" for item in predecessors):
            priority = 0 if task_id.startswith("FW-P6-FPA-IMPL-") else 1
            candidates.append((f"{priority}:{task_id}", path, text))
    if not candidates:
        print("TASK_CYCLE_NO_READY_LEAF: no dependency-ready planned leaf task")
        return 2
    _, path, text = sorted(candidates, key=lambda item: item[0])[0]
    next_task = next(task_id for task_id, (candidate, _, _) in cards.items() if candidate == path)
    if args.dry_run:
        print(f"TASK_CYCLE_NEXT: {next_task} ({path.relative_to(ROOT)})")
        return 0

    reason = "completed" if active and statuses.get(active) == "completed" else "interrupted"
    run("tools/rotate_web_task_context.py", "--reason", reason, "--next-task", next_task)
    run("tools/sync_web_task_state.py", "--active", next_task)
    update_checkpoint(next_task, text)
    run("tools/check_continuation_state.py")
    prepare_module_batch()
    run("tools/prepare_web_task_context.py")
    if not implementation_first_enabled():
        run("tools/validate_incremental_context.py")
    print(f"TASK_CYCLE_CLAIMED: {next_task} ({path.relative_to(ROOT)})")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())