"""Tests for marketing_intelligence.evasion.session."""

from collections.abc import Generator

import pytest

import marketing_intelligence.evasion.session as session_mod
from marketing_intelligence.evasion.session import (
    BrowserSession,
    create_session,
    delete_session,
    get_session,
    update_session,
)


@pytest.fixture(autouse=True)
def clear_store() -> Generator[None, None, None]:
    session_mod._store.clear()
    yield
    session_mod._store.clear()


class TestBrowserSession:
    def test_default_engine(self) -> None:
        s = BrowserSession()
        assert s.engine == "camoufox"

    def test_default_profile(self) -> None:
        s = BrowserSession()
        assert s.profile_name == "desktop"

    def test_default_human_behavior(self) -> None:
        assert BrowserSession().human_behavior is True

    def test_default_delay_factor(self) -> None:
        assert BrowserSession().delay_factor == 1.0

    def test_auto_session_id_is_8_chars(self) -> None:
        assert len(BrowserSession().session_id) == 8

    def test_two_sessions_have_different_ids(self) -> None:
        assert BrowserSession().session_id != BrowserSession().session_id

    def test_custom_engine_stored(self) -> None:
        assert BrowserSession(engine="nodriver").engine == "nodriver"

    def test_custom_proxy_stored(self) -> None:
        proxy = {"server": "http://proxy:8080"}
        assert BrowserSession(proxy=proxy).proxy == proxy


class TestCreateSession:
    def test_returns_browser_session(self) -> None:
        s = create_session()
        assert isinstance(s, BrowserSession)

    def test_stored_in_store(self) -> None:
        s = create_session()
        assert session_mod._store[s.session_id] is s

    def test_custom_engine(self) -> None:
        s = create_session(engine="nodriver")
        assert s.engine == "nodriver"

    def test_custom_profile(self) -> None:
        s = create_session(profile_name="mobile_ios")
        assert s.profile_name == "mobile_ios"

    def test_custom_delay_factor(self) -> None:
        s = create_session(delay_factor=0.5)
        assert s.delay_factor == 0.5

    def test_human_behavior_false(self) -> None:
        s = create_session(human_behavior=False)
        assert s.human_behavior is False

    def test_proxy_stored(self) -> None:
        proxy = {"server": "http://proxy:8080"}
        s = create_session(proxy=proxy)
        assert s.proxy == proxy

    def test_multiple_sessions_independent(self) -> None:
        s1 = create_session(engine="camoufox")
        s2 = create_session(engine="nodriver")
        assert s1.session_id != s2.session_id
        assert session_mod._store[s1.session_id].engine == "camoufox"
        assert session_mod._store[s2.session_id].engine == "nodriver"


class TestGetSession:
    def test_returns_stored_session(self) -> None:
        s = create_session()
        assert get_session(s.session_id) is s

    def test_returns_none_for_unknown_id(self) -> None:
        assert get_session("nonexistent-id") is None


class TestUpdateSession:
    def test_updates_existing_field(self) -> None:
        s = create_session(engine="camoufox")
        result = update_session(s.session_id, engine="nodriver")
        assert result is not None
        assert result.engine == "nodriver"

    def test_ignores_unknown_field(self) -> None:
        s = create_session()
        result = update_session(s.session_id, nonexistent_field="value")
        assert result is s

    def test_returns_none_for_unknown_session(self) -> None:
        assert update_session("nonexistent-id", engine="nodriver") is None

    def test_mutates_stored_session(self) -> None:
        s = create_session(delay_factor=1.0)
        update_session(s.session_id, delay_factor=2.5)
        assert session_mod._store[s.session_id].delay_factor == 2.5


class TestDeleteSession:
    def test_returns_true_and_removes(self) -> None:
        s = create_session()
        assert delete_session(s.session_id) is True
        assert s.session_id not in session_mod._store

    def test_returns_false_for_unknown(self) -> None:
        assert delete_session("nonexistent-id") is False

    def test_does_not_affect_other_sessions(self) -> None:
        s1 = create_session()
        s2 = create_session()
        delete_session(s1.session_id)
        assert s2.session_id in session_mod._store