"""Reproducible economic arithmetic. Reads, but never executes, accepted R2/R3.

Run from any directory: python -B <this relative path>/model.py
Only this task's directory is writable. Python standard library only.
"""
from __future__ import annotations

import copy
import csv
import hashlib
import json
import math
import platform
import sys
from datetime import datetime, timezone
from pathlib import Path

HERE = Path(__file__).resolve().parent
ROOT = HERE.parents[3]
OUT = HERE / "results"
OUT.mkdir(exist_ok=True)
INPUT = HERE / "economic-inputs.json"
CFG = json.loads(INPUT.read_text(encoding="utf-8"))


def sha(path):
    return hashlib.sha256(path.read_bytes()).hexdigest()


def dump(path, data):
    path.write_text(json.dumps(data, ensure_ascii=False, indent=2, allow_nan=False) + "\n", encoding="utf-8")


def csvout(name, rows):
    if not rows:
        return
    keys = list(dict.fromkeys(k for row in rows for k in row))
    with (OUT / name).open("w", newline="", encoding="utf-8-sig") as f:
        w = csv.DictWriter(f, fieldnames=keys)
        w.writeheader()
        w.writerows(rows)


SCI_PATHS = {
    "R1": "reports/06_reports/01_survey/PAPER-STRUCTURE-R1-001/main-content.json",
    "R2": "reports/06_reports/02_power_system/PAPER-STRUCTURE-R2-001/main-content.json",
    "R3": "reports/06_reports/03_endurance_simulation/PAPER-STRUCTURE-R3-001/main-content.json",
    "system": "reports/06_reports/02_power_system/PAPER-STRUCTURE-R2-001/final-system-spec.json",
    "components": "reports/06_reports/02_power_system/PAPER-STRUCTURE-R2-001/final-components.csv",
    "CG": "reports/05_simulation/R23-001/equal-storage-supplement/CG_CLIMB_CORRECTED_MAX_WORK-summary.json",
    "B": "reports/05_simulation/R23-001/equal-storage-supplement/B_EQUAL_COMPLETE_WET_MAX_WORK-summary.json",
    "A": "reports/05_simulation/R23-001/equal-storage-supplement/A_EQUAL_COMPLETE_DRY_MAX_WORK-summary.json",
    "range": "reports/05_simulation/R23-001/range-supplement/summary.json",
}
EXPECTED = {
    "R1": "e53ac0afa44db29488800ffa043db1bf40eaf9e0e5c89688c26e2cf696462a65",
    "R2": "321f6f28388844a1e68e67fb632db46e1f2594b271142223cba477e0be54da50",
    "R3": "a99672d363d97654ac429c499311505c55b3f2e8e90b810f331cbb7067d1ebf0",
}
SOURCE_HASHES = {name: sha(ROOT / path) for name, path in SCI_PATHS.items()}
for name, expected in EXPECTED.items():
    if SOURCE_HASHES[name] != expected:
        raise RuntimeError("Frozen scientific input changed: " + name)
SCI = {name: json.loads((ROOT / SCI_PATHS[name]).read_text(encoding="utf-8-sig")) for name in ["CG", "B", "A", "range", "system"]}
RANGE = SCI["range"]["selected"]["mission"]
SCI_USED = {}
for name in ["CG", "B", "A"]:
    d = SCI[name]
    SCI_USED[name] = {k: d[k] for k in ["work_s", "flight_s", "total_profile_s", "H2_FC_used_kg", "H2_vented_kg", "H2_final_kg", "SOC_final", "battery_storage_delta_Wh"]}
SCI_USED["range"] = {k: RANGE[k] for k in ["flight_s", "total_profile_s", "H2_FC_used_kg", "H2_vented_kg", "SOC_final", "H2_final_kg", "input_settings"]}


def annuity_factor(rate, years):
    return years if rate == 0 else (1 - (1 + rate) ** (-years)) / rate


def lifecycle_asset(name, price, quantity, life, rate, horizon):
    """Initial purchase + repeated replacements - linear remaining-service salvage.

    Fleet rotates its spare equipment evenly. Life is deterministic budgeting,
    not an estimated survival distribution. Initial wear parts are not charged twice.
    """
    assert price >= 0 and quantity > 0 and life > 0
    initial = price * quantity
    replacements = []
    t = life
    while t < horizon - 1e-9:
        replacements.append(t)
        t += life
    last_purchase = replacements[-1] if replacements else 0
    residual_fraction = max(0, 1 - (horizon - last_purchase) / life)
    salvage = initial * residual_fraction
    pv = initial + sum(initial / (1 + rate) ** t for t in replacements) - salvage / (1 + rate) ** horizon
    return {"asset": name, "price_cny": price, "quantity": quantity, "life_years": life,
            "initial_cny": initial, "replacement_years": replacements, "residual_cny": salvage,
            "PV_cost_cny": pv, "annual_equivalent_cny": pv / annuity_factor(rate, horizon)}


def mode_settings(cfg, mode):
    g = cfg["global"]
    # Equal local task includes the same 625 s airborne overhead in R3.
    overhead = (SCI["CG"]["flight_s"] - SCI["CG"]["work_s"]) / 3600
    startup = (SCI["CG"]["total_profile_s"] - SCI["CG"]["flight_s"]) / 3600
    max_work = SCI[mode]["work_s"] / 3600 if mode in ["CG", "B"] else g["LI_flight_h"] - overhead
    return overhead, startup, max_work, g[mode + "_change_h"]


