#!/usr/bin/env -S uv run python
"""Reperform Linden Peak's revenue allocation and three-period rollforward.

Run directly with uv; this script uses only the Python standard library:

    uv run python linden-peak-device-support-allocation.py
    uv run python linden-peak-device-support-allocation.py --support-ssp 40000
"""

from __future__ import annotations

import argparse


def money(amount: float) -> str:
    """Format dollars with commas and accounting-style negatives."""
    rounded = round(amount)
    if rounded < 0:
        return f"(${abs(rounded):,.0f})"
    if rounded == 0:
        return "—"
    return f"${rounded:,.0f}"


def build_schedule(support_ssp: float) -> dict[str, object]:
    fixed_consideration = 120_000.0
    estimated_bonus = 12_000.0
    included_bonus = 6_000.0  # stipulated constraint result; not inferred here
    transaction_price = fixed_consideration + included_bonus

    obligations = {
        "Monitoring device": 100_000.0,
        "Installation": 20_000.0,
        "Support service": support_ssp,
    }
    total_ssp = sum(obligations.values())
    allocations = {
        name: transaction_price * standalone_price / total_ssp
        for name, standalone_price in obligations.items()
    }
    recognition = {
        "Monitoring device": [allocations["Monitoring device"], 0.0, 0.0],
        "Installation": [allocations["Installation"], 0.0, 0.0],
        "Support service": [allocations["Support service"] / 3] * 3,
    }
    revenue = [sum(rows[period] for rows in recognition.values()) for period in range(3)]
    billings = [100_000.0, 13_000.0, 13_000.0]
    collections = [90_000.0, 20_000.0, 16_000.0]

    receivable = 0.0
    net_contract_position = 0.0
    balances: list[dict[str, float]] = []
    for period in range(3):
        receivable += billings[period] - collections[period]
        net_contract_position += revenue[period] - billings[period]
        balances.append(
            {
                "receivable": receivable,
                "contract_asset": max(net_contract_position, 0.0),
                "contract_liability": max(-net_contract_position, 0.0),
            }
        )

    return {
        "fixed": fixed_consideration,
        "estimated_bonus": estimated_bonus,
        "included_bonus": included_bonus,
        "transaction_price": transaction_price,
        "obligations": obligations,
        "allocations": allocations,
        "recognition": recognition,
        "revenue": revenue,
        "billings": billings,
        "collections": collections,
        "balances": balances,
    }


def print_schedule(schedule: dict[str, object]) -> None:
    obligations = schedule["obligations"]
    allocations = schedule["allocations"]
    recognition = schedule["recognition"]
    revenue = schedule["revenue"]
    billings = schedule["billings"]
    collections = schedule["collections"]
    balances = schedule["balances"]
    assert isinstance(obligations, dict)
    assert isinstance(allocations, dict)
    assert isinstance(recognition, dict)
    assert isinstance(revenue, list)
    assert isinstance(billings, list)
    assert isinstance(collections, list)
    assert isinstance(balances, list)

    print("LINDEN PEAK — REVENUE CONTRACT TRACE")
    print("Scope: arithmetic under supplied Topic 606 judgments; US dollars")
    print()
    print("TRANSACTION PRICE")
    print(f"  Fixed consideration                 {money(schedule['fixed'])}")
    print(f"  Estimated bonus                     {money(schedule['estimated_bonus'])}")
    print(f"  Bonus included after constraint     {money(schedule['included_bonus'])}")
    print(f"  Transaction price                   {money(schedule['transaction_price'])}")
    print()
    print("RELATIVE STANDALONE-PRICE ALLOCATION")
    print(f"  {'Obligation':24} {'SSP':>14} {'Allocation':>14}")
    for name in obligations:
        print(f"  {name:24} {money(obligations[name]):>14} {money(allocations[name]):>14}")
    print()
    print("THREE-PERIOD RECOGNITION")
    print(f"  {'Obligation':24} {'Year 1':>14} {'Year 2':>14} {'Year 3':>14}")
    for name, row in recognition.items():
        print(f"  {name:24} {money(row[0]):>14} {money(row[1]):>14} {money(row[2]):>14}")
    print()
    print("CONTRACT-BALANCE CONTROL")
    print(
        f"  {'Period':8} {'Revenue':>12} {'Billings':>12} {'Cash':>12} "
        f"{'A/R':>12} {'C. asset':>12} {'C. liab.':>12}"
    )
    for index, balance in enumerate(balances):
        print(
            f"  {'Year ' + str(index + 1):8} {money(revenue[index]):>12} "
            f"{money(billings[index]):>12} {money(collections[index]):>12} "
            f"{money(balance['receivable']):>12} {money(balance['contract_asset']):>12} "
            f"{money(balance['contract_liability']):>12}"
        )

    allocation_tie = sum(allocations.values()) - float(schedule["transaction_price"])
    revenue_tie = sum(revenue) - float(schedule["transaction_price"])
    final = balances[-1]
    checks = {
        "Allocation to transaction price": allocation_tie,
        "Revenue schedule to transaction price": revenue_tie,
        "Ending receivable": final["receivable"],
        "Ending contract asset": final["contract_asset"],
        "Ending contract liability": final["contract_liability"],
    }
    print()
    print("RECONCILIATION CHECKS")
    for label, difference in checks.items():
        status = "PASS" if abs(difference) < 0.005 else "CHECK"
        print(f"  {status:5} {label:39} {money(difference):>12}")
    print()
    print("A PASS verifies arithmetic only. It does not approve contract scope,")
    print("obligations, constraint, SSP evidence, control transfer, or credit loss.")


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--support-ssp",
        type=float,
        default=30_000.0,
        help="Support standalone selling price; default: 30,000",
    )
    args = parser.parse_args()
    if args.support_ssp <= 0:
        parser.error("--support-ssp must be positive")
    print_schedule(build_schedule(args.support_ssp))


if __name__ == "__main__":
    main()