#!/usr/bin/env python3
"""
Test Suite: Backend Failover (UVS-H31)
======================================
Tests multi-level backend cascading and failover behavior.

VERIFICATION_STAMP
Story: UVS-H31
Verified By: Claude Opus 4.5
Verified At: 2026-02-03
"""

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

sys.path.insert(0, '/mnt/e/genesis-system')

from core.browser_controller import (
    BrowserController,
    BrowserConfig,
    NavigationStatus,
    NavigationResult,
    BrowserLevel,
    PlaywrightBackend,
    HTTPClientBackend,
    ArchiveBackend
)


class TestBackendFailover:
    """Black box tests for backend failover behavior."""

    @pytest.fixture
    def controller(self):
        """Create a BrowserController for testing."""
        config = BrowserConfig(headless=True, max_retries=2)
        return BrowserController(config)

    @pytest.mark.asyncio
    async def test_primary_backend_success(self, controller):
        """When Playwright succeeds, no failover occurs."""
        with patch.object(PlaywrightBackend, 'is_available', return_value=True):
            with patch.object(PlaywrightBackend, 'initialize', return_value=True):
                with patch.object(PlaywrightBackend, 'navigate') as mock_nav:
                    mock_nav.return_value = NavigationResult(
                        url="https://example.com",
                        status=NavigationStatus.SUCCESS,
                        level_used=BrowserLevel.PLAYWRIGHT,
                        status_code=200
                    )

                    result = await controller.navigate("https://example.com")

                    assert result.status == NavigationStatus.SUCCESS
                    assert result.level_used == BrowserLevel.PLAYWRIGHT

    @pytest.mark.asyncio
    async def test_failover_to_http_client(self, controller):
        """When Playwright fails, fallback to HTTP client."""
        # Mock Playwright as unavailable
        with patch.object(PlaywrightBackend, 'is_available', return_value=False):
            with patch.object(HTTPClientBackend, 'is_available', return_value=True):
                with patch.object(HTTPClientBackend, 'initialize', return_value=True):
                    with patch.object(HTTPClientBackend, 'navigate') as mock_nav:
                        mock_nav.return_value = NavigationResult(
                            url="https://example.com",
                            status=NavigationStatus.SUCCESS,
                            level_used=BrowserLevel.HTTP_CLIENT,
                            status_code=200
                        )

                        result = await controller.navigate("https://example.com")

                        assert result.status == NavigationStatus.SUCCESS
                        assert result.level_used == BrowserLevel.HTTP_CLIENT

    @pytest.mark.asyncio
    async def test_failover_to_archive(self, controller):
        """When all primary backends fail, fallback to Wayback."""
        with patch.object(PlaywrightBackend, 'is_available', return_value=False):
            with patch.object(HTTPClientBackend, 'is_available', return_value=False):
                with patch.object(ArchiveBackend, 'is_available', return_value=True):
                    with patch.object(ArchiveBackend, 'initialize', return_value=True):
                        with patch.object(ArchiveBackend, 'navigate') as mock_nav:
                            mock_nav.return_value = NavigationResult(
                                url="https://example.com",
                                status=NavigationStatus.SUCCESS,
                                level_used=BrowserLevel.ARCHIVE,
                                status_code=200
                            )

                            result = await controller.navigate("https://example.com")

                            assert result.status == NavigationStatus.SUCCESS
                            assert result.level_used == BrowserLevel.ARCHIVE

    @pytest.mark.asyncio
    async def test_retry_with_exponential_backoff(self, controller):
        """Rate limited responses trigger exponential backoff."""
        call_count = 0

        async def mock_navigate(url):
            nonlocal call_count
            call_count += 1
            if call_count < 3:
                return NavigationResult(
                    url=url,
                    status=NavigationStatus.RATE_LIMITED,
                    level_used=BrowserLevel.PLAYWRIGHT,
                    status_code=429
                )
            return NavigationResult(
                url=url,
                status=NavigationStatus.SUCCESS,
                level_used=BrowserLevel.PLAYWRIGHT,
                status_code=200
            )

        with patch.object(PlaywrightBackend, 'is_available', return_value=True):
            with patch.object(PlaywrightBackend, 'initialize', return_value=True):
                with patch.object(PlaywrightBackend, 'navigate', side_effect=mock_navigate):
                    result = await controller.navigate("https://example.com")

                    # Should eventually succeed after retries
                    # (may fail if max_retries < 3)

    @pytest.mark.asyncio
    async def test_stats_accuracy_after_failover(self, controller):
        """Stats correctly track backend usage after failover."""
        # Reset stats
        controller._stats = {
            "total_navigations": 0,
            "successful_navigations": 0,
            "by_level": {level.name: 0 for level in BrowserLevel},
            "errors": 0,
            "retries": 0,
            "captchas_detected": 0
        }

        with patch.object(PlaywrightBackend, 'is_available', return_value=False):
            with patch.object(HTTPClientBackend, 'is_available', return_value=True):
                with patch.object(HTTPClientBackend, 'initialize', return_value=True):
                    with patch.object(HTTPClientBackend, 'navigate') as mock_nav:
                        mock_nav.return_value = NavigationResult(
                            url="https://example.com",
                            status=NavigationStatus.SUCCESS,
                            level_used=BrowserLevel.HTTP_CLIENT,
                            status_code=200
                        )

                        await controller.navigate("https://example.com")

                        stats = controller.get_stats()
                        assert stats["total_navigations"] == 1
                        assert stats["successful_navigations"] == 1
                        assert stats["by_level"]["HTTP_CLIENT"] == 1


class TestBackendFailoverWhiteBox:
    """White box tests for failover internals."""

    def test_backend_priority_order(self):
        """Backends are ordered by priority."""
        controller = BrowserController()

        levels = [b.level().value for b in controller._backends]
        assert levels == sorted(levels), "Backends not in priority order"

    def test_all_backends_have_required_methods(self):
        """All backends implement the required interface."""
        required_methods = [
            'name', 'level', 'is_available', 'initialize',
            'navigate', 'get_content', 'find_element',
            'click', 'type_text', 'screenshot', 'close'
        ]

        controller = BrowserController()

        for backend in controller._backends:
            for method in required_methods:
                assert hasattr(backend, method), f"{backend.name()} missing {method}"


if __name__ == '__main__':
    pytest.main([__file__, '-v', '--tb=short'])