"""Tests for cookie utilities."""

from app.utils.cookies import extract_access_token_from_cookies, parse_cookies


class TestParseCookies:
    """Test cookie parsing functionality."""

    def test_parse_empty_cookie_header(self):
        """Test parsing empty cookie header."""
        result = parse_cookies("")
        assert result == {}

    def test_parse_none_cookie_header(self):
        """Test parsing None cookie header."""
        result = parse_cookies("")
        assert result == {}

    def test_parse_single_cookie(self):
        """Test parsing single cookie."""
        cookie_header = "session_id=abc123"
        result = parse_cookies(cookie_header)

        assert result == {"session_id": "abc123"}

    def test_parse_multiple_cookies(self):
        """Test parsing multiple cookies."""
        cookie_header = "session_id=abc123; user_pref=dark_mode; lang=en"
        result = parse_cookies(cookie_header)

        expected = {
            "session_id": "abc123",
            "user_pref": "dark_mode",
            "lang": "en",
        }
        assert result == expected

    def test_parse_cookies_with_spaces(self):
        """Test parsing cookies with extra spaces."""
        cookie_header = " session_id = abc123 ; user_pref = dark_mode "
        result = parse_cookies(cookie_header)

        expected = {
            "session_id": "abc123",
            "user_pref": "dark_mode",
        }
        assert result == expected

    def test_parse_cookies_with_equals_in_value(self):
        """Test parsing cookies where value contains equals sign."""
        cookie_header = "encoded_data=key=value&other=data; session=123"
        result = parse_cookies(cookie_header)

        expected = {
            "encoded_data": "key=value&other=data",
            "session": "123",
        }
        assert result == expected

    def test_parse_cookies_malformed(self):
        """Test parsing malformed cookies (no equals sign)."""
        cookie_header = "session_id=abc123; malformed_cookie; user_pref=dark"
        result = parse_cookies(cookie_header)

        # Should skip malformed cookie and parse valid ones
        expected = {
            "session_id": "abc123",
            "user_pref": "dark",
        }
        assert result == expected

    def test_parse_cookies_empty_values(self):
        """Test parsing cookies with empty values."""
        cookie_header = "empty_value=; session_id=abc123"
        result = parse_cookies(cookie_header)

        expected = {
            "empty_value": "",
            "session_id": "abc123",
        }
        assert result == expected

    def test_parse_cookies_duplicate_names(self):
        """Test parsing cookies with duplicate names (last one wins)."""
        cookie_header = "session_id=first; session_id=second"
        result = parse_cookies(cookie_header)

        assert result == {"session_id": "second"}


class TestExtractAccessTokenFromCookies:
    """Test access token extraction from cookies."""

    def test_extract_access_token_present(self):
        """Test extracting access token when present."""
        cookie_header = "session_id=abc123; access_token=jwt_token_here; user_pref=dark"
        result = extract_access_token_from_cookies(cookie_header)

        assert result == "jwt_token_here"

    def test_extract_access_token_not_present(self):
        """Test extracting access token when not present."""
        cookie_header = "session_id=abc123; user_pref=dark"
        result = extract_access_token_from_cookies(cookie_header)

        assert result is None

    def test_extract_access_token_empty_header(self):
        """Test extracting access token from empty header."""
        result = extract_access_token_from_cookies("")
        assert result is None

    def test_extract_access_token_only_token(self):
        """Test extracting access token when it's the only cookie."""
        cookie_header = "access_token=my_jwt_token"
        result = extract_access_token_from_cookies(cookie_header)

        assert result == "my_jwt_token"

    def test_extract_access_token_with_spaces(self):
        """Test extracting access token with spaces around values."""
        cookie_header = " access_token = jwt_token_with_spaces ; other=value "
        result = extract_access_token_from_cookies(cookie_header)

        assert result == "jwt_token_with_spaces"

    def test_extract_access_token_empty_value(self):
        """Test extracting access token with empty value."""
        cookie_header = "access_token=; other=value"
        result = extract_access_token_from_cookies(cookie_header)

        assert result == ""

    def test_extract_access_token_complex_value(self):
        """Test extracting access token with complex JWT-like value."""
        jwt_token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjMiLCJleHAiOjE2MzM5NjY0MDB9.signature"
        cookie_header = f"session=abc; access_token={jwt_token}; csrf=token"
        result = extract_access_token_from_cookies(cookie_header)

        assert result == jwt_token

    def test_extract_access_token_multiple_equals(self):
        """Test extracting access token when value contains equals signs."""
        cookie_header = "access_token=encoded=data=here; other=simple"
        result = extract_access_token_from_cookies(cookie_header)

        assert result == "encoded=data=here"