from celery import shared_task
from django.utils import timezone
from datetime import datetime, timedelta
from .models import UserPattern, ScheduledNotification, BurnoutAnalysis, BurnoutNotification
from .push_service import PushNotificationService
import logging

logger = logging.getLogger(__name__)

@shared_task
def schedule_daily_notifications():
    """Schedule all notifications for the day at midnight"""
    try:
        logger.info("Starting daily notification scheduling")
        
        # Get all users with patterns
        user_ids = UserPattern.objects.values_list('user_id', flat=True).distinct()
        
        scheduled_count = 0
        for user_id in user_ids:
            count = schedule_user_notifications_for_today(user_id)
            scheduled_count += count
        
        logger.info(f"Scheduled {scheduled_count} notifications for {len(user_ids)} users")
        
        return {
            'status': 'success',
            'notifications_scheduled': scheduled_count,
            'users_processed': len(user_ids),
            'timestamp': timezone.now().isoformat()
        }
        
    except Exception as e:
        logger.error(f"Error in schedule_daily_notifications: {e}")
        return {
            'status': 'error',
            'error': str(e),
            'timestamp': timezone.now().isoformat()
        }

def schedule_user_notifications_for_today(user_id):
    """Schedule notifications for specific user"""
    try:
        patterns = UserPattern.objects.filter(user_id=user_id)
        scheduled_count = 0
        
        for pattern in patterns:
            # Calculate exact notification time (15 minutes before typical time)
            typical_time = pattern.average_time
            notification_time = PushNotificationService().subtract_minutes(typical_time, 15)
            
            # Schedule for today
            today = timezone.now().date()
            notification_datetime = datetime.combine(today, notification_time)
            
            # Only schedule if time hasn't passed today
            if notification_datetime > timezone.now():
                # Check if already scheduled
                existing = ScheduledNotification.objects.filter(
                    user_id=user_id,
                    question_type=pattern.question_type,
                    scheduled_time=notification_datetime,
                    is_sent=False
                ).exists()
                
                if not existing:
                    # Schedule the notification
                    task = send_notification_at_exact_time.apply_async(
                        args=[str(user_id), pattern.question_type],
                        eta=notification_datetime
                    )
                    
                    # Store the scheduled notification
                    ScheduledNotification.objects.create(
                        user_id=user_id,
                        question_type=pattern.question_type,
                        scheduled_time=notification_datetime,
                        celery_task_id=task.id
                    )
                    
                    scheduled_count += 1
                    logger.info(f"Scheduled notification for user {user_id}, {pattern.question_type} at {notification_datetime}")
        
        return scheduled_count
        
    except Exception as e:
        logger.error(f"Error scheduling notifications for user {user_id}: {e}")
        return 0

@shared_task
def send_notification_at_exact_time(user_id, question_type):
    """Send notification at exact scheduled time"""
    try:
        push_service = PushNotificationService()
        
        # Get pattern data
        pattern = UserPattern.objects.get(
            user_id=user_id,
            question_type=question_type
        )
        
        # Check if user still needs notification
        if not push_service.user_already_did_action(user_id, question_type):
            # Send notification
            typical_time_str = pattern.average_time.strftime('%H:%M')
            success = push_service.send_smart_reminder(user_id, question_type, typical_time_str)
            
            # Update scheduled notification record
            ScheduledNotification.objects.filter(
                user_id=user_id,
                question_type=question_type,
                scheduled_time__date=timezone.now().date(),
                is_sent=False
            ).update(
                is_sent=True,
                sent_at=timezone.now()
            )
            
            if success:
                logger.info(f"Successfully sent notification to user {user_id} for {question_type}")
                return {
                    'status': 'success',
                    'user_id': user_id,
                    'question_type': question_type,
                    'sent_at': timezone.now().isoformat()
                }
            else:
                logger.error(f"Failed to send notification to user {user_id} for {question_type}")
                return {
                    'status': 'failed',
                    'user_id': user_id,
                    'question_type': question_type,
                    'error': 'Push notification failed'
                }
        else:
            logger.info(f"Skipped notification for user {user_id} - already completed {question_type}")
            return {
                'status': 'skipped',
                'reason': 'User already completed action',
                'user_id': user_id,
                'question_type': question_type
            }
            
    except UserPattern.DoesNotExist:
        logger.error(f"Pattern not found for user {user_id}, question_type {question_type}")
        return {
            'status': 'error',
            'error': 'Pattern not found',
            'user_id': user_id,
            'question_type': question_type
        }
    except Exception as e:
        logger.error(f"Error in send_notification_at_exact_time: {e}")
        return {
            'status': 'error',
            'error': str(e),
            'user_id': user_id,
            'question_type': question_type
        }

