"""
Role-Specific Staff Views
Separate dashboards for each role: Accountant, Marketing, Content, etc.
"""
from django.shortcuts import render, redirect
from django.http import JsonResponse
from django.contrib.auth.decorators import login_required
from django.contrib import messages
from django.db.models import Sum, Count, Avg
from django.utils import timezone
from datetime import timedelta
from decimal import Decimal

from products.models import Product
from orders.models import Order
from accounts.models import User
from ai_features.ai_controller import AIController
import tempfile
import os
try:
    from moviepy.editor import VideoFileClip
except Exception:
    VideoFileClip = None


def role_required(allowed_roles):
    """Decorator to check if user has required role"""
    def decorator(view_func):
        def wrapper(request, *args, **kwargs):
            if request.user.role not in allowed_roles:
                messages.error(request, 'You do not have permission to access this page.')
                return redirect('staff:dashboard')
            return view_func(request, *args, **kwargs)
        return wrapper
    return decorator


@login_required
@role_required(['ADMIN', 'ACCOUNTANT'])
def accountant_dashboard(request):
    """
    Accountant Dashboard - Financial Controls
    """
    # Date range
    days = int(request.GET.get('days', 30))
    start_date = timezone.now() - timedelta(days=days)
    
    # Financial data
    orders = Order.objects.filter(created_at__gte=start_date)
    paid_orders = orders.filter(is_paid=True)
    
    total_revenue = paid_orders.aggregate(total=Sum('total'))['total'] or Decimal('0')
    total_pending = orders.filter(is_paid=False).aggregate(total=Sum('total'))['total'] or Decimal('0')
    total_refunds = orders.filter(status='REFUNDED').aggregate(total=Sum('total'))['total'] or Decimal('0')
    
    # Payment method breakdown
    payment_breakdown = paid_orders.values('payment_method').annotate(
        count=Count('id'),
        total=Sum('total')
    )
    
    # Daily revenue for chart
    daily_revenue = []
    for i in range(days):
        date = timezone.now().date() - timedelta(days=days-i-1)
        day_revenue = paid_orders.filter(created_at__date=date).aggregate(
            total=Sum('total')
        )['total'] or 0
        daily_revenue.append({
            'date': date.strftime('%m/%d'),
            'revenue': float(day_revenue)
        })
    
    # AI Financial Analysis (requires ai_controller install)
    ai_analysis = None
    # if request.GET.get('analyze'):
    #     ai_analysis = financial_analyzer.analyze_revenue_trends(orders)
    
    context = {
        'total_revenue': total_revenue,
        'total_pending': total_pending,
        'total_refunds': total_refunds,
        'total_orders': orders.count(),
        'paid_orders': paid_orders.count(),
        'avg_order_value': total_revenue / paid_orders.count() if paid_orders.count() > 0 else 0,
        'payment_breakdown': payment_breakdown,
        'daily_revenue': daily_revenue,
        'ai_analysis': ai_analysis,
        'days': days,
    }
    
    return render(request, 'staff/accountant_dashboard.html', context)


@login_required
@role_required(['ADMIN', 'MARKETING'])
def marketing_dashboard(request):
    """
    Marketing Dashboard - Campaigns & Analytics
    """
    # Customer statistics
    total_customers = User.objects.filter(role='CUSTOMER').count()
    verified_customers = User.objects.filter(role='CUSTOMER', email_verified=True).count()
    
    # Campaign management
    if request.method == 'POST':
        # Launch campaign
        campaign_type = request.POST.get('campaign_type')
        
        if campaign_type == 'promotional_email':
            target_users = User.objects.filter(
                role='CUSTOMER',
                email_verified=True
            )
            
            campaign_data = {
                'name': request.POST.get('campaign_name'),
                'email_subject': request.POST.get('email_subject'),
                'email_template': 'emails/promotional.html',
                'target_users': target_users,
                'context': {
                    'message': request.POST.get('email_message'),
                }
            }
            
            # results = communication_controller.send_promotional_campaign(campaign_data)  # Requires AI controller
            messages.success(request, "Campaign feature requires AI controller setup")
        
        elif campaign_type == 'bulk_sms':
            target_users = User.objects.filter(
                role='CUSTOMER',
                phone_verified=True
            ).exclude(phone__isnull=True)
            
            phones = [user.phone for user in target_users]
            sms_message = request.POST.get('sms_message')
            
            # results = communication_controller.send_bulk_sms(phones, sms_message)  # Requires AI controller
            # sent_count = sum(1 for r in results.values() if r == 'sent')
            messages.success(request, "SMS feature requires AI controller and Twilio setup")
    
    context = {
        'total_customers': total_customers,
        'verified_customers': verified_customers,
        'active_rate': (verified_customers / total_customers * 100) if total_customers > 0 else 0,
    }
    
    return render(request, 'staff/marketing_dashboard.html', context)


