"""
Tests for RentCache server endpoints.
"""
import pytest
import pytest_asyncio
from httpx import AsyncClient
import hashlib
import json
from unittest.mock import patch, AsyncMock

from rentcache.models import APIKey


@pytest_asyncio.fixture
async def authenticated_client(test_client, test_session, sample_api_key_data):
    """Create an authenticated HTTP client."""
    # Create API key in database
    key_hash = hashlib.sha256(sample_api_key_data["rentcast_api_key"].encode()).hexdigest()
    
    api_key = APIKey(
        key_name=sample_api_key_data["key_name"],
        key_hash=key_hash,
        daily_limit=sample_api_key_data["daily_limit"],
        monthly_limit=sample_api_key_data["monthly_limit"],
        is_active=True
    )
    
    test_session.add(api_key)
    await test_session.commit()
    
    # Add auth header to client
    test_client.headers.update({
        "Authorization": f"Bearer {sample_api_key_data['rentcast_api_key']}"
    })
    
    return test_client


class TestHealthEndpoints:
    """Tests for health and system endpoints."""
    
    @pytest.mark.asyncio
    async def test_health_endpoint(self, test_client):
        """Test health check endpoint."""
        response = await test_client.get("/health")
        
        assert response.status_code == 200
        data = response.json()
        
        assert data["status"] == "healthy"
        assert "timestamp" in data
        assert "version" in data
        assert "database" in data
        assert "active_keys" in data
        assert "total_cache_entries" in data
    
    @pytest.mark.asyncio
    async def test_metrics_endpoint(self, test_client):
        """Test metrics endpoint."""
        response = await test_client.get("/metrics")
        
        assert response.status_code == 200
        data = response.json()
        
        required_fields = [
            "total_requests", "cache_hits", "cache_misses", 
            "cache_hit_ratio", "active_api_keys", "uptime_seconds"
        ]
        
        for field in required_fields:
            assert field in data


class TestAPIKeyManagement:
    """Tests for API key management endpoints."""
    
    @pytest.mark.asyncio
    async def test_create_api_key(self, test_client, sample_api_key_data):
        """Test API key creation."""
        response = await test_client.post(
            "/admin/api-keys",
            json=sample_api_key_data
        )
        
        assert response.status_code == 201
        data = response.json()
        
        assert data["key_name"] == sample_api_key_data["key_name"]
        assert data["daily_limit"] == sample_api_key_data["daily_limit"]
        assert data["monthly_limit"] == sample_api_key_data["monthly_limit"]
        assert data["is_active"] is True
    
    @pytest.mark.asyncio
    async def test_create_duplicate_api_key(self, test_client, test_session, sample_api_key_data):
        """Test creating duplicate API key fails."""
        # Create first key
        key_hash = hashlib.sha256(sample_api_key_data["rentcast_api_key"].encode()).hexdigest()
        
        existing_key = APIKey(
            key_name=sample_api_key_data["key_name"],
            key_hash=key_hash,
            daily_limit=1000,
            monthly_limit=10000
        )
        
        test_session.add(existing_key)
        await test_session.commit()
        
        # Try to create duplicate
        response = await test_client.post(
            "/admin/api-keys",
            json=sample_api_key_data
        )
        
        assert response.status_code == 400
        assert "already exists" in response.json()["detail"]