def observation_schedule(cfg, mode, continuous=False):
    g, o = cfg["global"], cfg["observation"]
    overhead, startup, maximum, turn = mode_settings(cfg, mode)
    work = o["public_continuous_productive_h"] if continuous else o["required_productive_h"]
    if continuous:
        flights = math.ceil(work / maximum - 1e-12)
        active = 1 if flights == 1 else 2
        flight_h = work + flights * overhead
        FC_h = flight_h + flights * startup
        # Two craft hand over; service production is counted once, not twice.
        # Staff remain on duty for full coverage plus shared mobilization/phase time.
        wall_h = work + overhead + startup + g["mobilization_h"]
    else:
        active = 1
        while True:
            per_craft_work = work / active
            flights_each = math.ceil(per_craft_work / maximum - 1e-12)
            wall_h = per_craft_work + flights_each * (overhead + startup) + (flights_each - 1) * turn + g["mobilization_h"]
            if wall_h <= g["shift_h"] + 1e-9:
                break
            active += 1
            if active > 20:
                raise RuntimeError("Impossible schedule")
        flights = active * flights_each
        flight_h = work + flights * overhead
        FC_h = flight_h + flights * startup
    staffing_active = active * g["public_parallel_crew_factor"] if continuous and active > 1 else active
    staff_person_h = staffing_active * g["crew_size"] * wall_h
    return {"active_aircraft": active, "sorties": flights, "flight_h": flight_h, "FC_h": FC_h,
            "wall_h": wall_h, "staff_person_h": staff_person_h, "work_h": work,
            "continuous_handover_required": continuous and flights > 1}


def single_shift_capacity(cfg, mode):
    overhead, startup, max_work, turn = mode_settings(cfg, mode)
    time_left = cfg["global"]["shift_h"] - cfg["global"]["mobilization_h"]
    work, flights = 0.0, 0
    while time_left > overhead + startup + (turn if flights else 0) + 1e-9:
        if flights:
            time_left -= turn
        step = min(max_work, time_left - overhead - startup)
        work += step
        time_left -= step + overhead + startup
        flights += 1
    q = cfg["global"]["quality_fraction"] * cfg["global"]["mission_success_fraction"]
    return {"mode": mode, "single_aircraft_productive_h": work, "sorties": flights,
            "qualified_km": work * cfg["observation"]["qualified_corridor_km_productive_h"] * q}


def asset_bundle(cfg, mode, active, annual_flight_h, annual_FC_h, annual_starts, annual_LI_cycles):
    g, a = cfg["global"], cfg["assets"]
    rate, horizon = g["discount_rate"], g["horizon_years"]
    fleet = active * (1 + g["spare_aircraft_ratio"])
    assets = []

    def add(key, quantity=1, price=None, life=None):
        spec = a.get(key, {})
        assets.append(lifecycle_asset(key, spec["price_cny"] if price is None else price, quantity,
                                      spec["calendar_years"] if life is None else life, rate, horizon))

    if mode in ["CG", "B"]:
        for key in ["H_body", "H_payload", "H_gas_safety"]:
            add(key, fleet)
        fc_life = min(g["FC_calendar_years"], g["FC_life_h"] * fleet / annual_FC_h,
                      g["FC_life_starts"] * fleet / annual_starts)
        add("FC", fleet, life=fc_life)
        d = SCI[mode]
        kwh_h = -d["battery_storage_delta_Wh"] / (d["total_profile_s"] / 3600) / 1000
        efc_year = kwh_h * annual_FC_h / g["buffer_capacity_kwh"]
        buf_life = min(g["buffer_calendar_years"], g["buffer_life_EFC"] * fleet / max(efc_year, 1e-12))
        add("buffer", fleet, life=buf_life)
        vessels = fleet + a["CG_spare_vessels_per_active_aircraft"] * active
        v_price = a["CG_vessel"]["price_cny"] + (a["B_vessel_premium_cny"] if mode == "B" else 0)
        v_life = a["B_vessel_calendar_years"] if mode == "B" else a["CG_vessel"]["calendar_years"]
        add(mode + "_vessels", vessels, price=v_price, life=v_life)
        add(mode + "_ground")
    elif mode == "LI":
        add("LI_body", fleet)
        add("LI_payload", fleet)
        pairs = fleet * g["LI_pairs_per_aircraft"]
        # Keep manufacturer's "cycles" distinct from equivalent full cycles.
        # Budget one charge cycle per sortie, not 400 EFC inferred from the FAQ.
        pack_life = min(g["LI_pair_calendar_years"], g["LI_pair_cycles"] * pairs / annual_LI_cycles)
        add("LI_pair", pairs, life=pack_life)
        add("LI_charger", active)
    elif mode == "VTOL":
        add("VTOL_aircraft", fleet)
        pairs = fleet * g["LI_pairs_per_aircraft"]
        life = min(a["VTOL_pair"]["calendar_years"], a["VTOL_pair"]["cycles"] * pairs / annual_LI_cycles)
        add("VTOL_pair", pairs, life=life)
        add("VTOL_charger", active)
    else:
        add("road_vehicle")
    return assets


