from django.shortcuts import render
from django.http import JsonResponse
from django.views.generic import View
from django.contrib.auth.mixins import LoginRequiredMixin
from django.db.models import Count, Q
from django.utils import timezone
from datetime import datetime, timedelta
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status

from apps.analytics.models import AdbreakHistory, SfrAnalytics, VastResponseGo, RealtimeAdbreak
from apps.campaigns.models import Campaign, AdSpot
from apps.channels.models import Channel



class AnalyticsDashboardView(LoginRequiredMixin, View):
    """Main analytics dashboard"""
    
    def get(self, request):
        # Get basic stats for the dashboard
        today = timezone.now().date()
        week_ago = today - timedelta(days=7)
        
        context = {
            'total_campaigns': Campaign.objects.filter(status='active').count(),
            'total_channels': Channel.objects.count(),
            'total_adspots': AdSpot.objects.count(),
            'recent_adbreaks': AdbreakHistory.objects.filter(
                datetime__date__gte=week_ago
            ).count(),
        }
        
        return render(request, 'analytics/dashboard.html', context)


class ImpressionAnalyticsView(LoginRequiredMixin, View):
    """Impression analytics and reporting"""
    
    def get(self, request):
        start_date = request.GET.get('start_date')
        end_date = request.GET.get('end_date')
        campaign_id = request.GET.get('campaign_id')
        
        queryset = VastResponseGo.objects.all()
        
        if start_date:
            queryset = queryset.filter(datetime_timestamp__date__gte=start_date)
        if end_date:
            queryset = queryset.filter(datetime_timestamp__date__lte=end_date)
        if campaign_id:
            queryset = queryset.filter(campaign_id=campaign_id)
        
        # Calculate impression stats
        stats = {
            'total_requests': queryset.count(),
            'successful_impressions': queryset.filter(
                impression_status='success'
            ).count(),
            'completion_rate': queryset.filter(
                tracking_completed_status='completed'
            ).count(),
        }
        
        # Group by campaign
        campaign_stats = queryset.values('campaign__name').annotate(
            total=Count('id'),
            completed=Count('id', filter=Q(tracking_completed_status='completed'))
        )
        
        context = {
            'stats': stats,
            'campaign_stats': campaign_stats,
            'campaigns': Campaign.objects.filter(status='active'),
        }
        
        return render(request, 'analytics/impressions.html', context)


class SfrAnalyticsView(LoginRequiredMixin, View):
    """SFR market share analytics"""
    
    def get(self, request):
        analytics_data = SfrAnalytics.objects.all().order_by('-created_at')[:100]
        
        context = {
            'analytics_data': analytics_data,
        }
        
        return render(request, 'analytics/sfr_analytics.html', context)


class RealtimeAdbreakAPIView(APIView):
    """API endpoint for real-time ad break notifications"""
    
    def post(self, request):
        channel_id = request.data.get('channel_id')
        start_at = request.data.get('start_at')
        duration = request.data.get('duration')
        message = request.data.get('message', '')
        
        try:
            channel = Channel.objects.get(id=channel_id)
            
            # Create real-time ad break record
            adbreak = RealtimeAdbreak.objects.create(
                channel=channel,
                start_at=datetime.fromisoformat(start_at),
                duration=duration,
                message=message
            )
            
            # Also create history record
            AdbreakHistory.objects.create(
                channel=channel,
                datetime=datetime.fromisoformat(start_at),
                day=datetime.fromisoformat(start_at).strftime('%Y-%m-%d'),
                time=datetime.fromisoformat(start_at).strftime('%H:%M:%S'),
                duration=duration
            )
            
            return Response({
                'status': 'success',
                'adbreak_id': adbreak.id
            }, status=status.HTTP_201_CREATED)
            
        except Channel.DoesNotExist:
            return Response({
                'error': 'Channel not found'
            }, status=status.HTTP_404_NOT_FOUND)
        except Exception as e:
            return Response({
                'error': str(e)
            }, status=status.HTTP_400_BAD_REQUEST)


class ChartDataAPIView(APIView):
    """API endpoint for chart data"""
    
    def get(self, request):
        chart_type = request.GET.get('type', 'impressions')
        days = int(request.GET.get('days', 7))
        
        end_date = timezone.now().date()
        start_date = end_date - timedelta(days=days)
        
        if chart_type == 'impressions':
            data = self._get_impression_chart_data(start_date, end_date)
        elif chart_type == 'adbreaks':
            data = self._get_adbreak_chart_data(start_date, end_date)
        elif chart_type == 'campaigns':
            data = self._get_campaign_chart_data(start_date, end_date)
        else:
            data = {'error': 'Invalid chart type'}
        
        return Response(data)
    
    def _get_impression_chart_data(self, start_date, end_date):
        """Get impression data for charts"""
        impressions = VastResponseGo.objects.filter(
            datetime_timestamp__date__range=[start_date, end_date]
        ).extra(
            select={'day': 'DATE(datetime_timestamp)'}
        ).values('day').annotate(
            total=Count('id'),
            completed=Count('id', filter=Q(tracking_completed_status='completed'))
        ).order_by('day')
        
        return {
            'labels': [item['day'] for item in impressions],
            'datasets': [
                {
                    'label': 'Total Impressions',
                    'data': [item['total'] for item in impressions],
                    'backgroundColor': 'rgba(54, 162, 235, 0.2)',
                    'borderColor': 'rgba(54, 162, 235, 1)',
                },
                {
                    'label': 'Completed Views',
                    'data': [item['completed'] for item in impressions],
                    'backgroundColor': 'rgba(75, 192, 192, 0.2)',
                    'borderColor': 'rgba(75, 192, 192, 1)',
                }
            ]
        }
    
    def _get_adbreak_chart_data(self, start_date, end_date):
        """Get ad break data for charts"""
        adbreaks = AdbreakHistory.objects.filter(
            datetime__date__range=[start_date, end_date]
        ).extra(
            select={'day': 'DATE(datetime)'}
        ).values('day').annotate(
            total=Count('id')
        ).order_by('day')
        
        return {
            'labels': [item['day'] for item in adbreaks],
            'datasets': [{
                'label': 'Ad Breaks',
                'data': [item['total'] for item in adbreaks],
                'backgroundColor': 'rgba(255, 99, 132, 0.2)',
                'borderColor': 'rgba(255, 99, 132, 1)',
            }]
        }
    
    def _get_campaign_chart_data(self, start_date, end_date):
        """Get campaign performance data"""
        campaigns = VastResponseGo.objects.filter(
            datetime_timestamp__date__range=[start_date, end_date]
        ).values('campaign__name').annotate(
            total=Count('id'),
            completed=Count('id', filter=Q(tracking_completed_status='completed'))
        ).order_by('-total')[:10]
        
        return {
            'labels': [item['campaign__name'] or 'Unknown' for item in campaigns],
            'datasets': [
                {
                    'label': 'Total Impressions',
                    'data': [item['total'] for item in campaigns],
                    'backgroundColor': 'rgba(153, 102, 255, 0.2)',
                    'borderColor': 'rgba(153, 102, 255, 1)',
                },
                {
                    'label': 'Completed Views',
                    'data': [item['completed'] for item in campaigns],
                    'backgroundColor': 'rgba(255, 159, 64, 0.2)',
                    'borderColor': 'rgba(255, 159, 64, 1)',
                }
            ]
        }