class TestRentcastProxyEndpoints:
    """Tests for Rentcast API proxy endpoints."""
    
    @pytest.mark.asyncio
    async def test_properties_endpoint_no_auth(self, test_client):
        """Test properties endpoint without authentication."""
        response = await test_client.get("/api/v1/properties")
        
        assert response.status_code == 401
        assert "Valid API key required" in response.json()["detail"]
    
    @pytest.mark.asyncio
    @patch('httpx.AsyncClient.get')
    async def test_properties_endpoint_success(self, mock_get, authenticated_client):
        """Test successful properties endpoint call."""
        # Mock Rentcast API response
        mock_response = AsyncMock()
        mock_response.status_code = 200
        mock_response.json.return_value = {
            "properties": [
                {
                    "id": "123",
                    "address": "123 Main St",
                    "city": "Austin",
                    "state": "TX"
                }
            ]
        }
        mock_response.headers = {"Content-Type": "application/json"}
        mock_response.content = b'{"properties": [{"id": "123"}]}'
        mock_response.raise_for_status = AsyncMock()
        mock_get.return_value = mock_response
        
        response = await authenticated_client.get(
            "/api/v1/properties?city=Austin&state=TX"
        )
        
        assert response.status_code == 200
        data = response.json()
        
        assert "properties" in data
        assert len(data["properties"]) == 1
        assert data["properties"][0]["id"] == "123"
        
        # Check cache headers
        assert "X-Cache-Hit" in response.headers
        assert response.headers["X-Cache-Hit"] == "False"  # First request
        assert "X-Response-Time-MS" in response.headers
    
    @pytest.mark.asyncio
    @patch('httpx.AsyncClient.get')
    async def test_properties_endpoint_cache_hit(self, mock_get, authenticated_client, test_session):
        """Test cache hit on second request."""
        # Mock Rentcast API response
        mock_response = AsyncMock()
        mock_response.status_code = 200
        mock_response.json.return_value = {"properties": [{"id": "123"}]}
        mock_response.headers = {"Content-Type": "application/json"}
        mock_response.content = b'{"properties": [{"id": "123"}]}'
        mock_response.raise_for_status = AsyncMock()
        mock_get.return_value = mock_response
        
        # First request (cache miss)
        response1 = await authenticated_client.get("/api/v1/properties?city=Austin")
        assert response1.status_code == 200
        assert response1.headers["X-Cache-Hit"] == "False"
        
        # Second request (should be cache hit)
        response2 = await authenticated_client.get("/api/v1/properties?city=Austin")
        assert response2.status_code == 200
        assert response2.headers["X-Cache-Hit"] == "True"
        
        # Should have called Rentcast API only once
        assert mock_get.call_count == 1
    
    @pytest.mark.asyncio
    @patch('httpx.AsyncClient.get')
    async def test_value_estimate_endpoint(self, mock_get, authenticated_client):
        """Test value estimate endpoint."""
        # Mock Rentcast API response
        mock_response = AsyncMock()
        mock_response.status_code = 200
        mock_response.json.return_value = {
            "estimate": {
                "value": 450000,
                "confidence": "high",
                "address": "123 Main St"
            }
        }
        mock_response.headers = {"Content-Type": "application/json"}
        mock_response.content = b'{"estimate": {"value": 450000}}'
        mock_response.raise_for_status = AsyncMock()
        mock_get.return_value = mock_response
        
        response = await authenticated_client.get(
            "/api/v1/estimates/value?address=123 Main St&city=Austin&state=TX"
        )
        
        assert response.status_code == 200
        data = response.json()
        
        assert "estimate" in data
        assert data["estimate"]["value"] == 450000
        assert "X-Estimated-Cost" in response.headers
    
    @pytest.mark.asyncio
    async def test_force_refresh_parameter(self, authenticated_client):
        """Test force refresh parameter bypasses cache."""
        # This would need more complex mocking to test properly
        # For now, just test that the parameter is accepted
        response = await authenticated_client.get(
            "/api/v1/properties?city=Austin&force_refresh=true"
        )
        
        # Will fail due to no mock, but parameter should be accepted
        # In a real test, we'd mock the upstream call
        pass


class TestRateLimiting:
    """Tests for rate limiting functionality."""
    
    @pytest.mark.asyncio
    async def test_rate_limit_headers(self, test_client):
        """Test that rate limit headers are present."""
        # Make multiple requests to trigger rate limiting
        responses = []
        for i in range(5):
            response = await test_client.get("/metrics")
            responses.append(response)
        
        # Should eventually hit rate limit
        # Note: This test might need adjustment based on actual rate limits
        assert any(r.status_code == 429 for r in responses[-2:])
    
    @pytest.mark.asyncio
    async def test_api_key_usage_tracking(self, authenticated_client, test_session):
        """Test that API key usage is tracked."""
        # Make a request
        with patch('httpx.AsyncClient.get') as mock_get:
            mock_response = AsyncMock()
            mock_response.status_code = 200
            mock_response.json.return_value = {"test": "data"}
            mock_response.headers = {}
            mock_response.content = b'{"test": "data"}'
            mock_response.raise_for_status = AsyncMock()
            mock_get.return_value = mock_response
            
            response = await authenticated_client.get("/api/v1/properties")
            assert response.status_code == 200
        
        # Check that usage was recorded
        # This would require querying the database to verify
        # usage stats were created


class TestCacheManagement:
    """Tests for cache management endpoints."""
    
    @pytest.mark.asyncio
    async def test_clear_cache_endpoint(self, test_client):
        """Test cache clearing endpoint."""
        response = await test_client.post(
            "/admin/cache/clear",
            json={"endpoint": "properties"}
        )
        
        assert response.status_code == 200
        data = response.json()
        
        assert "message" in data
        assert "cleared" in data["message"].lower()
    
    @pytest.mark.asyncio
    async def test_clear_all_cache(self, test_client):
        """Test clearing all cache entries."""
        response = await test_client.post(
            "/admin/cache/clear",
            json={}
        )
        
        assert response.status_code == 200


class TestErrorHandling:
    """Tests for error handling."""
    
    @pytest.mark.asyncio
    @patch('httpx.AsyncClient.get')
    async def test_upstream_api_error(self, mock_get, authenticated_client):
        """Test handling of upstream API errors."""
        # Mock Rentcast API error
        from httpx import HTTPStatusError, Request, Response
        
        mock_response = Response(
            status_code=404,
            content=b'{"error": "Not found"}',
            request=Request("GET", "http://test.com")
        )
        
        mock_get.side_effect = HTTPStatusError(
            message="Not found",
            request=mock_response.request,
            response=mock_response
        )
        
        response = await authenticated_client.get("/api/v1/properties?city=NonExistent")
        
        assert response.status_code == 404
        assert "Upstream API error" in response.json()["detail"]
    
    @pytest.mark.asyncio
    async def test_invalid_parameters(self, authenticated_client):
        """Test validation of invalid parameters."""
        # Test negative limit
        response = await authenticated_client.get("/api/v1/properties?limit=-1")
        
        assert response.status_code == 422  # Validation error
        
        # Test limit too large
        response = await authenticated_client.get("/api/v1/properties?limit=10000")
        
        assert response.status_code == 422