def service_case(cfg, service, mode, overrides=None):
    g, o, d = cfg["global"], cfg["observation"], cfg["delivery"]
    q_success = g["mission_success_fraction"]
    if service in ["observation", "public"]:
        schedule = observation_schedule(cfg, mode, service == "public")
        n = o["effective_days_year"] if service == "observation" else o["public_response_count_year"]
        units_per_attempt = (o["required_productive_h"] * o["qualified_corridor_km_productive_h"] * g["quality_fraction"] * q_success
                             if service == "observation" else q_success)
        fee = o["fee_cny_qualified_km"] if service == "observation" else o["public_fee_cny_response"]
    else:
        n = d["orders_year"]
        units_per_attempt, fee = q_success, d["fee_cny_successful_order"]
        km = 2 * d["air_one_way_km"]
        if mode == "CG":
            speed = SCI["range"]["selected"]["search"]["speed_m_s"] * 3.6
            fixed_h = (RANGE["flight_s"] - 2 * SCI["range"]["selected"]["search"]["leg_s"]) / 3600
            flight = km / speed + fixed_h
            startup = (RANGE["total_profile_s"] - RANGE["flight_s"]) / 3600
            wall = flight + startup + d["handling_h"] + d["dispatch_h"] + g["CG_change_h"]
            arrival = d["dispatch_h"] + d["handling_h"] + startup + d["air_one_way_km"] / speed + fixed_h / 2
        elif mode == "VTOL":
            flight = km / d["VTOL_speed_kmh"] + d["VTOL_fixed_flight_h"]
            startup = 0
            wall = flight + d["handling_h"] + d["dispatch_h"] + g["LI_change_h"]
            arrival = d["dispatch_h"] + d["handling_h"] + d["air_one_way_km"] / d["VTOL_speed_kmh"] + d["VTOL_fixed_flight_h"] / 2
        else:
            flight, startup = 0, 0
            road_km = km * d["road_detour_ratio"]
            wall = road_km / d["road_speed_kmh"] + d["handling_h"] + d["dispatch_h"]
            arrival = d["dispatch_h"] + d["handling_h"] + road_km / 2 / d["road_speed_kmh"]
        schedule = {"active_aircraft": 1, "sorties": 1, "flight_h": flight, "FC_h": flight + startup,
                    "wall_h": wall, "staff_person_h": wall * (1 if mode == "ROAD" else g["crew_size"]),
                    "work_h": 0, "arrival_h": arrival}
    if overrides:
        schedule.update(overrides)
    active = schedule["active_aircraft"]
    annual_flight = n * schedule["flight_h"]
    annual_FC = n * schedule["FC_h"]
    annual_starts = n * schedule["sorties"]
    if service == "public":
        annual_flight += o["public_training_flight_h_year"]
        annual_FC += o["public_training_flight_h_year"]
        annual_starts += o["public_training_flight_h_year"] / o["public_training_sortie_h"]
    assets = asset_bundle(cfg, mode, active, annual_flight, annual_FC, annual_starts, annual_starts)
    asset_EAC = sum(x["annual_equivalent_cny"] for x in assets)
    staff_cost = n * schedule["staff_person_h"] * (d["road_driver_cny_h"] if mode == "ROAD" else g["staff_cny_person_h"])
    staffing_active = active * g["public_parallel_crew_factor"] if service == "public" and active > 1 else active
    readiness = o["public_readiness_crew_h_year"] * staffing_active * g["crew_size"] * g["staff_cny_person_h"] if service == "public" else 0
    hydrogen, grid_kwh, road_km_year = 0.0, 0.0, 0.0
    if mode in ["CG", "B"]:
        fuel_source = RANGE if service == "delivery" else SCI[mode]
        fuel_rate = fuel_source["H2_FC_used_kg"] / (fuel_source["total_profile_s"] / 3600)
        startup_vent = fuel_source["H2_vented_kg"]
        hydrogen = (annual_FC * fuel_rate + annual_starts * startup_vent) / (1 - g["hydrogen_delivery_loss_fraction"])
        if mode == "B":
            hydrogen += g["B_storage_loss_kg_station_day"] * (365 if service == "public" else n)
        fuel_cny = hydrogen * g[mode + "_hydrogen_cny_kg"]
        grid_kwh = annual_FC * (-fuel_source["battery_storage_delta_Wh"]) / (fuel_source["total_profile_s"] / 3600) / 1000 / g["charging_efficiency"]
        maintenance = annual_flight * g[mode + "_maintenance_cny_flight_h"]
        insurance = g[mode + "_insurance_cny_year"] * active
    elif mode == "LI":
        grid_kwh = annual_flight / g["LI_flight_h"] * g["LI_pair_energy_kwh"] * g["LI_used_energy_fraction"] / g["charging_efficiency"]
        fuel_cny = 0
        maintenance = annual_flight * g["LI_maintenance_cny_flight_h"]
        insurance = g["LI_insurance_cny_year"] * active
    elif mode == "VTOL":
        grid_kwh = n * d["VTOL_grid_kwh_trip"]
        fuel_cny = 0
        maintenance = annual_flight * d["VTOL_maintenance_cny_h"]
        insurance = d["VTOL_insurance_cny_year"]
    else:
        road_km_year = n * 2 * d["air_one_way_km"] * d["road_detour_ratio"]
        fuel_cny = road_km_year * d["road_fuel_cny_km"]
        maintenance = road_km_year * d["road_maintenance_cny_km"]
        insurance = d["road_insurance_cny_year"]
    electricity = grid_kwh * g["grid_cny_kwh"]
    cost_parts = {"asset_annual_equivalent": asset_EAC, "staff": staff_cost, "readiness_staff": readiness,
                  "fuel": fuel_cny, "grid_electricity": electricity, "maintenance": maintenance,
                  "insurance": insurance, "admin_comms": g["admin_comms_cny_year"]}
    cash_opex = sum(cost_parts.values()) - asset_EAC
    annual_cost = sum(cost_parts.values())
    quantity = n * units_per_attempt
    revenue = quantity * fee
    if service == "public":
        revenue += o["public_retainer_cny_year"]
    elif service == "observation" and mode == "B":
        revenue += n * q_success * o["B_continuity_premium_cny_day"]
    e = cfg["environment"]
    energy_co2 = (hydrogen * e[mode + "_upstream_hydrogen_kg_co2_kg"] + grid_kwh * e["grid_kg_co2_kwh"] if mode in ["CG", "B"]
                  else road_km_year * e["road_kg_co2_km"] + grid_kwh * e["grid_kg_co2_kwh"])
    renewable_co2 = hydrogen * e["renewable_hydrogen_kg_co2_kg"] + grid_kwh * e["grid_kg_co2_kwh"] if mode in ["CG", "B"] else energy_co2
    ground_conditioning_kwh = hydrogen * e["B_conditioning_kwh_kg"] if mode == "B" else 0
    if mode == "B":
        # Conditioning power is at the supplier and already in the delivered-H2
        # price; add its carbon once, never as a second electricity purchase.
        energy_co2 += ground_conditioning_kwh * e["grid_kg_co2_kwh"]
        renewable_co2 += ground_conditioning_kwh * e["renewable_conditioning_grid_kg_co2_kwh"]
    result = {"service": service, "mode": mode, "schedule": schedule, "annual_attempts": n,
              "successful_units_year": quantity, "unit": "qualified_km" if service == "observation" else "successful_response" if service == "public" else "successful_1kg_order",
              "annual_flight_h": annual_flight, "annual_FC_h": annual_FC, "annual_starts": annual_starts,
              "annual_H2_kg": hydrogen, "annual_grid_kwh": grid_kwh, "annual_road_km": road_km_year,
              "annual_external_ground_conditioning_kwh": ground_conditioning_kwh,
              "cost_parts_cny_year": cost_parts, "assets": assets, "initial_capital_cny": sum(x["initial_cny"] for x in assets),
              "annual_cost_cny": annual_cost, "annual_cash_opex_cny": cash_opex, "annual_revenue_cny": revenue,
              "annual_economic_profit_cny": revenue - annual_cost, "cost_cny_successful_unit": annual_cost / quantity,
              "cost_cny_attempt": annual_cost / n, "energy_chain_co2_kg_year": energy_co2,
              "renewable_supply_scenario_co2_kg_year": renewable_co2,
              "five_year_PV_cost_cny": annual_cost * annuity_factor(g["discount_rate"], g["horizon_years"]),
              "five_year_NPV_cny": (revenue - annual_cost) * annuity_factor(g["discount_rate"], g["horizon_years"])}
    return result


