"""ORC Value Standard, reference model v0.2.

Extends orc_model.py (v0.1) with four things:
  1. the finesse hurdle and hidden work, as multipliers on the build work;
  2. an error range: every figure is the P10, P50 and P90 of a seeded simulation;
  3. the P/R curve: price-to-replication today, 12, 24 and 36 months ahead, and at the floor;
  4. the Value Score and its issue rule.

Run:  python3 orc_value_model.py        (prints JSON; same seed, same numbers)

Evidence grades of the inputs
  A  published facts: developer wage (US BLS, May 2025), plan price (cotbase.com, 13 Nov 2026)
  C  declared assumptions (bootstrap values, to be replaced by a measured Index and by sealed
     measurements). Every range below is read as a P10 to P90 interval of a lognormal distribution.

Formulas
  work      W      = Z * (1 + hidden) * finesse * (tokens + hours * wage)
  today     ORC(0) = (W + setup * wage + access * p) / pi  +  upkeep * W * T / 12  +  attention * wage * T
  floor     ORC_inf= (commission * wage + access * p) / pi  +  attention_limit * wage * T  +  verification
  path      ORC(t) = ORC_inf + (ORC(0) - ORC_inf) * 2 ** (-t / h)
  unit      P/R(t) = S / ORC(t),  S = p * T
  hold(t)          = share of simulated outcomes with S < ORC(t)
  Value Score      = 100 * (1 - S / P10[ORC(36)]),  issued only if hold(36) >= 0.90
"""
import json
import math
import random

WAGE = 135980 / 2080            # US BLS median software developer, May 2025, per hour (grade A)
PRICE = 14.0                    # COTBase Premium, yearly plan, per month (grade A)
T = 36                          # standard horizon, months, no discounting
S = PRICE * T                   # outlay at standard conditions
PI = 0.8                        # probability that a build reaches the stated fidelity
SETUP_H, ACCESS_M, UPKEEP = 3.0, 1.0, 0.15
COMMISSION_H = 1.0              # hours to commission a build at full automation
SEED, N = 20261113, 100_000
Z90 = 1.2815515655446004        # standard normal quantile at 0.90


def ln(lo, hi, z):
    """Lognormal draw whose P10 is lo and P90 is hi, from a standard normal z."""
    return math.exp((math.log(lo) + math.log(hi)) / 2 + (math.log(hi) - math.log(lo)) / (2 * Z90) * z)


# ranges are (P10, P90); a single number is a fixed value
PUBLIC = {
    "size_cfp":      (80, 125),      # function points of the standard buyer's core, counted from outside
    "tokens_cfp":    (2.0, 6.0),     # USD of tokens per function point   } one shared level, as in v0.1:
    "hours_cfp":     (0.08, 0.24),   # oversight hours per function point } P10 = low case, P90 = high case
    "hidden":        (0.05, 0.40),   # work the outside view misses, as a share of the counted size
    "finesse_extra": (0.10, 0.50),   # finesse factor minus one (grade Phi-2, visible calibration)
    "attention":     (0.25, 1.00),   # hours a month to keep a personal copy running today
    "attention_lim": (0.05, 0.20),   # the same at full automation
    "halving":       (6.0, 12.0),    # months for AI-priced cost to halve
    "verify_lag": 0.0, "verify_att": (0.3, 0.8), "verify_att_lim": (0.05, 0.20),
}
# What a sealed measurement could change. The findings are invented to show the mechanics:
# nobody has inspected the COTBase codebase.
SEALED = {
    "A plain":   dict(PUBLIC, size_cfp=(95, 105), hidden=(0.06, 0.10), finesse_extra=(0.03, 0.08)),
    "B crafted": dict(PUBLIC, size_cfp=(95, 105), hidden=(0.26, 0.34), finesse_extra=(0.65, 1.00)),
    "C hidden":  dict(PUBLIC, size_cfp=(95, 105), hidden=(0.26, 0.34), finesse_extra=(0.65, 1.00), verify_lag=13.0),
}
# What a measured Index could change: the same medians, with the spread a measurement would leave (invented spreads).
INDEX = dict(tokens_cfp=(2.83, 4.24), hours_cfp=(0.113, 0.170), attention=(0.40, 0.63), attention_lim=(0.07, 0.14), halving=(7.5, 9.6))


def verification_lag(sigma_over_eps, weeks_per_obs=1.0, alpha_z=1.6448536269514722, power_z=0.8416212335729143):
    """Months of public outcomes needed to show quality parity within tolerance eps (one-sided 5%, power 80%)."""
    n = ((alpha_z + power_z) * sigma_over_eps) ** 2
    return n * weeks_per_obs * 12 / 52.1775, n


KEYS = ["size_cfp", "unit", "hidden", "finesse_extra", "attention", "attention_lim", "halving", "verify_att", "verify_att_lim"]


def simulate(cfg, seed=SEED, n=N, only=None):
    """only: vary just these inputs and hold the others at their medians (used for the variance shares)."""
    rnd = random.Random(seed)
    rows = []
    for _ in range(n):
        z = {k: rnd.gauss(0, 1) for k in KEYS}
        if only is not None:
            z = {k: (v if k in only else 0.0) for k, v in z.items()}
        g = lambda k, zk=None: (ln(*cfg[k], z[zk or k]) if isinstance(cfg[k], tuple) else cfg[k])
        size = g("size_cfp")
        unit = g("tokens_cfp", "unit") + g("hours_cfp", "unit") * WAGE
        tok_share = g("tokens_cfp", "unit") / unit
        work = size * (1 + g("hidden")) * (1 + g("finesse_extra")) * unit
        lag = cfg["verify_lag"]
        verify_now = lag * (PRICE + g("verify_att") * WAGE)             # a seat and attention for the lag
        verify_lim = lag * (PRICE + g("verify_att_lim") * WAGE)
        build = (work + SETUP_H * WAGE + ACCESS_M * PRICE) / PI
        upkeep = UPKEEP * work * T / 12
        orc0 = build + upkeep + g("attention") * WAGE * T + verify_now
        floor = (COMMISSION_H * WAGE + ACCESS_M * PRICE) / PI + g("attention_lim") * WAGE * T + verify_lim
        h = g("halving")
        tokens = tok_share * (work / PI + upkeep)
        rows.append((orc0, floor, h, tokens / orc0))
    return rows


