#!/usr/bin/env python3
"""
Container Health Monitoring Test Script

Tests the container health monitoring system with automatic failure detection
and recovery mechanisms.
"""

import os
import sys
import asyncio
import time
import json
from pathlib import Path

# Add session-manager to path for imports
sys.path.insert(0, str(Path(__file__).parent))

from container_health import (
    ContainerHealthMonitor,
    ContainerStatus,
    HealthCheckResult,
    get_container_health_monitor,
    get_container_health_stats,
    get_container_health_history,
)

# Set up logging
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


async def test_health_monitor_initialization():
    """Test health monitor initialization and configuration."""
    print("🩺 Testing Health Monitor Initialization")
    print("=" * 50)

    monitor = ContainerHealthMonitor(
        check_interval=5,  # Faster for testing
        max_restart_attempts=2,
        failure_threshold=2,
    )

    # Test configuration
    assert monitor.check_interval == 5
    assert monitor.max_restart_attempts == 2
    assert monitor.failure_threshold == 2

    print("✅ Health monitor configured correctly")

    # Test stats before monitoring starts
    stats = monitor.get_health_stats()
    assert stats["monitoring_active"] == False
    assert stats["check_interval"] == 5

    print("✅ Health monitor stats available")

    return True


async def test_health_result_processing():
    """Test health check result processing and status determination."""
    print("\n📊 Testing Health Result Processing")
    print("=" * 50)

    monitor = ContainerHealthMonitor()

    # Test healthy result
    healthy_result = HealthCheckResult(
        session_id="test-session-1",
        container_id="container-123",
        status=ContainerStatus.HEALTHY,
        response_time=50.0,
        metadata={"docker_status": "running"},
    )

    await monitor._process_health_result(healthy_result)

    # Check history
    history = monitor.get_health_history("test-session-1")
    assert len(history) == 1
    assert history[0]["status"] == "healthy"
    print("✅ Healthy result processed correctly")

    # Test unhealthy result
    unhealthy_result = HealthCheckResult(
        session_id="test-session-1",
        container_id="container-123",
        status=ContainerStatus.UNHEALTHY,
        error_message="Health check failed",
        metadata={"docker_status": "running", "health_status": "unhealthy"},
    )

    await monitor._process_health_result(unhealthy_result)

    # Check history grew
    history = monitor.get_health_history("test-session-1")
    assert len(history) == 2
    print("✅ Unhealthy result processed correctly")

    # Test stats
    stats = monitor.get_health_stats("test-session-1")
    session_stats = stats.get("session_test-session-1", {})
    assert session_stats["total_checks"] == 2
    assert session_stats["healthy_checks"] == 1
    assert session_stats["failed_checks"] == 1

    print("✅ Health statistics calculated correctly")

    return True


async def test_failure_detection_and_restart():
    """Test failure detection and automatic restart logic."""
    print("\n🔄 Testing Failure Detection and Restart")
    print("=" * 50)

    monitor = ContainerHealthMonitor(
        check_interval=1, failure_threshold=2, max_restart_attempts=1
    )

    # Mock session manager and docker client
    class MockSessionManager:
        def __init__(self):
            self.sessions = {}
            self.restart_called = False

        async def get_session(self, session_id):
            return type("MockSession", (), {"session_id": session_id})()

        async def create_session(self):
            self.restart_called = True

    class MockDockerClient:
        pass

    mock_session_manager = MockSessionManager()
    mock_docker_client = MockDockerClient()

    monitor.set_dependencies(mock_session_manager, mock_docker_client)

    # Simulate consecutive failures
    session_id = "test-restart-session"
    container_id = "test-container-456"

    for i in range(3):
        failed_result = HealthCheckResult(
            session_id=session_id,
            container_id=container_id,
            status=ContainerStatus.UNHEALTHY,
            error_message=f"Failure {i + 1}",
        )
        await monitor._process_health_result(failed_result)

    # Check that restart was attempted
    await asyncio.sleep(0.1)  # Allow async operations to complete

    # Note: In the real implementation, restart would be triggered
    # For this test, we verify the failure detection logic
    stats = monitor.get_health_stats(session_id)
    session_stats = stats.get(f"session_{session_id}", {})
    assert session_stats["failed_checks"] >= 2

    print("✅ Failure detection working correctly")
    print("✅ Restart logic would trigger on consecutive failures")

    return True


async def test_history_cleanup():
    """Test automatic cleanup of old health check history."""
    print("\n🧹 Testing History Cleanup")
    print("=" * 50)

    monitor = ContainerHealthMonitor()

    # Add some old results (simulate by setting timestamps)
    session_id = "cleanup-test-session"

    # Add results with old timestamps
    import datetime

    old_time = datetime.datetime.utcnow() - datetime.timedelta(hours=2)

    for i in range(5):
        result = HealthCheckResult(
            session_id=session_id,
            container_id=f"container-{i}",
            status=ContainerStatus.HEALTHY,
        )
        # Manually set old timestamp
        result.timestamp = old_time
        monitor._health_history[session_id].append(result)

    # Verify results were added
    assert len(monitor._health_history[session_id]) == 5
    print("✅ Old history entries added")

    # Run cleanup
    await monitor._cleanup_old_history()

    # Results should be cleaned up (older than 1 hour)
    history = monitor._health_history.get(session_id, [])
    assert len(history) == 0
    print("✅ Old history cleaned up automatically")

    return True