def all_cases(cfg):
    cases = {}
    for service, modes in [("observation", ["CG", "B", "LI"]), ("delivery", ["CG", "ROAD", "VTOL"]), ("public", ["CG", "B", "LI"])]:
        for mode in modes:
            cases[service + ":" + mode] = service_case(cfg, service, mode)
    return cases


def scenario_cfg(scenario):
    cfg = copy.deepcopy(CFG)
    g, o, d = cfg["global"], cfg["observation"], cfg["delivery"]
    for key in ["CG_hydrogen_cny_kg", "B_hydrogen_cny_kg", "FC_life_h"]:
        g[key] = scenario[key]
    o["effective_days_year"] *= scenario["utilization_multiplier"]
    o["public_response_count_year"] *= scenario["utilization_multiplier"]
    d["orders_year"] *= scenario["utilization_multiplier"]
    for target, key in [(o, "fee_cny_qualified_km"), (o, "public_retainer_cny_year"), (o, "public_fee_cny_response"), (d, "fee_cny_successful_order")]:
        target[key] *= scenario["service_fee_multiplier"]
    o["B_continuity_premium_cny_day"] = scenario["B_continuity_premium_cny_day"]
    for spec in cfg["assets"].values():
        if isinstance(spec, dict) and "price_cny" in spec:
            spec["price_cny"] *= scenario["equipment_price_multiplier"]
    cfg["assets"]["B_vessel_premium_cny"] *= scenario["equipment_price_multiplier"]
    return cfg