@login_required
@role_required(['ADMIN', 'CONTENT_MANAGER'])
def content_dashboard(request):
    """
    Content Manager Dashboard - AI-powered content
    """
    if request.method == 'POST':
        action = request.POST.get('action')
        
        if action == 'generate_description':
            product_name = request.POST.get('product_name')
            features = request.POST.get('features')
            
            # description = ai_controller.generate_product_description(product_name, features)  # Requires AI
            description = "AI content generation requires ai_controller setup"
            
            context = {
                'generated_description': description,
                'product_name': product_name,
            }
            return render(request, 'staff/content_dashboard.html', context)
        
        elif action == 'auto_categorize':
            product_name = request.POST.get('product_name')
            description = request.POST.get('description')
            
            # category = ai_controller.auto_categorize_product(product_name, description)  # Requires AI
            category = "General"
            
            context = {
                'suggested_category': category,
                'product_name': product_name,
            }
            return render(request, 'staff/content_dashboard.html', context)
    
    # Get products needing descriptions
    products_needing_content = Product.objects.filter(
        description__isnull=True
    ) | Product.objects.filter(description='')
    
    context = {
        'products_needing_content': products_needing_content.count(),
    }
    
    return render(request, 'staff/content_dashboard.html', context)


@login_required
def ai_voice_chat(request):
    """
    AI Voice Chat Interface
    """
    config = AIConfiguration.get_settings()
    if not getattr(config, 'enable_chat', True):
        if request.method == 'POST':
            return JsonResponse({'error': 'AI Chat is disabled'}, status=403)
        messages.error(request, 'AI Chat is disabled by administrator.')
        return redirect('staff:dashboard')
    ai_controller = AIController()
    if request.method == 'POST':
        if request.FILES.get('audio'):
            # Voice to text
            audio_file = request.FILES['audio']
            text = ai_controller.voice_to_text(audio_file)
            
            if text:
                # Get AI response
                response = ai_controller.chat_response(text)
                
                # Convert response to voice
                audio_response = ai_controller.text_to_voice(response)
                
                return JsonResponse({
                    'text': text,
                    'response': response,
                    'audio_url': None
                })
            return JsonResponse({'error': 'Could not process audio'}, status=400)
        
        if request.FILES.get('video'):
            video_file = request.FILES['video']
            if not VideoFileClip:
                return JsonResponse({'error': 'Video processing not enabled'}, status=400)
            try:
                with tempfile.TemporaryDirectory() as tmpdir:
                    video_path = os.path.join(tmpdir, 'input_video')
                    with open(video_path, 'wb') as f:
                        for chunk in video_file.chunks():
                            f.write(chunk)
                    clip = VideoFileClip(video_path)
                    audio_out = os.path.join(tmpdir, 'audio.wav')
                    clip.audio.write_audiofile(audio_out, verbose=False, logger=None)
                    text = ai_controller.voice_to_text(audio_out)
                    if text:
                        response = ai_controller.chat_response(text)
                        return JsonResponse({'text': text, 'response': response})
                    return JsonResponse({'error': 'Could not extract speech from video'}, status=400)
            except Exception:
                return JsonResponse({'error': 'Video processing failed'}, status=400)
        
        if request.POST.get('message'):
            # Text chat
            message = request.POST.get('message')
            response = ai_controller.chat_response(message)
            
            return JsonResponse({
                'response': response
            })
    
    return render(request, 'staff/ai_chat.html')


@login_required
def verification_center(request):
    """
    Email & Phone Verification Management
    """
    if request.method == 'POST':
        action = request.POST.get('action')
        
        if action == 'send_email_verification':
            email = request.POST.get('email')
            # Generate code and send
            import random
            code = str(random.randint(100000, 999999))
            
            user = User.objects.get(email=email)
            # communication_controller.send_verification_email(email, code, user.get_full_name())  # Requires AI controller
            
            messages.success(request, f'Verification email sent to {email}')
        
        elif action == 'send_sms_verification':
            phone = request.POST.get('phone')
            # Generate code and send
            import random
            code = str(random.randint(100000, 999999))
            
            # communication_controller.send_verification_sms(phone, code)  # Requires AI controller
            
            messages.success(request, f'Verification SMS sent to {phone}')
    
    #  Statistics
    total_users =User.objects.filter(role='CUSTOMER').count()
    email_verified = User.objects.filter(email_verified=True).count()
    phone_verified = User.objects.filter(phone_verified=True).count()
    
    context = {
        'total_users': total_users,
        'email_verified': email_verified,
        'phone_verified': phone_verified,
        'email_verification_rate': (email_verified / total_users * 100) if total_users > 0 else 0,
        'phone_verification_rate': (phone_verified / total_users * 100) if total_users > 0 else 0,
    }
    
    return render(request, 'staff/verification_center.html', context)