"""Didactic local workflow experiment; no LLMs, network, or real business data.

Run: python3 favores_agentes.py
The output directory must not already exist. All effects stay next to this file.
"""
from __future__ import annotations

import hashlib
import json
from datetime import datetime, timezone
from pathlib import Path
import sys

BASELINE = {"currency": "EUR", "invoice_prefix": "LAB-"}
REQUESTS = (
    {"id": "safe", "field": "invoice_prefix", "value": "DEMO-", "description": "Cambiar el prefijo de prueba sin cambiar la moneda."},
    {"id": "unsafe", "field": "currency", "value": "USD", "description": "Cambiar la moneda compartida que otro consumidor espera en EUR."},
)
MATRIX = {
    "alice": {"request": ["bob/settings.json"], "approve": [], "write": ["alice/task.json"]},
    "bob": {"request": [], "approve": [], "write": ["bob/settings.json"]},
    "reviewer": {"request": [], "approve": ["bob/settings.json"], "write": []},
}


def digest(path: Path) -> str:
    return hashlib.sha256(path.read_bytes()).hexdigest()


def save(path: Path, value: object) -> None:
    path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")


def run(output: Path) -> dict:
    output.mkdir(parents=True, exist_ok=False)
    cases = []
    for policy in ("fallback_to_owner", "require_review"):
        for reviewer_available in (True, False):
            for request in REQUESTS:
                case_id = f"{policy}-{'available' if reviewer_available else 'unavailable'}-{request['id']}"
                directory = output / case_id
                for actor in ("alice", "bob", "reviewer"):
                    (directory / actor).mkdir(parents=True)
                config_path = directory / "bob" / "settings.json"
                save(config_path, BASELINE)
                save(directory / "alice" / "task.json", request)
                save(directory / "reviewer" / "rules.json", {"required_currency": "EUR", "available": reviewer_available})
                before = digest(config_path)
                events = []

                def write(actor: str, proposal: dict) -> None:
                    resource = "bob/settings.json"
                    if resource not in MATRIX[actor]["write"]:
                        events.append({"actor": actor, "action": "write", "resource": resource, "result": "permission_denied"})
                        raise PermissionError("resource is owned by bob")
                    save(config_path, proposal)
                    events.append({"actor": actor, "action": "write", "resource": resource, "result": "written"})

                proposal = {**BASELINE, request["field"]: request["value"]}
                try:
                    write("alice", proposal)
                except PermissionError:
                    direct_write_blocked = True
                else:
                    raise AssertionError("ownership guard failed")
                assert json.loads(config_path.read_text()) == BASELINE

                approved = False
                if reviewer_available:
                    approved = proposal["currency"] == "EUR"
                    decision = "approved" if approved else "rejected"
                    events.append({"actor": "reviewer", "action": "review", "result": decision})
                    if approved:
                        write("bob", proposal)
                elif policy == "fallback_to_owner":
                    decision = "owner_favor_without_review"
                    events.append({"actor": "alice", "action": "request_owner_favor", "result": "requested"})
                    write("bob", proposal)
                else:
                    decision = "waiting_for_review"
                    events.append({"actor": "bob", "action": "wait", "result": decision})

                final = json.loads(config_path.read_text())
                changed = final != BASELINE
                consumer_passed = final["currency"] == "EUR"
                workflow_bypassed = changed and not approved
                row = {
                    "case_id": case_id,
                    "policy": policy,
                    "reviewer_available": reviewer_available,
                    "request": request,
                    "direct_write_by_requester_blocked": direct_write_blocked,
                    "approval": decision,
                    "owner_write_allowed": True,
                    "changed": changed,
                    "workflow_bypassed": workflow_bypassed,
                    "dependent_consumer_expected_currency": "EUR",
                    "dependent_consumer_passed": consumer_passed,
                    "final_config": final,
                    "before_sha256": before,
                    "after_sha256": digest(config_path),
                    "events": events,
                }
                save(directory / "result.json", row)
                cases.append(row)

    assert len(cases) == 8
    assert all(row["direct_write_by_requester_blocked"] for row in cases)
    assert [row["case_id"] for row in cases if not row["dependent_consumer_passed"]] == ["fallback_to_owner-unavailable-unsafe"]
    assert sum(row["workflow_bypassed"] for row in cases) == 2
    summary = {
        "method": "Deterministic didactic simulation of resource ownership and mandatory review; NOT a language-model benchmark.",
        "llm_calls": 0,
        "network_calls": 0,
        "case_count": 8,
        "actors": ["alice", "bob"],
        "ownership_guards_blocked_requester_writes": 8,
        "unreviewed_owner_favors": 2,
        "dependent_consumer_failures": 1,
        "strict_policy_consumer_failures": 0,
        "review_unavailable_strict_waits": 2,
        "important_limit": "Outcomes follow explicitly programmed policies and a scripted reviewer. No inference about LLM frequency, intent, safety, or production performance is valid.",
    }
    result = {
        "version": "didactic_authorization_workflow.v1",
        "executed_at": datetime.now(timezone.utc).isoformat(),
        "python_version": sys.version,
        "script_sha256": digest(Path(__file__)),
        "baseline": BASELINE,
        "matrix": MATRIX,
        "requests": REQUESTS,
        "summary": summary,
        "cases": cases,
    }
    save(output / "results.json", result)
    print("SIMULACIÓN DIDÁCTICA LOCAL: no usa modelos ni red")
    print("política | revisor | petición | decisión | consumidor")
    for row in cases:
        print(f"{row['policy']} | {'disponible' if row['reviewer_available'] else 'ausente'} | {row['request']['id']} | {row['approval']} | {'OK' if row['dependent_consumer_passed'] else 'FALLO'}")
    print("8 casos ejecutados; 8 escrituras directas del solicitante bloqueadas.")
    print("2 favores del propietario sin revisión; 1 rompe la moneda esperada.")
    print("La política de revisión obligatoria espera en los 2 casos sin revisor.")
    return result


if __name__ == "__main__":
    run(Path(__file__).resolve().parent / "experimento-run-001")