def forecasts():
    market = CFG["market"]
    r = CFG["global"]["discount_rate"]
    annual_rows, summaries, supplier_rows = [], [], []
    for scenario in market["scenarios"]:
        cfg = scenario_cfg(scenario)
        cases = all_cases(cfg)
        alt = {"observation": cases["observation:LI"], "delivery": min([cases["delivery:ROAD"], cases["delivery:VTOL"]], key=lambda x: x["annual_cost_cny"]), "public": cases["public:LI"]}
        cohorts = []
        prev = 0
        supplier_npv = -market["B_RnD_initial_cny"]
        for j, year in enumerate(market["years"]):
            sites = scenario["sites_eoy"][j]
            new = sites - prev
            b_new = new * scenario["B_share_new_sites"][j]
            b_pub = min(new * market["public_site_fraction"], b_new)
            b_obs = b_new - b_pub
            counts = {"observation:B": b_obs, "public:B": b_pub,
                      "observation:CG": new * market["observation_site_fraction"] - b_obs,
                      "public:CG": new * market["public_site_fraction"] - b_pub,
                      "delivery:CG": new * market["delivery_site_fraction"]}
            assert all(v >= -1e-9 for v in counts.values())
            for key, count in counts.items():
                if count > 0:
                    cohorts.append({"start": j + 0.5, "key": key, "count": count})
            row = {"scenario": scenario["id"], "year": year, "sites_start": prev, "sites_eoy": sites,
                   "new_sites": new, "new_B_sites": b_new, "candidate_market_sites": market["candidate_sites"],
                   "adoption_fraction_eoy": sites / market["candidate_sites"]}
            totals = {k: 0.0 for k in ["active_site_years", "B_active_site_years", "service_revenue_cny", "annual_equivalent_cost_cny", "cash_opex_cny", "initial_equipment_sales_cny", "replacement_cash_cny", "salvage_cny", "net_resource_gain_vs_alternative_cny", "B_indirect_resource_increment_cny", "B_operator_increment_cny", "observation_qualified_km", "delivered_orders", "public_responses", "H2_kg", "B_direct_vessel_premium_sales_cny"]}
            cash_events = []
            for cohort in cohorts:
                start, key, count = cohort["start"], cohort["key"], cohort["count"]
                fraction = max(0, min(j + 1, 5) - max(j, start))
                if fraction <= 0:
                    continue
                case = cases[key]
                service, mode = key.split(":")
                sy = count * fraction
                totals["active_site_years"] += sy
                totals["B_active_site_years"] += sy if mode == "B" else 0
                for field, source in [("service_revenue_cny", "annual_revenue_cny"), ("annual_equivalent_cost_cny", "annual_cost_cny"), ("cash_opex_cny", "annual_cash_opex_cny"), ("H2_kg", "annual_H2_kg")]:
                    totals[field] += sy * case[source]
                totals["net_resource_gain_vs_alternative_cny"] += sy * (alt[service]["annual_cost_cny"] - case["annual_cost_cny"])
                if mode == "B":
                    cg = cases[service + ":CG"]
                    totals["B_indirect_resource_increment_cny"] += sy * (cg["annual_cost_cny"] - case["annual_cost_cny"])
                    totals["B_operator_increment_cny"] += sy * (case["annual_economic_profit_cny"] - cg["annual_economic_profit_cny"])
                qty_key = {"observation": "observation_qualified_km", "delivery": "delivered_orders", "public": "public_responses"}[service]
                totals[qty_key] += sy * case["successful_units_year"]
                for asset in case["assets"]:
                    if j <= start < j + 1:
                        amount = count * asset["initial_cny"]
                        totals["initial_equipment_sales_cny"] += amount
                        cash_events.append((start, -amount))
                        if mode == "B" and asset["asset"] == "B_vessels":
                            totals["B_direct_vessel_premium_sales_cny"] += count * asset["quantity"] * cfg["assets"]["B_vessel_premium_cny"]
                    t = start + asset["life_years"]
                    last = start
                    while t < 5 - 1e-9:
                        if j <= t < j + 1:
                            amount = count * asset["initial_cny"]
                            totals["replacement_cash_cny"] += amount
                            cash_events.append((t, -amount))
                        last = t
                        t += asset["life_years"]
                    if j == 4:
                        salvage = count * asset["initial_cny"] * max(0, 1 - (5 - last) / asset["life_years"])
                        totals["salvage_cny"] += salvage
                        cash_events.append((5, salvage))
            row.update(totals)
            row["operator_economic_profit_cny"] = totals["service_revenue_cny"] - totals["annual_equivalent_cost_cny"]
            row["operator_cash_before_salvage_cny"] = totals["service_revenue_cny"] - totals["cash_opex_cny"] - totals["initial_equipment_sales_cny"] - totals["replacement_cash_cny"]
            row["operator_cash_with_salvage_cny"] = row["operator_cash_before_salvage_cny"] + totals["salvage_cny"]
            row["discounted_operator_cash_cny"] = ((totals["service_revenue_cny"] - totals["cash_opex_cny"]) / (1 + r) ** (j + 0.5)
                                                   + sum(amount / (1 + r) ** t for t, amount in cash_events))
            margin = totals["B_direct_vessel_premium_sales_cny"] * market["supplier_incremental_margin_fraction"]
            supplier_net = margin - market["B_RnD_annual_support_cny"]
            supplier_npv += supplier_net / (1 + r) ** (j + 0.5)
            supplier_rows.append({"scenario": scenario["id"], "year": year, "incremental_vessel_sales_cny": totals["B_direct_vessel_premium_sales_cny"], "supplier_incremental_margin_cny": margin,
                                  "RnD_support_cny": market["B_RnD_annual_support_cny"], "RnD_initial_cny": market["B_RnD_initial_cny"] if j == 0 else 0,
                                  "supplier_incremental_cash_cny": supplier_net - (market["B_RnD_initial_cny"] if j == 0 else 0)})
            annual_rows.append(row)
            prev = sites
        own = [x for x in annual_rows if x["scenario"] == scenario["id"]]
        summary = {"scenario": scenario["id"], "sites_2031": prev}
        sum_fields = ["service_revenue_cny", "initial_equipment_sales_cny", "operator_economic_profit_cny", "net_resource_gain_vs_alternative_cny", "B_direct_vessel_premium_sales_cny", "B_indirect_resource_increment_cny", "B_operator_increment_cny", "observation_qualified_km", "delivered_orders", "public_responses", "H2_kg", "active_site_years", "B_active_site_years", "operator_cash_before_salvage_cny", "operator_cash_with_salvage_cny", "discounted_operator_cash_cny"]
        summary.update({key: sum(x[key] for x in own) for key in sum_fields})
        summary["B_supplier_incremental_NPV_cny"] = supplier_npv
        summaries.append(summary)
    return annual_rows, summaries, supplier_rows


