from decimal import Decimal

from app.domain.price import (
    filter_and_sort_prices,
    filter_valid_prices,
    normalize_delivery_request,
    sort_prices_by_price,
)
from app.schemas.request import DeliveryEntity, DeliveryRequest
from app.schemas.response import DeliveryPrice


def _make_price(**overrides) -> DeliveryPrice:
    payload = {
        "provider": "provider-a",
        "service_name": "standard",
        "price": Decimal("100.00"),
        "currency": "RUB",
        "delivery_days_min": 2,
        "delivery_days_max": 4,
    }
    payload.update(overrides)
    return DeliveryPrice.model_construct(**payload)


def _make_request(**overrides) -> DeliveryRequest:
    payload = {
        "entity": DeliveryEntity.INDIVIDUAL,
        "from_city": "  Moscow  ",
        "to_city": "  Saint Petersburg  ",
        "weight_kg": 1.235,
        "length_cm": 10.04,
        "width_cm": 20.05,
        "height_cm": 30.06,
    }
    payload.update(overrides)
    return DeliveryRequest(**payload)


def test_normalize_delivery_request_applies_rules_without_side_effects() -> None:
    request = _make_request()

    normalized = normalize_delivery_request(request, weight_round_scale=2)

    assert normalized is not request
    assert normalized.from_city == "Moscow"
    assert normalized.to_city == "Saint Petersburg"
    assert normalized.weight_kg == Decimal("1.24")
    assert normalized.length_cm == Decimal("10.0")
    assert normalized.width_cm == Decimal("20.1")
    assert normalized.height_cm == Decimal("30.1")
    assert request.from_city == "  Moscow  "


def test_normalize_delivery_request_handles_normalization_boundaries() -> None:
    request = _make_request(
        weight_kg=0.0001,
        length_cm=0.01,
        width_cm=0.04,
        height_cm=0.15,
    )

    low_scale = normalize_delivery_request(request, weight_round_scale=-5)
    high_scale = normalize_delivery_request(request, weight_round_scale=99)

    assert low_scale.weight_kg == Decimal("0.01")
    assert low_scale.length_cm == Decimal("0.1")
    assert low_scale.width_cm == Decimal("0.1")
    assert low_scale.height_cm == Decimal("0.2")
    assert high_scale.weight_kg == Decimal("0.01")


def test_filter_valid_prices_handles_empty_input() -> None:
    assert filter_valid_prices([]) == []
    assert filter_and_sort_prices([]) == []


def test_filter_valid_prices_excludes_invalid_records() -> None:
    valid = _make_price(provider=" cdek ", service_name=" express ", currency="rub")
    invalid_provider = _make_price(provider=" ")
    invalid_price = _make_price(price=Decimal("-1.00"))
    invalid_currency = _make_price(currency="RUR1")
    invalid_range = _make_price(delivery_days_min=5, delivery_days_max=3)

    result = filter_valid_prices(
        [
            valid,
            invalid_provider,
            invalid_price,
            invalid_currency,
            invalid_range,
            {"not": "a price"},
        ]
    )

    assert len(result) == 1
    assert result[0].provider == "cdek"
    assert result[0].service_name == "express"
    assert result[0].currency == "RUB"


def test_filter_valid_prices_excludes_non_finite_prices() -> None:
    valid = _make_price(provider="cdek", price=Decimal("199.00"))
    invalid_nan = _make_price(price=Decimal("NaN"))
    invalid_inf = _make_price(price=Decimal("Infinity"))
    invalid_neg_inf = _make_price(price=Decimal("-Infinity"))

    result = filter_valid_prices([invalid_nan, invalid_inf, invalid_neg_inf, valid])

    assert len(result) == 1
    assert result[0].provider == "cdek"


def test_filter_valid_prices_excludes_none_provider_and_service() -> None:
    valid = _make_price(provider="cdek", service_name="express")
    invalid_provider_none = _make_price(provider=None)
    invalid_service_none = _make_price(service_name=None)

    result = filter_valid_prices([invalid_provider_none, invalid_service_none, valid])

    assert len(result) == 1
    assert result[0].provider == "cdek"
    assert result[0].service_name == "express"


def test_sort_prices_by_price_keeps_equal_price_order_stable() -> None:
    price_a = _make_price(provider="a", price=Decimal("150.00"))
    price_b = _make_price(provider="b", price=Decimal("150.00"))
    price_c = _make_price(provider="c", price=Decimal("99.99"))

    sorted_prices = sort_prices_by_price([price_a, price_b, price_c])

    assert [price.provider for price in sorted_prices] == ["c", "a", "b"]


def test_filter_and_sort_prices_combines_domain_steps() -> None:
    price_a = _make_price(provider="a", price=Decimal("220.00"))
    price_b = _make_price(provider="b", price=Decimal("100.00"))
    invalid = _make_price(provider="", price=Decimal("50.00"))

    result = filter_and_sort_prices([price_a, invalid, price_b])

    assert [price.provider for price in result] == ["b", "a"]