"""Выбор версии правил для шахматки без обращения к БД."""

import datetime
import uuid
from types import SimpleNamespace
from unittest.mock import AsyncMock

import pytest

from src.models.enums import StatementType
from src.repositories import elimination_rules as rules_repo
from src.services import elimination_rules as service_module


def _rule() -> SimpleNamespace:
    return SimpleNamespace(
        id=uuid.uuid4(),
        statement_type=StatementType.balance,
        rule_no=2,
        version_no=3,
        side_1="D",
        measure="closing",
    )


@pytest.mark.parametrize(
    ("rule", "version_no", "as_of", "expected"),
    [
        (None, 3, None, False),
        (SimpleNamespace(version_no=3), None, None, False),
        (SimpleNamespace(version_no=3), 2, None, False),
        (SimpleNamespace(version_no=3), 3, None, True),
        (
            SimpleNamespace(version_no=3, valid_from=datetime.date(2024, 1, 1), valid_to=datetime.date(2024, 12, 31)),
            3,
            datetime.date(2023, 12, 31),
            False,
        ),
        (
            SimpleNamespace(version_no=3, valid_from=datetime.date(2024, 1, 1), valid_to=datetime.date(2024, 12, 31)),
            3,
            datetime.date(2024, 12, 31),
            True,
        ),
        (
            SimpleNamespace(version_no=3, valid_from=datetime.date(2024, 1, 1), valid_to=datetime.date(2024, 12, 31)),
            3,
            datetime.date(2025, 1, 1),
            False,
        ),
    ],
)
def test_rule_is_valid_for_version(
    rule: SimpleNamespace | None, version_no: int | None, as_of: datetime.date | None, expected: bool
) -> None:
    assert rules_repo.is_valid_for_version(rule, version_no, as_of=as_of) is expected


async def test_fixed_rules_version_ignores_current_date(monkeypatch: pytest.MonkeyPatch) -> None:
    session, scope = object(), object()
    version_id = uuid.uuid4()
    rule = _rule()
    account_id = uuid.uuid4()
    account = SimpleNamespace(company_no=1, account_id=account_id, is_excluded=False)
    monkeypatch.setattr(
        service_module.consolidations_repo,
        "get_version",
        AsyncMock(return_value=(SimpleNamespace(elimination_rules_version=rule.version_no), None)),
    )
    current = AsyncMock()
    listed = AsyncMock(return_value=[(rule, account)])
    monkeypatch.setattr(service_module.rules_repo, "current_version_no", current)
    monkeypatch.setattr(service_module.rules_repo, "list_rules_with_accounts", listed)

    result = await service_module.EliminationRuleService(session, scope).list_rules(version_id)

    assert result.is_version_fixed is True
    assert result.version_no == rule.version_no
    assert result.as_of is None
    assert [item.id for item in result.rules] == [rule.id]
    assert result.rules[0].company_1.accounts == [account_id]
    current.assert_not_awaited()
    listed.assert_awaited_once_with(session, rule.version_no, as_of=None)


async def test_unfixed_rules_use_latest_active_version_on_moscow_date(monkeypatch: pytest.MonkeyPatch) -> None:
    session, scope = object(), object()
    version_id = uuid.uuid4()
    rule = _rule()
    expected_date = datetime.date(2026, 10, 19)
    monkeypatch.setattr(service_module, "utc_now", lambda: datetime.datetime(2026, 10, 18, 22, tzinfo=datetime.UTC))
    monkeypatch.setattr(
        service_module.consolidations_repo,
        "get_version",
        AsyncMock(return_value=(SimpleNamespace(elimination_rules_version=None), None)),
    )
    current = AsyncMock(return_value=rule.version_no)
    listed = AsyncMock(return_value=[(rule, None)])
    monkeypatch.setattr(service_module.rules_repo, "current_version_no", current)
    monkeypatch.setattr(service_module.rules_repo, "list_rules_with_accounts", listed)

    result = await service_module.EliminationRuleService(session, scope).list_rules(version_id)

    assert result.is_version_fixed is False
    assert result.version_no == rule.version_no
    assert result.as_of == expected_date
    assert [item.id for item in result.rules] == [rule.id]
    current.assert_awaited_once_with(session, expected_date)
    listed.assert_awaited_once_with(session, rule.version_no, as_of=expected_date)


async def test_no_current_rules_returns_empty_with_unfixed_flag(monkeypatch: pytest.MonkeyPatch) -> None:
    session, scope = object(), object()
    monkeypatch.setattr(
        service_module.consolidations_repo,
        "get_version",
        AsyncMock(return_value=(SimpleNamespace(elimination_rules_version=None), None)),
    )
    monkeypatch.setattr(service_module.rules_repo, "current_version_no", AsyncMock(return_value=None))
    listed = AsyncMock()
    monkeypatch.setattr(service_module.rules_repo, "list_rules_with_accounts", listed)

    result = await service_module.EliminationRuleService(session, scope).list_rules(uuid.uuid4())

    assert result.is_version_fixed is False
    assert result.version_no is None
    assert result.as_of is not None
    assert result.rules == []
    listed.assert_not_awaited()