def flatten(data, prefix=""):
    if isinstance(data, dict):
        for k, value in data.items():
            if k != "source_overrides":
                yield from flatten(value, prefix + ("." if prefix else "") + k)
    elif isinstance(data, list):
        for i, value in enumerate(data):
            yield from flatten(value, prefix + "." + str(i))
    elif isinstance(data, (float, int, bool)):
        yield prefix, data


def units_for(path):
    unit_names = [("cny_person_h", "CNY/person/h"), ("cny_flight_h", "CNY/flight_h"), ("cny_successful_order", "CNY/successful_order"),
                  ("cny_qualified_km", "CNY/qualified_km"), ("cny_crew_h", "CNY/crew/h"), ("cny_kwh", "CNY/kWh"),
                  ("cny_kg", "CNY/kg"), ("cny_km", "CNY/km"), ("cny_h", "CNY/h"), ("cny_year", "CNY/year"),
                  ("kg_station_day", "kg/station/day"), ("kg_co2_kwh", "kgCO2/kWh"), ("kg_co2_kg", "kgCO2e/kg_H2"), ("kg_co2_km", "kgCO2/km"),
                  ("km_productive_h", "km/productive_h"), ("cny", "CNY"), ("kmh", "km/h"), ("kwh", "kWh"), ("_kg", "kg"),
                  ("_km", "km"), ("_years", "year"), ("_h_year", "h/year"), ("_h", "h"), ("_days_year", "day/year"),
                  ("_cycles", "manufacturer_charge_cycle"), ("EFC", "equivalent_full_cycle"), ("_fraction", "fraction"), ("_ratio", "ratio"), ("_multiplier", "ratio")]
    for token, unit in unit_names:
        if token in path:
            return unit
    if "years." in path:
        return "calendar_year"
    if "sites" in path:
        return "site_equivalent"
    return "dimensionless_or_count;see_definition"


def sensitivity():
    choices = {
        "FC_life_h": [500, 1000, 2000],
        "LI_pair_calendar_years": [1, 2, 3],
        "LI_pair_cycles": [200, 400, 800],
        "CG_hydrogen_cny_kg": [25, 50, 100],
        "B_hydrogen_cny_kg": [50, 80, 130],
        "B_storage_loss_kg_station_day": [0, 0.03, 0.1],
        "mission_success_fraction": [0.8, 0.95, 0.99],
        "LI_flight_h": [0.55, 0.75, 0.9],
        "CG_change_h": [0.05, 0.1, 0.25],
        "staff_cny_person_h": [30, 45, 70],
        "public_parallel_crew_factor": [0.5, 1],
    }
    rows = []
    for key, values in choices.items():
        for val in values:
            cfg = copy.deepcopy(CFG)
            cfg["global"][key] = val
            cases = all_cases(cfg)
            rows.append({"parameter": "global." + key, "value": val,
                         "CG_observation_cny_km": cases["observation:CG"]["cost_cny_successful_unit"],
                         "LI_observation_cny_km": cases["observation:LI"]["cost_cny_successful_unit"],
                         "B_observation_cny_km": cases["observation:B"]["cost_cny_successful_unit"],
                         "CG_delivery_cny_order": cases["delivery:CG"]["cost_cny_successful_unit"],
                         "B_minus_CG_public_annual_cost_cny": cases["public:B"]["annual_cost_cny"] - cases["public:CG"]["annual_cost_cny"]})
    for premium in [0, 15000, 40000]:
        cfg = copy.deepcopy(CFG)
        cfg["assets"]["B_vessel_premium_cny"] = premium
        cases = all_cases(cfg)
        rows.append({"parameter": "assets.B_vessel_premium_cny", "value": premium,
                     "B_observation_cny_km": cases["observation:B"]["cost_cny_successful_unit"],
                     "B_minus_CG_public_annual_cost_cny": cases["public:B"]["annual_cost_cny"] - cases["public:CG"]["annual_cost_cny"]})
    for hours in [2, 4, 6]:
        cfg = copy.deepcopy(CFG)
        cfg["observation"]["required_productive_h"] = hours
        cases = all_cases(cfg)
        rows.append({"parameter": "observation.required_productive_h", "value": hours,
                     "CG_observation_cny_km": cases["observation:CG"]["cost_cny_successful_unit"],
                     "LI_observation_cny_km": cases["observation:LI"]["cost_cny_successful_unit"],
                     "CG_active_aircraft": cases["observation:CG"]["schedule"]["active_aircraft"],
                     "LI_active_aircraft": cases["observation:LI"]["schedule"]["active_aircraft"]})
    for batch in [1, 4, 8]:
        # Identical trip cost shared by simultaneous compatible parcels; capacity
        # is not claimed for the present 1kg H platform. ROAD only.
        cases = all_cases(CFG)
        batched_cfg = copy.deepcopy(CFG)
        batched_cfg["delivery"]["orders_year"] /= batch
        batched_road = service_case(batched_cfg, "delivery", "ROAD")
        rows.append({"parameter": "delivery.road_compatible_orders_per_trip", "value": batch,
                     "road_cny_order": batched_road["cost_cny_successful_unit"] / batch,
                     "CG_delivery_cny_order": cases["delivery:CG"]["cost_cny_successful_unit"]})
    return rows


