"""State machine unit tests — asset-centric (dcy-020 / REQ-057, BAT-030).

`inactive` is the only no-position state. The pool-model `idle`/`closed`
aliases were removed at the cutover (D2); migration 010 rewrites legacy rows.

BAT-051 / REQ-105 OQ-A: (INACTIVE, HOLDING) transition added to _SYNC_TRANSITIONS
for cold-start onboarding (actor=sync only, wire contract unchanged).
"""
from __future__ import annotations

import pytest

from trex_core.domain.slot.state import (
    ALLOWED_TRANSITIONS,
    SLOT_ADVISORY_LOCK_ID,
    SlotState,
    is_allowed_transition,
    slot_advisory_lock_id,
)


def test_slot_state_members():
    """dcy-020 (BAT-030): 5 canonical members — idle/closed aliases removed."""
    assert {s.value for s in SlotState} == {
        "inactive",
        "pending_buy",
        "holding",
        "pending_sell",
        "error",
    }


def test_legacy_alias_values_rejected():
    """`idle`/`closed` are no longer valid SlotState values (migration 010
    rewrites any remaining DB rows before this code reads them)."""
    with pytest.raises(ValueError):
        SlotState("idle")
    with pytest.raises(ValueError):
        SlotState("closed")


def test_advisory_lock_id_is_stable_constant():
    """SLOT_ADVISORY_LOCK_ID base must not change between releases (REQ-002 NFR-1)."""
    assert isinstance(SLOT_ADVISORY_LOCK_ID, int)
    assert SLOT_ADVISORY_LOCK_ID == 0x5107_4D31


def test_slot_advisory_lock_id_is_instance_scoped():
    """dcy-020/REQ-057: distinct instance_key -> distinct lock id; same -> same."""
    a = slot_advisory_lock_id("inst-a")
    b = slot_advisory_lock_id("inst-b")
    assert a != b
    assert slot_advisory_lock_id("inst-a") == a
    # 'default' keeps a stable derived id
    assert slot_advisory_lock_id("default") == slot_advisory_lock_id("default")


@pytest.mark.parametrize(
    "from_state,to_state",
    [
        # canonical lifecycle
        (SlotState.INACTIVE, SlotState.PENDING_BUY),
        (SlotState.PENDING_BUY, SlotState.HOLDING),
        (SlotState.PENDING_BUY, SlotState.INACTIVE),
        (SlotState.HOLDING, SlotState.PENDING_BUY),    # dcy-021 increase
        (SlotState.HOLDING, SlotState.PENDING_SELL),
        (SlotState.PENDING_SELL, SlotState.INACTIVE),
        (SlotState.PENDING_SELL, SlotState.HOLDING),
        # to error (every non-error)
        (SlotState.INACTIVE, SlotState.ERROR),
        (SlotState.PENDING_BUY, SlotState.ERROR),
        (SlotState.HOLDING, SlotState.ERROR),
        (SlotState.PENDING_SELL, SlotState.ERROR),
        # operator resolve out of error
        (SlotState.ERROR, SlotState.INACTIVE),
        (SlotState.ERROR, SlotState.HOLDING),
        # BAT-051 / REQ-105 OQ-A: cold-start onboarding sync (actor=sync only)
        (SlotState.INACTIVE, SlotState.HOLDING),
    ],
)
def test_allowed_transition(from_state: SlotState, to_state: SlotState):
    assert is_allowed_transition(from_state, to_state)


@pytest.mark.parametrize(
    "from_state,to_state",
    [
        # skipping intermediate states (INACTIVE→HOLDING now in _SYNC_TRANSITIONS)
        (SlotState.INACTIVE, SlotState.PENDING_SELL),
        (SlotState.HOLDING, SlotState.INACTIVE),
        (SlotState.PENDING_BUY, SlotState.PENDING_SELL),
        (SlotState.PENDING_SELL, SlotState.PENDING_BUY),
        # error has restricted exits — only inactive and holding
        (SlotState.ERROR, SlotState.PENDING_BUY),
        (SlotState.ERROR, SlotState.PENDING_SELL),
        (SlotState.ERROR, SlotState.ERROR),
    ],
)
def test_disallowed_transition(from_state: SlotState, to_state: SlotState):
    assert not is_allowed_transition(from_state, to_state)


def test_self_loops_are_not_allowed():
    """No state may transition to itself."""
    for s in SlotState:
        assert not is_allowed_transition(s, s)


def test_allowed_transitions_set_size():
    """7 base (incl. dcy-021 holding→pending_buy) + 4 to-error + 2 operator-resolve
    + 1 sync-onboarding (REQ-105 OQ-A: INACTIVE→HOLDING) = 14."""
    assert len(ALLOWED_TRANSITIONS) == 14


def test_sync_transition_inactive_to_holding_is_allowed():
    """REQ-105 OQ-A: INACTIVE→HOLDING is allowed (cold-start onboarding via sync)."""
    assert is_allowed_transition(SlotState.INACTIVE, SlotState.HOLDING)


def test_slot_state_enum_still_5_values():
    """REQ-105 OQ-A / REQ-108 NFR-4: wire contract unchanged — enum still 5 states."""
    assert len(list(SlotState)) == 5
    assert {s.value for s in SlotState} == {
        "inactive", "pending_buy", "holding", "pending_sell", "error"
    }


def test_normal_strategy_path_unchanged():
    """REQ-105 OQ-A: normal strategy path (INACTIVE→PENDING_BUY) still allowed;
    sync path (INACTIVE→HOLDING) is additive."""
    assert is_allowed_transition(SlotState.INACTIVE, SlotState.PENDING_BUY)
    assert is_allowed_transition(SlotState.INACTIVE, SlotState.HOLDING)