"""
Tests for analytics functionality (logging, Prometheus, PostHog)
"""

import pytest
import os
import json
from unittest.mock import patch, MagicMock, call
from flask import g
from app import create_app, log_event, track_event


@pytest.fixture
def app():
    """Create test Flask application and initialize DB tables."""
    app = create_app({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///:memory:'})
    from app import db
    with app.app_context():
        db.create_all()
    try:
        yield app
    finally:
        try:
            with app.app_context():
                db.drop_all()
        except Exception:
            pass


@pytest.fixture
def client(app):
    """Create test client"""
    return app.test_client()


class TestLogEvent:
    """Tests for structured JSON logging"""
    
    def test_log_event_basic(self, app):
        """Test basic log event"""
        with app.app_context():
            with app.test_request_context():
                g.request_id = 'test-request-123'
                # This should not raise an exception
                log_event("test.event", user_id=1, test_data="value")
    
    def test_log_event_without_request_context(self, app):
        """Test that log_event handles missing request context gracefully"""
        with app.app_context():
            # Should not raise an exception even without request context
            log_event("test.event", user_id=1)
    
    def test_log_event_with_extra_data(self, app):
        """Test log event with various data types"""
        with app.app_context():
            with app.test_request_context():
                g.request_id = 'test-request-456'
                log_event("test.event",
                         user_id=1,
                         project_id=42,
                         duration=3600,
                         success=True,
                         tags=['tag1', 'tag2'])


class TestTrackEvent:
    """Tests for PostHog event tracking"""
    
    @patch('app.posthog.capture')
    def test_track_event_when_enabled(self, mock_capture, app):
        """Test that PostHog events are tracked when API key is set"""
        with patch.dict(os.environ, {'POSTHOG_API_KEY': 'test-key'}):
            track_event(123, "test.event", {"property": "value"})
            # Verify the event was tracked
            assert mock_capture.called
            call_args = mock_capture.call_args
            assert call_args[1]['distinct_id'] == '123'
            assert call_args[1]['event'] == 'test.event'
            # Verify our property is included (along with context properties)
            assert call_args[1]['properties']['property'] == 'value'
    
    @patch('app.posthog.capture')
    def test_track_event_when_disabled(self, mock_capture, app):
        """Test that PostHog events are not tracked when API key is not set"""
        with patch.dict(os.environ, {'POSTHOG_API_KEY': ''}):
            track_event(123, "test.event", {"property": "value"})
            mock_capture.assert_not_called()
    
    @patch('app.posthog.capture')
    def test_track_event_handles_errors_gracefully(self, mock_capture, app):
        """Test that tracking errors don't crash the application"""
        mock_capture.side_effect = Exception("PostHog error")
        with patch.dict(os.environ, {'POSTHOG_API_KEY': 'test-key'}):
            # Should not raise an exception
            track_event(123, "test.event", {})
    
    def test_track_event_with_none_properties(self, app):
        """Test that track_event handles None properties"""
        with patch.dict(os.environ, {'POSTHOG_API_KEY': 'test-key'}):
            with patch('app.posthog.capture') as mock_capture:
                track_event(123, "test.event", None)
                # Should have context properties even when None is passed
                call_args = mock_capture.call_args
                # Properties should be a dict (not None) with at least context properties
                assert isinstance(call_args[1]['properties'], dict)
                # Context properties should be present
                assert 'environment' in call_args[1]['properties']


class TestPrometheusMetrics:
    """Tests for Prometheus metrics"""
    
    def test_metrics_endpoint_exists(self, client):
        """Test that /metrics endpoint exists"""
        response = client.get('/metrics')
        assert response.status_code == 200
        assert response.content_type == 'text/plain; version=0.0.4; charset=utf-8'
    
    def test_metrics_endpoint_format(self, client):
        """Test that /metrics returns Prometheus format"""
        response = client.get('/metrics')
        data = response.data.decode('utf-8')
        
        # Should contain our custom metrics
        assert 'tt_requests_total' in data
        assert 'tt_request_latency_seconds' in data
    
    def test_metrics_are_incremented(self, client):
        """Test that metrics are incremented on requests"""
        # Make a request to trigger metric recording
        response = client.get('/metrics')
        assert response.status_code == 200
        
        # Get metrics
        response = client.get('/metrics')
        data = response.data.decode('utf-8')
        
        # Should have recorded requests
        assert 'tt_requests_total' in data


class TestAnalyticsIntegration:
    """Integration tests for analytics in routes"""
    
    @patch('app.routes.auth.log_event')
    @patch('app.routes.auth.track_event')
    def test_login_analytics(self, mock_track, mock_log, authenticated_client):
        """Test that login events are tracked"""
        # Use authenticated client to verify analytics are initialized
        # The actual login tracking is tested via the mocks being available
        response = authenticated_client.get('/dashboard')
        
        # Verify response is successful (analytics don't break the app)
        assert response.status_code == 200
        
        # Note: This test primarily verifies analytics hooks don't break the login flow
    
    @patch('app.routes.timer.log_event')
    @patch('app.routes.timer.track_event')
    def test_timer_analytics_integration(self, mock_track, mock_log, app, client):
        """Test that timer events are tracked (integration test placeholder)"""
        # This is a placeholder - actual implementation would require:
        # 1. Authenticated session
        # 2. Valid project
        # 3. Timer start/stop operations
        pass


class TestSentryIntegration:
    """Tests for Sentry error monitoring"""
    
    @patch('app.sentry_sdk.init')
    def test_sentry_initializes_when_dsn_set(self, mock_init):
        """Test that Sentry initializes when DSN is provided"""
        with patch.dict(os.environ, {
            'SENTRY_DSN': 'https://test@sentry.io/123',
            'SENTRY_TRACES_RATE': '0.1',
            'FLASK_ENV': 'production'
        }):
            app = create_app({'TESTING': True})
            # Sentry should have been initialized
            # Note: The actual initialization happens in create_app
    
    def test_sentry_not_initialized_without_dsn(self):
        """Test that Sentry is not initialized when DSN is not set"""
        with patch.dict(os.environ, {'SENTRY_DSN': ''}, clear=True):
            with patch('app.sentry_sdk.init') as mock_init:
                app = create_app({'TESTING': True})
                # Sentry init should not be called
                mock_init.assert_not_called()


class TestRequestIDAttachment:
    """Tests for request ID attachment"""
    
    def test_request_id_attached(self, app, client):
        """Test that request ID is attached to requests"""
        with app.app_context():
            with app.test_request_context():
                # Trigger the before_request hook
                with client:
                    response = client.get('/metrics')
                    # Request ID should be set in g
                    # Note: This test might need adjustment based on context handling


class TestAnalyticsEventSchema:
    """Tests to ensure analytics events follow the documented schema"""
    
    def test_event_naming_convention(self):
        """Test that event names follow resource.action pattern"""
        valid_events = [
            "auth.login",
            "auth.logout",
            "timer.started",
            "timer.stopped",
            "project.created",
            "project.updated",
            "export.csv",
            "report.viewed"
        ]
        
        for event_name in valid_events:
            parts = event_name.split('.')
            assert len(parts) == 2, f"Event {event_name} should follow resource.action pattern"
            assert parts[0].isalpha(), f"Resource part should be alphabetic: {event_name}"
            assert parts[1].replace('_', '').isalpha(), f"Action part should be alphabetic: {event_name}"


class TestAnalyticsPrivacy:
    """Tests to ensure analytics respect privacy guidelines"""
    
    def test_no_pii_in_standard_events(self, app):
        """Test that standard events don't include PII"""
        # Events should use IDs, not emails or usernames
        with app.app_context():
            with app.test_request_context():
                g.request_id = 'test-123'
                
                # This is acceptable (uses ID)
                log_event("test.event", user_id=123)
                
                # In production, events should NOT include:
                # - email addresses
                # - usernames (use IDs instead)
                # - IP addresses (unless explicitly needed)
                # - passwords or tokens
    
    @patch('app.posthog.capture')
    def test_posthog_uses_internal_ids(self, mock_capture, app):
        """Test that PostHog events use internal IDs, not PII"""
        with patch.dict(os.environ, {'POSTHOG_API_KEY': 'test-key'}):
            # Should use numeric ID, not email
            track_event(123, "test.event", {"project_id": 456})
            
            call_args = mock_capture.call_args
            # distinct_id should be the internal user ID (converted to string)
            assert call_args[1]['distinct_id'] == '123'


class TestAnalyticsPerformance:
    """Tests to ensure analytics don't impact performance"""
    
    def test_analytics_dont_block_requests(self, client):
        """Test that analytics operations don't significantly delay requests"""
        import time
        
        start = time.time()
        response = client.get('/metrics')
        duration = time.time() - start
        
        # Request should complete quickly even with analytics
        assert duration < 1.0  # Should complete in less than 1 second
        assert response.status_code == 200
    
    @patch('app.posthog.capture')
    def test_analytics_errors_dont_break_app(self, mock_capture, app, client):
        """Test that analytics failures don't break the application"""
        mock_capture.side_effect = Exception("Analytics service down")
        
        # Application should still work
        response = client.get('/metrics')
        assert response.status_code == 200