import time 
import redis
from django.db import connection
from django.conf import settings
from django.utils import timezone
from django.contrib import messages
from django.core.cache import cache
from django.http import JsonResponse
from django.db.models import Count, Q
from datetime import datetime, timedelta
from django.shortcuts import render, redirect
from django.contrib.auth.decorators import login_required


from apps.campaigns.models import Campaign
from apps.advertisers.models import Advertiser
from apps.channels.models import Channel
from apps.playlists.models import Playlist
from apps.core.models import ActivityLog


@login_required
def dashboard(request):
    """Main dashboard view with statistics and charts."""
    # Get date range for statistics (last 30 days)
    end_date = timezone.now()
    start_date = end_date - timedelta(days=30)
    
    # Basic statistics
    stats = {
        'total_campaigns': Campaign.objects.filter(is_deleted=False).count(),
        'active_campaigns': Campaign.objects.filter(
            is_deleted=False, 
            status='active',
            start_date__lte=end_date,
            end_date__gte=start_date
        ).count(),
        'total_advertisers': Advertiser.objects.filter(is_deleted=False).count(),
        'total_channels': Channel.objects.filter(is_deleted=False).count(),
        'total_playlists': Playlist.objects.filter(is_deleted=False).count(),
        'total_impressions': 0,  # TODO: Implement when impressions tracking is added
        'total_revenue': 0,  # TODO: Implement when revenue tracking is added
        'channels_growth': 5.2,  # Mock data for now
        'campaigns_change': -2.1,  # Mock data for now
        'impressions_growth': 12.5,  # Mock data for now
        'revenue_growth': 8.3,  # Mock data for now
    }
    
    # Recent activities
    recent_activities = ActivityLog.objects.select_related('user').order_by('-created_at')[:10]
    
    # Campaign status distribution
    campaign_status = Campaign.objects.filter(is_deleted=False).aggregate(
        active=Count('id', filter=Q(status='active')),
        inactive=Count('id', filter=~Q(status='active')),
    )
    
    # Recent campaigns with mock impression and revenue data
    recent_campaigns = Campaign.objects.filter(
        is_deleted=False
    ).select_related('advertiser').order_by('-created_at')[:5]
    
    # Add mock data to campaigns
    for campaign in recent_campaigns:
        campaign.impressions_count = 0  # TODO: Implement actual impressions tracking
        campaign.revenue = 0  # TODO: Implement actual revenue tracking
    
    # Top performing channels with mock data
    top_channels = Channel.objects.filter(is_deleted=False)[:5]
    for channel in top_channels:
        channel.impressions_count = 0  # TODO: Implement actual impressions tracking
        channel.revenue = 0  # TODO: Implement actual revenue tracking
        channel.performance = 75  # Mock performance percentage
    
    # Chart data for impressions (mock data for now)
    chart_data = {
        'impressions': [120, 150, 180, 200, 175, 220, 250],
        'dates': ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
    }
    
    context = {
        'stats': stats,
        'recent_activities': recent_activities,
        'activity_logs': recent_activities,  # Alias for template compatibility
        'campaign_status': campaign_status,
        'recent_campaigns': recent_campaigns,
        'top_channels': top_channels,
        'chart_data': chart_data,
    }
    
    return render(request, 'core/dashboard.html', context)


def landing_page(request):
    """Public landing page that doesn't require authentication."""
    if request.user.is_authenticated:
        return redirect('core:dashboard')
    
    context = {
        'app_name': 'Adtlas',
        'app_description': 'Dynamic Ad Insertion (DAI) Management System',
        'version': '2.0.0',
    }
    
    return render(request, 'core/landing.html', context)


@login_required
def dashboard_stats_api(request):
    """API endpoint for dashboard statistics."""
    # Get date range from request
    days = int(request.GET.get('days', 30))
    end_date = timezone.now()
    start_date = end_date - timedelta(days=days)
    
    # Campaign statistics over time
    campaigns_data = []
    for i in range(days):
        date = start_date + timedelta(days=i)
        count = Campaign.objects.filter(
            created_at__date=date.date(),
            is_deleted=False
        ).count()
        campaigns_data.append({
            'date': date.strftime('%Y-%m-%d'),
            'count': count
        })
    
    # Advertiser distribution
    advertiser_data = list(
        Advertiser.objects.filter(is_deleted=False)
        .annotate(campaign_count=Count('campaigns'))
        .values('name', 'campaign_count')
        .order_by('-campaign_count')[:10]
    )
    
    return JsonResponse({
        'campaigns_over_time': campaigns_data,
        'advertiser_distribution': advertiser_data,
    })