async def test_monitoring_lifecycle():
    """Test starting and stopping the monitoring system."""
    print("\n🔄 Testing Monitoring Lifecycle")
    print("=" * 50)

    monitor = ContainerHealthMonitor(check_interval=1)

    # Test starting
    await monitor.start_monitoring()
    assert monitor._monitoring == True
    assert monitor._task is not None

    print("✅ Health monitoring started")

    # Let it run briefly
    await asyncio.sleep(0.1)

    # Test stopping
    await monitor.stop_monitoring()
    assert monitor._monitoring == False

    # Wait for task to complete
    if monitor._task:
        try:
            await asyncio.wait_for(monitor._task, timeout=1.0)
        except asyncio.TimeoutError:
            pass  # Expected if task was cancelled

    print("✅ Health monitoring stopped cleanly")

    return True


async def test_concurrent_health_checks():
    """Test handling multiple health checks concurrently."""
    print("\n⚡ Testing Concurrent Health Checks")
    print("=" * 50)

    monitor = ContainerHealthMonitor()

    # Create multiple mock sessions
    sessions = []
    for i in range(10):
        session = type(
            "MockSession",
            (),
            {
                "session_id": f"concurrent-session-{i}",
                "container_id": f"container-{i}",
                "status": "running",
            },
        )()
        sessions.append(session)

    # Mock the health check to return quickly
    original_check = monitor._check_container_health

    async def mock_check(session):
        await asyncio.sleep(0.01)  # Simulate quick check
        return HealthCheckResult(
            session_id=session.session_id,
            container_id=session.container_id,
            status=ContainerStatus.HEALTHY,
            response_time=10.0,
        )

    monitor._check_container_health = mock_check

    try:
        # Run concurrent health checks
        start_time = time.time()
        tasks = [monitor._check_container_health(session) for session in sessions]
        results = await asyncio.gather(*tasks)
        end_time = time.time()

        # Verify all results
        assert len(results) == 10
        for result in results:
            assert result.status == ContainerStatus.HEALTHY
            assert result.response_time == 10.0

        total_time = end_time - start_time
        print(f"✅ 10 concurrent health checks completed in {total_time:.3f}s")
        print("✅ Concurrent processing working correctly")

    finally:
        # Restore original method
        monitor._check_container_health = original_check

    return True


async def test_health_status_enums():
    """Test container status enum values and transitions."""
    print("\n🏷️  Testing Health Status Enums")
    print("=" * 50)

    # Test all status values
    statuses = [
        ContainerStatus.HEALTHY,
        ContainerStatus.UNHEALTHY,
        ContainerStatus.RESTARTING,
        ContainerStatus.FAILED,
        ContainerStatus.UNKNOWN,
    ]

    for status in statuses:
        assert isinstance(status.value, str)
        print(f"✅ Status {status.name}: {status.value}")

    # Test status transitions
    result = HealthCheckResult(
        session_id="enum-test",
        container_id="container-enum",
        status=ContainerStatus.HEALTHY,
    )

    assert result.status == ContainerStatus.HEALTHY
    assert result.to_dict()["status"] == "healthy"

    print("✅ Status enums and serialization working correctly")

    return True


async def run_all_health_tests():
    """Run all container health monitoring tests."""
    print("💓 Container Health Monitoring Test Suite")
    print("=" * 70)

    tests = [
        ("Health Monitor Initialization", test_health_monitor_initialization),
        ("Health Result Processing", test_health_result_processing),
        ("Failure Detection and Restart", test_failure_detection_and_restart),
        ("History Cleanup", test_history_cleanup),
        ("Monitoring Lifecycle", test_monitoring_lifecycle),
        ("Concurrent Health Checks", test_concurrent_health_checks),
        ("Health Status Enums", test_health_status_enums),
    ]

    results = []
    for test_name, test_func in tests:
        print(f"\n{'=' * 25} {test_name} {'=' * 25}")
        try:
            result = await test_func()
            results.append(result)
            status = "✅ PASSED" if result else "❌ FAILED"
            print(f"\n{status}: {test_name}")
        except Exception as e:
            print(f"\n❌ ERROR in {test_name}: {e}")
            import traceback

            traceback.print_exc()
            results.append(False)

    # Summary
    print(f"\n{'=' * 70}")
    passed = sum(results)
    total = len(results)
    print(f"📊 Test Results: {passed}/{total} tests passed")

    if passed == total:
        print("🎉 All container health monitoring tests completed successfully!")
        print("💓 Automatic failure detection and recovery is working correctly.")
    else:
        print("⚠️  Some tests failed. Check the output above for details.")
        print(
            "💡 Ensure all dependencies are installed and Docker is available for testing."
        )

    return passed == total


if __name__ == "__main__":
    asyncio.run(run_all_health_tests())