def run():
    cases = all_cases(CFG)
    annual, summary, supplier = forecasts()
    capacity = [single_shift_capacity(CFG, mode) for mode in ["CG", "B", "LI"]]
    units, components = [], []
    for key, case in cases.items():
        row = {k: v for k, v in case.items() if not isinstance(v, (dict, list))}
        row.update({"schedule_" + k: v for k, v in case["schedule"].items()})
        units.append(row)
        for asset in case["assets"]:
            components.append({"case": key, **{k: (json.dumps(v) if isinstance(v, list) else v) for k, v in asset.items()}})
    registry = []
    for path, value in flatten(CFG):
        override = CFG["source_overrides"].get(path, {})
        registry.append({"parameter_id": "R4P-" + str(len(registry) + 1).zfill(3), "path": path, "value": value,
                         "unit": units_for(path), "identity": override.get("identity", "economic_assumption"),
                         "source": override.get("source", "BUSINESS-R4-001 author scenario;not a quotation or observed market count"),
                         "scope": "same-service economic model;not a new flight calculation"})
    csvout("unit-task-costs.csv", units)
    csvout("lifecycle-assets.csv", components)
    csvout("five-year-annual.csv", annual)
    csvout("five-year-summary.csv", summary)
    csvout("advanced-supplier.csv", supplier)
    csvout("single-shift-capacity.csv", capacity)
    csvout("sensitivity.csv", sensitivity())
    csvout("parameters.csv", registry)
    ledger = [
        {"account": "equipment_sales", "beneficiary": "equipment_suppliers", "measure": "initial equipment gross sales", "do_not_add_to": "service_sales;operator_profit;resource_gain", "reason": "equipment procurement is already an operator capital cost"},
        {"account": "service_sales", "beneficiary": "operators", "measure": "fees for accepted service plus readiness retainer", "do_not_add_to": "operator_profit;customer_payment_savings", "reason": "fee is a transfer;profit already nets costs"},
        {"account": "operator_profit", "beneficiary": "operators", "measure": "service revenue minus annual equivalent complete cost", "do_not_add_to": "net_resource_gain", "reason": "different accounting lenses"},
        {"account": "net_resource_gain", "beneficiary": "whole service system", "measure": "same-service alternative resource cost minus H resource cost", "do_not_add_to": "equipment_sales;service_sales;wages;B_increment", "reason": "wages and B effect already included where applicable"},
        {"account": "B_direct", "beneficiary": "vessel_supplier", "measure": "premium-only gross sales relative to CG vessel", "do_not_add_to": "equipment_sales;B_indirect;operator_profit", "reason": "subset of equipment invoices and a cost to adopter"},
        {"account": "B_indirect", "beneficiary": "service_system", "measure": "CG cost minus B cost for same accepted service", "do_not_add_to": "net_resource_gain;B_direct", "reason": "already embedded in H-versus-alternative comparison"},
        {"account": "risk_reduction", "beneficiary": "public_and_asset_owners", "measure": "event exposure times avoidable loss times incremental risk reduction", "do_not_add_to": "service_sales;loss_savings_already_in_resource_cost", "reason": "report separately until event and causal evidence exist"},
        {"account": "employment", "beneficiary": "flight_and_support_staff", "measure": "paid person-hours and wages", "do_not_add_to": "operator_profit;resource_gain", "reason": "wages are included in cost;not additional national value added"},
    ]
    csvout("value-ledger.csv", ledger)
    increments = []
    for service in ["observation", "public"]:
        cg, b = cases[service + ":CG"], cases[service + ":B"]
        increments.append({"service": service, "annual_resource_saving_cny": cg["annual_cost_cny"] - b["annual_cost_cny"],
                           "annual_operator_profit_increment_cny": b["annual_economic_profit_cny"] - cg["annual_economic_profit_cny"],
                           "initial_capital_increment_cny": b["initial_capital_cny"] - cg["initial_capital_cny"],
                           "annual_B_gross_service_increment_cny": b["annual_revenue_cny"] - cg["annual_revenue_cny"],
                           "break_even_extra_fee_cny_attempt": max(0, b["annual_cost_cny"] - cg["annual_cost_cny"]) / (b["annual_attempts"] * CFG["global"]["mission_success_fraction"]),
                           "scope": "same productive task;B continuous-observation capability,not range multiplier"})
    csvout("advanced-storage-increments.csv", increments)
    o = CFG["observation"]
    public_increment = cases["public:CG"]["annual_cost_cny"] - o["public_existing_ground_budget_cny_year"]
    risk = {"assumed_exposure_events_year": o["public_exposure_events_year"], "assumed_loss_cny_event": o["public_loss_cny_event"],
            "assumed_incremental_loss_reduction_fraction": o["public_incremental_loss_reduction_fraction"],
            "illustrative_avoided_loss_cny_year": o["public_exposure_events_year"] * o["public_loss_cny_event"] * o["public_incremental_loss_reduction_fraction"],
            "existing_ground_budget_cny_year": o["public_existing_ground_budget_cny_year"],
            "CG_extra_early_warning_service_cost_cny_year": public_increment,
            "required_incremental_loss_reduction_fraction": max(0, public_increment) / (o["public_exposure_events_year"] * o["public_loss_cny_event"]),
            "B_required_incremental_loss_reduction_fraction": max(0, cases["public:B"]["annual_cost_cny"] - o["public_existing_ground_budget_cny_year"]) / (o["public_exposure_events_year"] * o["public_loss_cny_event"]),
            "identity": "assumed decision threshold;not a measured event rate or proven medical benefit;not in revenue or forecast totals"}
    dump(OUT / "risk-threshold.json", risk)
    dump(OUT / "results.json", {"model_version": CFG["model_version"], "cases": cases, "capacity": capacity, "five_year_summary": summary, "advanced_increments": increments, "risk_threshold": risk})
    inherited = {"source_paths": SCI_PATHS, "source_hashes": SOURCE_HASHES, "expected_main_hashes_match": True, "adopted_values": SCI_USED,
                 "boundary": "B9.22h is5m/s repeated work;CG218.40km is20m/s closed return;no B range extrapolation;no physics rerun"}
    dump(HERE / "inherited-inputs.json", inherited)
    checks = []
    for key, case in cases.items():
        checks.append({"check": key + ":cost_sum", "pass": math.isclose(case["annual_cost_cny"], sum(case["cost_parts_cny_year"].values()), abs_tol=1e-7)})
        checks.append({"check": key + ":unit_denominator", "pass": math.isclose(case["cost_cny_successful_unit"] * case["successful_units_year"], case["annual_cost_cny"], abs_tol=1e-7)})
        checks.append({"check": key + ":capital_once", "pass": math.isclose(case["initial_capital_cny"], sum(x["initial_cny"] for x in case["assets"]), abs_tol=1e-7)})
    for scenario in summary:
        own = [x for x in annual if x["scenario"] == scenario["scenario"]]
        checks.append({"check": scenario["scenario"] + ":five_year_sum", "pass": math.isclose(sum(x["service_revenue_cny"] for x in own), scenario["service_revenue_cny"], abs_tol=1e-7)})
        checks.append({"check": scenario["scenario"] + ":site_years", "pass": math.isclose(sum((x["sites_start"] + x["sites_eoy"]) / 2 for x in own), scenario["active_site_years"], abs_tol=1e-7)})
    # Monetary values must change with quotes/life; longer endurance cannot
    # automatically multiply fuel efficiency, price or the adopted flight range.
    checks.append({"check": "accepted_scientific_sources_unchanged", "pass": all(sha(ROOT / SCI_PATHS[k]) == h for k, h in SOURCE_HASHES.items())})
    checks.append({"check": "single_shift_B_gain_below_endurance_ratio", "pass": capacity[1]["qualified_km"] / capacity[0]["qualified_km"] < SCI["B"]["flight_s"] / SCI["CG"]["flight_s"]})
    checks.append({"check": "all_schedules_fit_eight_hour_window", "pass": all(cases[k]["schedule"]["wall_h"] <= CFG["global"]["shift_h"] + 1e-9 for k in ["observation:CG", "observation:B", "observation:LI"])})
    assert all(x["pass"] for x in checks), "Economic accounting check failed"
    dump(OUT / "checks.json", {"status": "passed", "checks": checks, "count": len(checks), "not_physical_or_market_validation": True})
    files = sorted(p for p in OUT.iterdir() if p.is_file())
    receipt = {"task_id": "BUSINESS-R4-001", "model_version": CFG["model_version"], "executed_utc": datetime.now(timezone.utc).isoformat(),
               "command_entry": "python -B reports/06_reports/04_business_plan/BUSINESS-R4-001/model.py", "python_version": platform.python_version(),
               "runtime": platform.system() + " " + platform.release(), "dependencies": "Python standard library only", "random_seed": None,
               "random_seed_reason": "deterministic accounting,no random sampling", "native_exit_expected": 0,
               "input_hashes": {"economic-inputs.json": sha(INPUT), "model.py": sha(Path(__file__)), **{SCI_PATHS[k]: v for k, v in SOURCE_HASHES.items()}},
               "output_hashes": {p.relative_to(HERE).as_posix(): sha(p) for p in files}, "checks_passed": len(checks),
               "physical_model_executed": False, "new_flight_claims": False, "market_observations_created": False,
               "scope": "economic hypotheses and lifecycle/forecast arithmetic;not supplier quotes,flight validation or industry forecast"}
    dump(HERE / "run-receipt.json", receipt)
    print(json.dumps({"status": "completed", "checks": len(checks), "cases": len(cases), "scenario_years": len(annual), "parameters": len(registry), "summary": summary}, ensure_ascii=True))


if __name__ == "__main__":
    run()