def pct(xs, q):
    xs = sorted(xs)
    i = q * (len(xs) - 1)
    lo, hi = int(math.floor(i)), int(math.ceil(i))
    if math.isinf(xs[hi]):
        return math.inf
    return xs[lo] + (xs[hi] - xs[lo]) * (i - lo)


def band(xs):
    return {"p10": pct(xs, 0.10), "p50": pct(xs, 0.50), "p90": pct(xs, 0.90)}


def orc_at(row, t):
    orc0, floor, h, _ = row
    return floor + (orc0 - floor) * 2 ** (-t / h)


def assess(cfg, months=(0, 12, 24, 36)):
    rows = simulate(cfg)
    out = {"orc": {}, "pr": {}, "hold": {}}
    for t in months:
        xs = [orc_at(r, t) for r in rows]
        b = band(xs)
        out["orc"][t] = b
        out["pr"][t] = {"central": S / b["p50"], "low": S / b["p90"], "cautious": S / b["p10"]}
        out["hold"][t] = sum(x > S for x in xs) / len(xs)
    fl = band([r[1] for r in rows])
    out["floor"] = fl
    out["pr_terminal"] = {"central": S / fl["p50"], "low": S / fl["p90"], "cautious": S / fl["p10"]}
    out["durable_share"] = sum(r[1] >= S for r in rows) / len(rows)
    # runway: months until ORC(t) falls to the outlay; never, if the floor is at or above it
    run = [r[2] * math.log2((r[0] - r[1]) / (S - r[1])) if r[1] < S < r[0] else (math.inf if r[1] >= S else 0.0) for r in rows]
    fin = [x for x in run if math.isfinite(x)]
    out["runway"] = {"p10": pct(run, 0.10), "p50": pct(run, 0.50), "p90": pct(run, 0.90), "never_share": 1 - len(fin) / len(run)}
    out["spread_today"] = out["orc"][0]["p90"] / out["orc"][0]["p10"]
    out["token_share"] = band([r[3] for r in rows])
    gate = out["hold"][36] >= 0.90
    out["value_score"] = round(100 * (1 - out["pr"][36]["cautious"])) if gate else None
    out["curve"] = [{"t": t, **band([orc_at(r, t) for r in rows])} for t in range(0, 37, 3)]
    return out


GROUPS = {"Unit costs (the Index)": ["unit"], "Size count": ["size_cfp"], "Hidden work": ["hidden"], "Finesse": ["finesse_extra"],
          "Attention to run it": ["attention", "attention_lim"], "Pace of AI progress": ["halving"]}


def variance_shares(cfg, t, n=20_000):
    """First-order shares of the variance of log ORC(t): each input group varied alone, the rest held at their medians."""
    def var(xs):
        m = sum(xs) / len(xs)
        return sum((x - m) ** 2 for x in xs) / len(xs)
    v = {g: var([math.log(orc_at(r, t)) for r in simulate(cfg, n=n, only=set(ks))]) for g, ks in GROUPS.items()}
    tot = sum(v.values())
    return {g: x / tot for g, x in v.items()}


def durable_price(att_lim, lag=0.0, v_att=0.0):
    """Highest monthly price that stays at or below the floor: p*T = (commission*w + access*p)/pi + att*w*T + lag*(p + v*w)."""
    return (COMMISSION_H * WAGE / PI + att_lim * WAGE * T + lag * v_att * WAGE) / (T - ACCESS_M / PI - lag)


out = {"inputs": {"wage": WAGE, "price": PRICE, "T": T, "outlay": S, "seed": SEED, "draws": N}}
out["public"] = assess(PUBLIC)
out["sealed"] = {k: assess(v) for k, v in SEALED.items()}
out["measured_index"] = {"public": assess(dict(PUBLIC, **INDEX)), "B crafted": assess(dict(SEALED["B crafted"], **INDEX)),
                         "C hidden": assess(dict(SEALED["C hidden"], **INDEX))}
out["variance_shares"] = {"today": variance_shares(PUBLIC, 0), "month_36": variance_shares(PUBLIC, 36)}
out["durable_price"] = {"central": durable_price(0.10), "cautious": durable_price(0.05), "generous": durable_price(0.20)}
lag_m, lag_n = verification_lag(3.0)
out["verification_lag_example"] = {"sigma_over_eps": 3.0, "observations": lag_n, "months": lag_m}

# consistency with v0.1: the low and high cases are the P10 and P90 of the unit-cost level
assert abs((2.0 + 0.08 * WAGE) - 7.23) < 0.005 and abs((6.0 + 0.24 * WAGE) - 21.69) < 0.005


def r(x):
    if isinstance(x, float):
        return None if math.isinf(x) else round(x, 3 if abs(x) < 10 else 1)
    if isinstance(x, dict):
        return {str(k): r(v) for k, v in x.items()}
    if isinstance(x, list):
        return [r(v) for v in x]
    return x


if __name__ == "__main__":
    print(json.dumps(r(out), indent=1))