#!/usr/bin/env -S uv run python
"""Reperform Cedar Trail's inventory cost-flow and measurement schedules.

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

    uv run python cedar-trail-cost-flow-and-measurement.py
"""

from __future__ import annotations


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


def issue(layers: list[list[float]], units: float, newest_first: bool) -> float:
    """Remove units from mutable [units, unit cost] layers."""
    cost = 0.0
    remaining = units
    while remaining > 0.000_001:
        position = -1 if newest_first else 0
        layer_units, unit_cost = layers[position]
        quantity = min(layer_units, remaining)
        cost += quantity * unit_cost
        layers[position][0] -= quantity
        remaining -= quantity
        if layers[position][0] < 0.000_001:
            layers.pop(position)
    return cost


def build_cost_flows() -> dict[str, tuple[float, float]]:
    """Return cost of goods sold and ending inventory by method."""
    opening = [[100.0, 10.0]]
    events = [
        ("purchase", 60.0, 12.0),
        ("sale", 120.0, None),
        ("purchase", 80.0, 14.0),
        ("sale", 50.0, None),
    ]
    all_layers = [layer.copy() for layer in opening]
    for kind, units, unit_cost in events:
        if kind == "purchase":
            assert unit_cost is not None
            all_layers.append([units, unit_cost])
    goods_available = sum(units * cost for units, cost in all_layers)
    units_sold = sum(units for kind, units, _ in events if kind == "sale")
    results: dict[str, tuple[float, float]] = {}

    for name, newest_first in (("FIFO", False), ("LIFO", True)):
        periodic_layers = [layer.copy() for layer in all_layers]
        periodic_cogs = issue(periodic_layers, units_sold, newest_first)
        periodic_ending = sum(units * cost for units, cost in periodic_layers)
        results[f"Periodic {name}"] = periodic_cogs, periodic_ending

        perpetual_layers = [layer.copy() for layer in opening]
        perpetual_cogs = 0.0
        for kind, units, unit_cost in events:
            if kind == "purchase":
                assert unit_cost is not None
                perpetual_layers.append([units, unit_cost])
            else:
                perpetual_cogs += issue(perpetual_layers, units, newest_first)
        perpetual_ending = sum(units * cost for units, cost in perpetual_layers)
        results[f"Perpetual {name}"] = perpetual_cogs, perpetual_ending

    total_units = 240.0
    ending_units = 70.0
    periodic_rate = goods_available / total_units
    results["Periodic average"] = (
        units_sold * periodic_rate,
        ending_units * periodic_rate,
    )

    moving_units = 100.0
    moving_cost = 1_000.0
    moving_cogs = 0.0
    for kind, units, unit_cost in events:
        if kind == "purchase":
            assert unit_cost is not None
            moving_units += units
            moving_cost += units * unit_cost
        else:
            issued_cost = units * moving_cost / moving_units
            moving_units -= units
            moving_cost -= issued_cost
            moving_cogs += issued_cost
    results["Perpetual moving average"] = moving_cogs, moving_cost
    return results


def main() -> None:
    flows = build_cost_flows()
    print("CEDAR TRAIL — INVENTORY CLOSE TRACE")
    print("Scope: arithmetic under supplied ownership, cost, method, and estimate inputs")
    print()
    print("COST-FLOW COMPARISON")
    print(f"  {'Method':28} {'Cost of sales':>16} {'Ending inventory':>18} {'Check':>12}")
    for method, (cost_of_sales, ending_inventory) in flows.items():
        difference = cost_of_sales + ending_inventory - 2_840.0
        print(
            f"  {method:28} {money(cost_of_sales):>16} "
            f"{money(ending_inventory):>18} {money(difference):>12}"
        )

    ordinary_write_down = 980.0 - min(980.0, 900.0)
    ceiling = 940.0
    floor = 940.0 - 100.0
    designated_market = min(max(880.0, floor), ceiling)
    lifo_write_down = 1_000.0 - min(1_000.0, designated_market)
    print()
    print("SUBSEQUENT MEASUREMENT")
    print(f"  Ordinary LCNRV write-down           {money(ordinary_write_down):>14}")
    print(f"  LIFO designated market              {money(designated_market):>14}")
    print(f"  LIFO market-path write-down         {money(lifo_write_down):>14}")

    gross_profit_ending = 20_000.0 + 80_000.0 - 120_000.0 * (1 - 0.30)
    retail_ending = (150_000.0 - 110_000.0) * (90_000.0 / 150_000.0)
    print()
    print("BOUNDED ESTIMATES")
    print(f"  Gross-profit estimated inventory    {money(gross_profit_ending):>14}")
    print(f"  Average-cost retail estimate        {money(retail_ending):>14}")

    print()
    print("$5,000 ENDING-INVENTORY OVERSTATEMENT")
    print(f"  Current cost of goods sold error    {money(-5_000):>14}")
    print(f"  Current pretax income error         {money(5_000):>14}")
    print(f"  Next-period pretax error            {money(-5_000):>14}")
    print()
    print("A zero check verifies arithmetic only. It does not approve ownership, cutoff,")
    print("cost eligibility, method, market evidence, estimate inputs, or disclosure.")


if __name__ == "__main__":
    main()