"""
P014: adaptive_router.py previously had ZERO test coverage and a docstring
("all methods, no compliance restrictions. See b0ts for scraping") that
directly contradicted this product's own compliance stance and pointed at a
forbidden, separate, non-compliant repo. This file tests the corrected
version: plan_for_market's static per-market plan, and the new block-
tracking (record_blocked/is_blocked/cooldown) that makes the engine actually
back off a source that just told it to stop, instead of retrying it with no
memory at all.
"""
from __future__ import annotations

from workers.adaptive_router import AdaptiveRouter, MARKET_SOURCES, plan_for_market


class TestPlanForMarket:
    def test_returns_the_full_static_plan_when_nothing_is_blocked(self):
        router = AdaptiveRouter()
        assert plan_for_market("GB", router=router) == MARKET_SOURCES["GB"]

    def test_unknown_market_falls_back_to_gleif_only(self):
        router = AdaptiveRouter()
        assert plan_for_market("ZZ", router=router) == ["gleif"]

    def test_defaults_to_the_process_wide_router_when_none_is_passed(self):
        # Just proves the call doesn't blow up and returns a real plan --
        # not asserting anything about global state here (other tests use
        # their own injected router precisely to avoid cross-test pollution
        # of the shared default_router).
        assert plan_for_market("FI") == MARKET_SOURCES["FI"]


class TestBlockTracking:
    def test_a_freshly_blocked_source_is_excluded_from_the_plan(self):
        router = AdaptiveRouter()
        router.record_blocked("GB", "companies_house")
        plan = plan_for_market("GB", router=router)
        assert "companies_house" not in plan
        assert "gleif" in plan  # only the blocked source is removed, not the whole market

    def test_is_blocked_is_false_before_any_block_is_recorded(self):
        router = AdaptiveRouter()
        assert router.is_blocked("GB", "companies_house") is False

    def test_blocking_is_scoped_per_market_not_global_to_the_source_id(self):
        # gleif appears in every market's plan -- blocking it for GB must not
        # silently remove it from FI/SE/etc too.
        router = AdaptiveRouter()
        router.record_blocked("GB", "gleif")
        assert "gleif" not in plan_for_market("GB", router=router)
        assert "gleif" in plan_for_market("FI", router=router)
        assert "gleif" in plan_for_market("SE", router=router)

    def test_cooldown_expires_and_the_source_becomes_eligible_again(self):
        router = AdaptiveRouter(cooldown_seconds=60.0)
        router.record_blocked("GB", "companies_house", now=1000.0)
        assert router.is_blocked("GB", "companies_house", now=1030.0) is True  # still within cooldown
        assert router.is_blocked("GB", "companies_house", now=1061.0) is False  # cooldown elapsed
        # And the plan reflects that:
        assert "companies_house" in plan_for_market("GB", router=router)

    def test_clear_forgets_every_recorded_block(self):
        router = AdaptiveRouter()
        router.record_blocked("GB", "companies_house")
        router.record_blocked("NO", "brreg")
        router.clear()
        assert plan_for_market("GB", router=router) == MARKET_SOURCES["GB"]
        assert plan_for_market("NO", router=router) == MARKET_SOURCES["NO"]

    def test_two_router_instances_never_share_state(self):
        # Regression guard for a shared-mutable-default bug class: each
        # AdaptiveRouter() must own its own dict, not a class-level one.
        a = AdaptiveRouter()
        b = AdaptiveRouter()
        a.record_blocked("GB", "companies_house")
        assert a.is_blocked("GB", "companies_house") is True
        assert b.is_blocked("GB", "companies_house") is False