# /// script
# requires-python = ">=3.12"
# dependencies = []
# [tool.uv]
# exclude-newer = "2026-08-07T00:00:00Z"
# ///
"""Reperform fictional finance and operating lessee schedules.

Run from any directory with:
    uv run /absolute/path/to/cedar-trail-lessee-schedules.py

No third-party packages are required. Classification, rates, payment scope,
dates, direct costs, incentives, and the change route are supplied assumptions.
"""

from __future__ import annotations


def money(amount: float) -> str:
    """Format signed US dollars with commas and parentheses."""
    return f"(${abs(amount):,.2f})" if amount < 0 else f"${amount:,.2f}"


def percent(rate: float) -> str:
    """Format a decimal rate as a percentage."""
    return f"{rate:.6%}"


def annuity_present_value(payment: float, rate: float, periods: int) -> float:
    """Present value of equal end-of-period payments."""
    return payment * (1 - (1 + rate) ** -periods) / rate


def print_table(headers: tuple[str, ...], rows: list[tuple[str, ...]]) -> None:
    """Print a small dependency-free, right-aligned text table."""
    widths = [len(header) for header in headers]
    for row in rows:
        for index, value in enumerate(row):
            widths[index] = max(widths[index], len(value))
    print("  ".join(value.rjust(widths[index]) for index, value in enumerate(headers)))
    print("  ".join("-" * width for width in widths))
    for row in rows:
        print("  ".join(value.rjust(widths[index]) for index, value in enumerate(row)))


def liability_rows(
    opening_liability: float, payment: float, rate: float, periods: int
) -> list[dict[str, float]]:
    """Build an effective-interest lease-liability schedule."""
    rows: list[dict[str, float]] = []
    liability = opening_liability
    for period in range(1, periods + 1):
        interest = liability * rate
        principal = payment - interest
        ending_liability = liability - principal
        if abs(ending_liability) < 1e-9:
            ending_liability = 0.0
        rows.append(
            {
                "period": float(period),
                "opening": liability,
                "interest": interest,
                "cash": payment,
                "principal": principal,
                "ending": ending_liability,
            }
        )
        liability = ending_liability
    return rows


print("CEDAR TRAIL — LESSEE SCHEDULES")
print("All entities, judgments, rates, dates, and amounts are fictional.\n")

# Finance lease: supplied classification and annual, year-end payment pattern.
finance_payment = 25_000.0
finance_rate = 0.08
finance_periods = 5
finance_liability = annuity_present_value(finance_payment, finance_rate, finance_periods)
finance_rou_asset = finance_liability
finance_rou_amortization = finance_rou_asset / finance_periods
finance_rows = liability_rows(finance_liability, finance_payment, finance_rate, finance_periods)

print("1. SUPPLIED FINANCE CLASSIFICATION")
print(
    f"Opening liability = {money(finance_payment)} × ordinary-annuity factor"
    f"({percent(finance_rate)}, {finance_periods}) = {money(finance_liability)}"
)
print(f"Opening ROU asset: {money(finance_rou_asset)}")
print(f"Straight-line ROU amortization: {money(finance_rou_amortization)}\n")

finance_table: list[tuple[str, ...]] = []
finance_rou = finance_rou_asset
for row in finance_rows:
    finance_rou -= finance_rou_amortization
    lease_cost = row["interest"] + finance_rou_amortization
    finance_table.append(
        (
            str(int(row["period"])),
            money(row["opening"]),
            money(row["interest"]),
            money(-row["cash"]),
            money(row["principal"]),
            money(row["ending"]),
            money(finance_rou_amortization),
            money(lease_cost),
        )
    )
print_table(
    (
        "Year",
        "Open liab.",
        "Interest",
        "Cash",
        "Principal",
        "End liab.",
        "ROU amort.",
        "Total cost",
    ),
    finance_table,
)
print()

# Operating lease: same liability mechanism, different ROU and cost pattern.
operating_payment = 40_000.0
operating_rate = 0.06
operating_periods = 5
operating_direct_costs = 3_000.0
operating_incentive = 5_000.0
operating_liability = annuity_present_value(operating_payment, operating_rate, operating_periods)
operating_rou_asset = operating_liability + operating_direct_costs - operating_incentive
operating_total_cost = (
    operating_payment * operating_periods + operating_direct_costs - operating_incentive
)
operating_single_cost = operating_total_cost / operating_periods
operating_rows = liability_rows(
    operating_liability, operating_payment, operating_rate, operating_periods
)

print("2. SUPPLIED OPERATING CLASSIFICATION")
print(f"Opening liability: {money(operating_liability)}")
print(
    "Opening ROU asset = liability + direct costs − incentive = "
    f"{money(operating_liability)} + {money(operating_direct_costs)} − "
    f"{money(operating_incentive)} = {money(operating_rou_asset)}"
)
print(
    "Single lease cost = (contractual cash + direct costs − incentive) ÷ term = "
    f"{money(operating_single_cost)}\n"
)

operating_table: list[tuple[str, ...]] = []
operating_rou = operating_rou_asset
for row in operating_rows:
    rou_reduction = operating_single_cost - row["interest"]
    operating_rou -= rou_reduction
    if abs(operating_rou) < 1e-9:
        operating_rou = 0.0
    operating_table.append(
        (
            str(int(row["period"])),
            money(row["opening"]),
            money(row["interest"]),
            money(-row["cash"]),
            money(row["principal"]),
            money(row["ending"]),
            money(rou_reduction),
            money(operating_rou),
            money(operating_single_cost),
        )
    )
print_table(
    (
        "Year",
        "Open liab.",
        "Interest",
        "Cash",
        "Principal",
        "End liab.",
        "ROU reduce",
        "End ROU",
        "Lease cost",
    ),
    operating_table,
)
print()

# Supplied non-separate change at its effective date.
old_liability_at_change = 120_000.0
revised_payment = 36_000.0
revised_rate = 0.07
remaining_periods = 4
revised_liability = annuity_present_value(revised_payment, revised_rate, remaining_periods)
remeasurement_adjustment = revised_liability - old_liability_at_change

print("3. SUPPLIED REMEASUREMENT AT THE CHANGE DATE")
print(f"Liability immediately before change: {money(old_liability_at_change)}")
print(
    f"Revised liability: {money(revised_payment)} × ordinary-annuity factor"
    f"({percent(revised_rate)}, {remaining_periods}) = {money(revised_liability)}"
)
print(f"Liability and ROU adjustment: {money(remeasurement_adjustment)}\n")

# Numeric controls use full precision even though the display is rounded.
assert abs(finance_rows[-1]["ending"]) < 1e-8
assert abs(operating_rows[-1]["ending"]) < 1e-8
assert abs(finance_rou_asset - finance_rou_amortization * finance_periods) < 1e-8
assert abs(operating_rou) < 1e-8
print("CONTROLS")
print("Finance liability settles: PASS")
print("Finance ROU asset amortizes to zero: PASS")
print("Operating liability settles: PASS")
print("Operating ROU asset reduces to zero: PASS\n")

print("BOUNDARY")
print("This script does not identify or classify a lease, approve a rate or payment")
print("population, qualify direct costs, route a modification, test impairment, or")
print("approve entries, statement presentation, tax treatment, or disclosures.")