import datetime
import math
from puga import saturation as s, market, fio


def test_tref_uses_min_and_poisson_floor():
    assert s.tref(60, 40) == 40
    assert s.tref(15, 13) < 13                    # low volume gets a lower bound
    assert s.tref(0, 0) == 0


def test_tref_precise_pads_missing_calendar_days_not_just_trading_days(monkeypatch):
    # 10 trading days out of 30, each with volume 30 -> real per-calendar-day mean is 10, not 30.
    # The original bug averaged only over the 10 trading-day rows (mean 30), overstating the
    # bound 3x for exactly the sparse tickers it's meant to protect.
    base = datetime.date(2026, 1, 1)
    fake_td = [(base + datetime.timedelta(days=i * 3), 30.0) for i in range(10)]
    monkeypatch.setattr(s, "trading_days", lambda tk, cx, days: fake_td)
    bound = s.tref_precise("FAKE", "AI1", traded7=30, traded30=30, days=30)
    assert bound < 15.0   # well below the naive trading-day mean of 30, reflecting real sparsity


def test_n_out_penalises_queue():
    free = s.n_out(100, 0, 5)                     # no queue
    assert math.isclose(free, 0.25 * 100 / 5)
    assert s.n_out(100, 7000, 5) < free           # 70 days of queue cuts it
    assert s.n_out(0, 0, 5) == 0


def test_thin_flag():
    assert s.is_thin(1.3, 100, 5) and not s.is_thin(60, 500, 5)


def test_p_patient_clamps_and_falls_to_bid_when_oversupplied():
    asks = [(100, 50), (110, 50), (120, 50)]
    assert s.p_patient(asks, 10, 20, bid=90, vwap7=105, vwap30=105, ask=100) == 90   # we out-produce flow: sell at bid
    p = s.p_patient(asks, 30, 1, 90, 200, 200, 100)                                  # ample flow: capped by ask level 100
    assert p == 100


def test_walk_treats_mm_null_count_as_unlimited(monkeypatch):
    monkeypatch.setattr(fio, "order_book", lambda m, c, r=False: {
        "SellingOrders": [], "BuyingOrders": [{"ItemCount": 4, "ItemCost": 90}, {"ItemCount": None, "ItemCost": 80}]})
    r = market.walk("X", "AI1", 1000, "sell")
    assert r["filled"] == 1000 and not r["short"] and r["worst"] == 80


def test_effective_supply_ignores_stale_far_asks():
    asks = [(100, 10), (110, 20), (150, 1500)]
    assert s.effective_supply(asks, 100) == 30          # 1500 units at 1.5x are not competition
    assert s.effective_supply(asks, None) == 1530


def test_effective_supply_hard_filters_out_of_band_asks():
    asks = [(100, 10), (110, 20), (150, 1500)]
    # band excludes the 150 tier outright, even though ref_price=None would otherwise count it
    assert s.effective_supply(asks, None, band=(50, 120)) == 30


def test_in_band():
    assert s.in_band(700, (663, 16575)) is True
    assert s.in_band(334, (663, 16575)) is False
    assert s.in_band(20000, (663, 16575)) is False
    assert s.in_band(1, None) is True                   # no band given: nothing excluded


def test_effective_demand_excludes_stale_bids_below_the_band():
    bids = [(4550, 8), (4200, 250), (2810, 8), (334, 19)]
    assert s.effective_demand(bids, band=(663, 16575)) == 8 + 250 + 8   # the 334 bid is stale, excluded
    assert s.effective_demand(bids, band=None) == 8 + 250 + 8 + 19


def test_max_units_at_impact_stops_at_the_price_threshold():
    bids = [(100, 10), (95, 20), (85, 1000)]            # ref 100, 10% floor = 90
    assert s.max_units_at_impact(bids, 100, max_impact_pct=10.0) == 30   # 100 and 95 tiers only
    assert s.max_units_at_impact(bids, 100, max_impact_pct=20.0) == 1030  # all three tiers now qualify
    assert s.max_units_at_impact([], 100) == 0.0
    assert s.max_units_at_impact(bids, 0) == 0.0