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

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", "expected"),
    [
        (None, 3, False),
        (SimpleNamespace(version_no=3, valid_to=None), None, True),
        (SimpleNamespace(version_no=3, valid_to="2026-12-31"), None, False),
        (SimpleNamespace(version_no=3), 2, False),
        (SimpleNamespace(version_no=3), 3, True),
        (SimpleNamespace(version_no=3, valid_to="2026-12-31"), 3, True),
    ],
)
def test_rule_is_valid_for_version(rule: SimpleNamespace | None, version_no: int | None, expected: bool) -> None:
    assert rules_repo.is_valid_for_version(rule, version_no) is expected


async def test_rules_filter_by_version_or_open_valid_to() -> None:
    version_no = 3
    session = SimpleNamespace(execute=AsyncMock(return_value=SimpleNamespace(all=lambda: [])))

    await rules_repo.list_rules_with_accounts(session, None)
    query = str(session.execute.await_args.args[0])
    assert "valid_to IS NULL" in query
    assert "max(" in query
    assert "version_no = (SELECT" in query

    await rules_repo.list_rules_with_accounts(session, version_no)
    assert "valid_to IS NULL" not in str(session.execute.await_args.args[0])
    assert "version_no =" in str(session.execute.await_args.args[0])


async def test_fixed_rules_use_version_number(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)),
    )
    listed = AsyncMock(return_value=[(rule, account)])
    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 [item.id for item in result.rules] == [rule.id]
    assert result.rules[0].company_1.accounts == [account_id]
    listed.assert_awaited_once_with(session, rule.version_no)


async def test_unfixed_rules_use_open_valid_to(monkeypatch: pytest.MonkeyPatch) -> None:
    session, scope = object(), object()
    version_id = uuid.uuid4()
    rule = _rule()
    monkeypatch.setattr(
        service_module.consolidations_repo,
        "get_version",
        AsyncMock(return_value=(SimpleNamespace(elimination_rules_version=None), None)),
    )
    listed = AsyncMock(return_value=[(rule, None)])
    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 [item.id for item in result.rules] == [rule.id]
    listed.assert_awaited_once_with(session, None)


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)),
    )
    listed = AsyncMock(return_value=[])
    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.rules == []
    listed.assert_awaited_once_with(session, None)