@shared_task
def cleanup_old_scheduled_notifications():
    """Clean up old scheduled notifications"""
    try:
        # Delete scheduled notifications older than 7 days
        cutoff_date = timezone.now() - timedelta(days=7)
        
        old_notifications = ScheduledNotification.objects.filter(
            created_at__lt=cutoff_date
        )
        
        count = old_notifications.count()
        old_notifications.delete()
        
        logger.info(f"Cleaned up {count} old scheduled notifications")
        
        return {
            'status': 'success',
            'deleted_count': count,
            'timestamp': timezone.now().isoformat()
        }
        
    except Exception as e:
        logger.error(f"Error in cleanup_old_scheduled_notifications: {e}")
        return {
            'status': 'error',
            'error': str(e),
            'timestamp': timezone.now().isoformat()
        }

# Legacy tasks for backward compatibility
@shared_task
def analyze_user_patterns_task(user_id: str):
    """Legacy task - kept for backward compatibility"""
    try:
        from .services import MLService
        ml_service = MLService()
        results = ml_service.analyze_user_patterns(user_id)
        
        return {
            'status': 'success',
            'user_id': user_id,
            'patterns_learned': len(results.get('patterns', {})),
            'timestamp': timezone.now().isoformat()
        }
        
    except Exception as e:
        logger.error(f"Error in analyze_user_patterns_task: {e}")
        return {
            'status': 'error',
            'user_id': user_id,
            'error': str(e),
            'timestamp': timezone.now().isoformat()
        }

@shared_task
def analyze_burnout_daily():
    """Analyze all users for burnout risk daily"""
    try:
        from .burnout_detector import BurnoutDetector
        
        logger.info("Starting daily burnout analysis")
        
        # Get all active users with settings enabled
        from user.models import User
        from userSettings.models import UserSettings
        
        users = User.objects.filter(is_active=True)
        analyzed_count = 0
        
        for user in users:
            try:
                settings = UserSettings.objects.get(user=user)
                if not settings.burnout_notifications_enabled:
                    continue
            except UserSettings.DoesNotExist:
                continue
            
            # Analyze user
            detector = BurnoutDetector(str(user.id))
            analysis = detector.analyze_user(days=30)
            
            if analysis:
                # Store analysis
                BurnoutAnalysis.objects.create(
                    user_id=user.id,
                    date=timezone.now().date(),
                    risk_score=analysis['risk_score'],
                    severity=analysis['severity'],
                    risk_factors=analysis['risk_factors'],
                    recommendations=analysis['recommendations'],
                )
                
                # Send notification if risk is medium or high
                if analysis['severity'] in ['medium', 'high', 'critical']:
                    send_burnout_notification.delay(str(user.id), analysis)
                
                analyzed_count += 1
        
        logger.info(f"Analyzed {analyzed_count} users for burnout")
        
        return {
            'status': 'success',
            'users_analyzed': analyzed_count,
            'timestamp': timezone.now().isoformat()
        }
        
    except Exception as e:
        logger.error(f"Error in analyze_burnout_daily: {e}")
        return {
            'status': 'error',
            'error': str(e),
            'timestamp': timezone.now().isoformat()
        }

@shared_task
def send_burnout_notification(user_id, analysis):
    """Send burnout notification to user"""
    try:
        from django.utils import timezone
        from .push_service import PushNotificationService
        
        # Generate notification content
        if analysis['severity'] == 'critical':
            title = "⚠️ High Burnout Risk Detected"
            body = f"Your work patterns show {analysis['risk_score']}/100 burnout risk. Take action immediately."
        elif analysis['severity'] == 'high':
            title = "⚠️ Consider Taking a Break"
            body = f"Your recent work patterns suggest high burnout risk. Consider using available balances."
        else:
            title = "ℹ️ Burnout Alert"
            body = f"Burnout risk detected: {analysis['risk_score']}/100. Monitor your work patterns."
        
        # Get recommendations
        recommendations = analysis.get('recommendations', [])
        if recommendations:
            body += f"\n\n💡 Suggestion: {recommendations[0]['action']}"
        
        # Create notification record
        notification = BurnoutNotification.objects.create(
            user_id=user_id,
            notification_type='burnout_alert',
            title=title,
            message=body,
            risk_score=analysis['risk_score'],
            recommendation=recommendations[0] if recommendations else {},
        )
        
        # Send push notification
        push_service = PushNotificationService()
        fcm_token = UserPattern.objects.filter(user_id=user_id).first()
        
        if fcm_token:
            from .models import UserFCMToken
            token_obj = UserFCMToken.objects.filter(user_id=user_id, is_active=True).first()
            if token_obj:
                push_service.send_notification(
                    user_id,
                    title=title,
                    body=body,
                    data={
                        'type': 'burnout_alert',
                        'risk_score': str(analysis['risk_score']),
                        'notification_id': str(notification.id),
                        'notification_type': 'burnout'
                    }
                )
        
        logger.info(f"Sent burnout notification to user {user_id}")
        
        return {
            'status': 'success',
            'user_id': user_id,
            'risk_score': analysis['risk_score'],
            'timestamp': timezone.now().isoformat()
        }
        
    except Exception as e:
        logger.error(f"Error in send_burnout_notification: {e}")
        return {
            'status': 'error',
            'error': str(e),
            'timestamp': timezone.now().isoformat()
        }