"""Tests for Cookie validation functionality.

Tests the validate_cookie method in ZhihuLogin class.
"""

from unittest.mock import MagicMock, patch, AsyncMock
import pytest

from kb_workflow.auth.zhihu_login import ZhihuLogin, CookieValidationResult


class TestCookieValidation:
    """Test suite for cookie validation."""

    @pytest.fixture
    def mock_browser_with_request(self):
        """Mock browser with request API support."""
        browser = MagicMock()
        browser.browser = MagicMock()
        browser.page = MagicMock()

        # Create mock response
        mock_response = MagicMock()
        mock_response.status = 200
        mock_response.json = AsyncMock(return_value={
            "id": 12345678,
            "name": "TestUser",
            "url_token": "testuser"
        })

        # Setup page.request.get to return mock response
        browser.page.request = MagicMock()
        browser.page.request.get = AsyncMock(return_value=mock_response)

        browser.close = MagicMock()
        browser.start = MagicMock()

        return browser, mock_response

    @pytest.mark.asyncio
    async def test_validate_cookie_valid(self, mock_browser_with_request, intermediate_path):
        """Test 1: validate_cookie_valid - Valid cookie returns valid=True with user info."""
        # Arrange
        mock_browser, _ = mock_browser_with_request
        login = ZhihuLogin(intermediate_path=intermediate_path)
        login.browser = mock_browser

        # Act
        result = await login.validate_cookie("z_c0=valid_cookie_value")

        # Assert
        assert isinstance(result, CookieValidationResult)
        assert result.valid is True
        assert result.username == "TestUser"
        assert result.user_id == "12345678"
        assert result.reason is None

    @pytest.mark.asyncio
    async def test_validate_cookie_expired(self, mock_browser_with_request, intermediate_path):
        """Test 2: validate_cookie_expired - Expired cookie returns valid=False."""
        # Arrange
        mock_browser, mock_response = mock_browser_with_request
        mock_response.status = 401

        login = ZhihuLogin(intermediate_path=intermediate_path)
        login.browser = mock_browser

        # Act
        result = await login.validate_cookie("z_c0=expired_cookie_value")

        # Assert
        assert isinstance(result, CookieValidationResult)
        assert result.valid is False
        assert result.reason == "Cookie expired"
        assert result.username is None
        assert result.user_id is None

    @pytest.mark.asyncio
    async def test_validate_cookie_empty(self, intermediate_path):
        """Test 3: validate_cookie_empty - Empty cookie returns valid=False."""
        # Arrange
        login = ZhihuLogin(intermediate_path=intermediate_path)
        login.browser = MagicMock()
        login.browser.page = None  # No page means no cookie loaded

        # Act
        result = await login.validate_cookie()

        # Assert
        assert isinstance(result, CookieValidationResult)
        assert result.valid is False
        assert "No cookie" in result.reason

    @pytest.mark.asyncio
    async def test_validate_cookie_malformed(self, intermediate_path):
        """Test 4: validate_cookie_malformed - Malformed cookie returns valid=False."""
        # Arrange
        mock_browser = MagicMock()
        mock_browser.browser = MagicMock()
        mock_browser.page = MagicMock()
        mock_browser.page.request = MagicMock()
        mock_browser.page.request.get = AsyncMock(side_effect=Exception("Network error"))
        mock_browser.close = MagicMock()
        mock_browser.start = MagicMock()

        login = ZhihuLogin(intermediate_path=intermediate_path)
        login.browser = mock_browser

        # Act
        result = await login.validate_cookie("invalid_format_cookie")

        # Assert
        assert isinstance(result, CookieValidationResult)
        assert result.valid is False
        assert "Network error" in result.reason

    @pytest.mark.asyncio
    async def test_validate_cookie_other_status_code(self, mock_browser_with_request, intermediate_path):
        """Test 5: validate_cookie with non-200/401 status code."""
        # Arrange
        mock_browser, mock_response = mock_browser_with_request
        mock_response.status = 500

        login = ZhihuLogin(intermediate_path=intermediate_path)
        login.browser = mock_browser

        # Act
        result = await login.validate_cookie("z_c0=some_cookie")

        # Assert
        assert isinstance(result, CookieValidationResult)
        assert result.valid is False
        assert "500" in result.reason