"""
Pruebas de streaming para NetFlux Backend.
Valida que los endpoints manejan correctamente los Range Requests y sirven fragmentos de video.
"""
import requests
import json
from typing import Dict, Any

class StreamingTests:
    def __init__(self, base_url: str = "http://localhost:8000"):
        self.base_url = base_url
        self.headers = {
            "Accept": "application/json",
            "User-Agent": "NetFlux-Test/1.0"
        }
    
    def test_health_endpoint(self) -> Dict[str, Any]:
        """Prueba el endpoint de salud."""
        response = requests.get(f"{self.base_url}/health", headers=self.headers)
        assert response.status_code == 200
        data = response.json()
        assert data["status"] == "healthy"
        return {"status": "passed", "message": "Endpoint de salud funciona correctamente"}
    
    def test_movie_details(self, movie_id: str) -> Dict[str, Any]:
        """Prueba el endpoint de detalles de película."""
        response = requests.get(f"{self.base_url}/movies/{movie_id}", headers=self.headers)
        if response.status_code == 200:
            data = response.json()
            assert "id" in data
            assert "title" in data
            return {"status": "passed", "message": f"Detalles de película {movie_id} obtenidos correctamente"}
        else:
            return {"status": "failed", "message": f"Error al obtener detalles: {response.status_code}"}
    
    def test_streaming_with_range_requests(self, movie_id: str) -> Dict[str, Any]:
        """Prueba el streaming con Range Requests."""
        # Obtener la ruta del stream
        response = requests.get(f"{self.base_url}/movies/{movie_id}/stream", headers=self.headers)
        if response.status_code == 200:
            data = response.json()
            assert "path" in data
            assert "headers" in data
            
            # Verificar que los headers incluyen Accept-Ranges
            assert data["headers"]["Accept-Ranges"] == "bytes"
            
            return {
                "status": "passed",
                "message": f"Streaming con Range Requests configurado correctamente para {movie_id}",
                "path": data["path"],
                "headers": data["headers"]
            }
        else:
            return {"status": "failed", "message": f"Error al obtener stream: {response.status_code}"}
    
    def test_range_request_fragment(self, movie_id: str) -> Dict[str, Any]:
        """Prueba la solicitud de fragmento con Range Request."""
        # Solicitar el primer 1024 bytes del archivo
        response = requests.get(
            f"{self.base_url}/movies/{movie_id}/stream/range",
            headers=self.headers,
            params={"range": "bytes=0-1023"}
        )
        
        if response.status_code == 206:  # Partial Content
            assert "Content-Range" in response.headers
            assert response.headers["Content-Range"] == f"bytes 0-1023/{response.headers['Content-Length']}"
            return {
                "status": "passed",
                "message": "Fragmento de video servido correctamente con Range Request",
                "content_range": response.headers["Content-Range"]
            }
        elif response.status_code == 404:
            return {"status": "failed", "message": "Archivo no encontrado"}
        else:
            return {"status": "failed", "message": f"Error inesperado: {response.status_code}"}
    
    def test_full_file_request(self, movie_id: str) -> Dict[str, Any]:
        """Prueba la solicitud del archivo completo."""
        response = requests.get(
            f"{self.base_url}/movies/{movie_id}/stream/range",
            headers=self.headers
        )
        
        if response.status_code == 200:
            assert "Content-Length" in response.headers
            return {
                "status": "passed",
                "message": "Archivo completo servido correctamente",
                "content_length": response.headers["Content-Length"]
            }
        else:
            return {"status": "failed", "message": f"Error al obtener archivo completo: {response.status_code}"}
    
    def run_all_tests(self, movie_id: str = "test_movie_1") -> Dict[str, Any]:
        """Ejecuta todas las pruebas."""
        tests = [
            self.test_health_endpoint,
            lambda: self.test_movie_details(movie_id),
            lambda: self.test_streaming_with_range_requests(movie_id),
            lambda: self.test_range_request_fragment(movie_id),
            lambda: self.test_full_file_request(movie_id)
        ]
        
        results = []
        for test in tests:
            try:
                result = test()
                results.append(result)
            except Exception as e:
                results.append({"status": "error", "message": str(e)})
        
        return {"tests": results}

if __name__ == "__main__":
    tests = StreamingTests()
    results = tests.run_all_tests("test_movie_1")
    print(json.dumps(results, indent=2))