@login_required
def activity_logs(request):
    """View for displaying activity logs."""
    logs = ActivityLog.objects.select_related('user').order_by('-created_at')
    
    # Filter by action if provided
    action_filter = request.GET.get('action')
    if action_filter:
        logs = logs.filter(action=action_filter)
    
    # Filter by user if provided
    user_filter = request.GET.get('user')
    if user_filter:
        logs = logs.filter(user_id=user_filter)
    
    # Pagination
    from django.core.paginator import Paginator
    paginator = Paginator(logs, 50)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    
    context = {
        'page_obj': page_obj,
        'action_choices': ActivityLog.ACTION_CHOICES,
    }
    
    return render(request, 'core/activity_logs.html', context)


def health_check_v1(request):
    """Health check endpoint for monitoring."""
    try:
        # Check database connection 
        with connection.cursor() as cursor:
            cursor.execute("SELECT 1")
        
        # Check Redis connection (if using Celery)
        try:
            from django_redis import get_redis_connection
            redis_conn = get_redis_connection("default")
            redis_conn.ping()
            redis_status = "OK"
        except Exception:
            redis_status = "ERROR"
        
        return JsonResponse({
            'status': 'OK',
            'timestamp': timezone.now().isoformat(),
            'database': 'OK',
            'redis': redis_status,
        })
    except Exception as e:
        return JsonResponse({
            'status': 'ERROR',
            'error': str(e),
            'timestamp': timezone.now().isoformat(),
        }, status=500)


def health_check_v2(request):
    """Comprehensive health check endpoint"""
    health_status = {
        'status': 'healthy',
        'timestamp': datetime.now().isoformat(),
        'version': getattr(settings, 'VERSION', '1.0.0'),
        'checks': {}
    }
    
    overall_healthy = True
    
    # Database health check
    try:
        start_time = time.time()
        with connection.cursor() as cursor:
            cursor.execute("SELECT 1")
            cursor.fetchone()
        db_response_time = round((time.time() - start_time) * 1000, 2)
        
        health_status['checks']['database'] = {
            'status': 'healthy',
            'response_time_ms': db_response_time
        }
    except Exception as e:
        health_status['checks']['database'] = {
            'status': 'unhealthy',
            'error': str(e)
        }
        overall_healthy = False
    
    # Redis health check
    try:
        start_time = time.time()
        cache.set('health_check', 'ok', 10)
        cache.get('health_check')
        redis_response_time = round((time.time() - start_time) * 1000, 2)
        
        health_status['checks']['redis'] = {
            'status': 'healthy',
            'response_time_ms': redis_response_time
        }
    except Exception as e:
        health_status['checks']['redis'] = {
            'status': 'unhealthy',
            'error': str(e)
        }
        overall_healthy = False
    
    # Celery health check (optional)
    try:
        from celery import current_app
        inspect = current_app.control.inspect()
        stats = inspect.stats()
        
        if stats:
            health_status['checks']['celery'] = {
                'status': 'healthy',
                'workers': len(stats)
            }
        else:
            health_status['checks']['celery'] = {
                'status': 'unhealthy',
                'error': 'No workers available'
            }
            overall_healthy = False
    except Exception as e:
        health_status['checks']['celery'] = {
            'status': 'unhealthy',
            'error': str(e)
        }
        # Don't mark overall as unhealthy for Celery issues
    
    # Set overall status
    if not overall_healthy:
        health_status['status'] = 'unhealthy'
    
    # Return appropriate HTTP status code
    status_code = 200 if overall_healthy else 503
    
    return JsonResponse(health_status, status=status_code)


def readiness_check(request):
    """Readiness check for Kubernetes/container orchestration"""
    try:
        # Check if database is ready
        with connection.cursor() as cursor:
            cursor.execute("SELECT 1")
            cursor.fetchone()
        
        # Check if Redis is ready
        cache.set('readiness_check', 'ok', 10)
        cache.get('readiness_check')
        
        return JsonResponse({'status': 'ready'}, status=200)
    except Exception as e:
        return JsonResponse({
            'status': 'not_ready',
            'error': str(e)
        }, status=503)


def liveness_check(request):
    """Liveness check for Kubernetes/container orchestration"""
    return JsonResponse({
        'status': 'alive',
        'timestamp': datetime.now().isoformat()
    }, status=200)