# quiz/models.py
from django.db import models
from users.models import CustomUser
from django.utils import timezone
import pandas as pd

class Country(models.Model):
    name = models.CharField(max_length=100, unique=True)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.name

class Category(models.Model):
    country = models.ForeignKey(Country, on_delete=models.CASCADE, related_name='categories')
    name = models.CharField(max_length=100)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        unique_together = ('country', 'name')

    def __str__(self):
        return f"{self.country.name} - {self.name}"

class QuestionAnswer(models.Model):
    country = models.ForeignKey(Country, on_delete=models.CASCADE)
    category = models.ForeignKey(Category, on_delete=models.CASCADE)
    question_text = models.TextField()
    option_a = models.CharField(max_length=200)
    option_b = models.CharField(max_length=200)
    option_c = models.CharField(max_length=200)
    option_d = models.CharField(max_length=200)
    correct_option = models.CharField(max_length=1, choices=[('A', 'A'), ('B', 'B'), ('C', 'C'), ('D', 'D')])
    created_at = models.DateTimeField(auto_now_add=True)
    difficulty = models.CharField(max_length=200)
    language = models.CharField(max_length=5, choices=[('en', 'English'), ('hi', 'Hindi')])

    def __str__(self):
        return f"{self.country.name} - {self.category.name} - {self.question_text[:50]}"

class UserQuizPerformance(models.Model):
    REASON_CHOICES = [
        ('quit', 'Quit'),
        ('completed', 'Completed'),
        ('timeout', 'Timeout'),
        ('wrong', 'Wrong'),
    ]
    
    user = models.ForeignKey(CustomUser, on_delete=models.CASCADE)
    country = models.ForeignKey(Country, on_delete=models.CASCADE)
    category = models.ForeignKey(Category, on_delete=models.CASCADE)
    country_name = models.CharField(max_length=100)
    category_name = models.CharField(max_length=100)
    reason = models.CharField(max_length=20, choices=REASON_CHOICES, default='quit')
    questions_answered = models.IntegerField(default=0)
    total_questions = models.IntegerField(default=0)
    correct_answers = models.IntegerField(default=0)
    average_score = models.FloatField(default=0.0)  # Percentage: (correct_answers / total_questions) * 100
    time_taken_seconds = models.IntegerField(default=0)
    current_question_time = models.IntegerField(default=0)
    current_question_index = models.IntegerField(default=0)
    used_lifelines = models.JSONField(default=list)  # Store as JSON array
    quiz_attempted_at = models.DateTimeField(auto_now_add=True)
    
    # Track best performance for this user-category combination
    best_score = models.FloatField(default=0.0)  # Best percentage score achieved
    best_time = models.IntegerField(default=0)  # Best time taken (lowest time for best performance)
    total_attempts = models.IntegerField(default=1)
    trophies = models.IntegerField(default=0)
    
    class Meta:
        unique_together = ('user', 'country', 'category')
        ordering = ['-quiz_attempted_at']

    def __str__(self):
        return f"{self.user.email} - {self.country_name} - {self.category_name} - Score: {self.average_score}%"

    def calculate_score_percentage(self):
        """Calculate score as percentage"""
        if self.total_questions > 0:
            return (self.correct_answers / self.total_questions) * 100
        return 0.0

    def update_best_performance(self):
        """Update best performance metrics when a new attempt is made"""
        current_score = self.calculate_score_percentage()
        
        # Update best score if current score is higher
        if current_score > self.best_score:
            self.best_score = current_score
        
        # Update best time if current score is better or equal to best score
        # and time is better (lower) than previous best time
        if (current_score >= self.best_score and 
            self.time_taken_seconds > 0 and 
            (self.best_time == 0 or self.time_taken_seconds < self.best_time)):
            self.best_time = self.time_taken_seconds
        
        self.total_attempts += 1
        self.save()

class Feedback(models.Model):
    country = models.ForeignKey(Country, on_delete=models.CASCADE)
    category = models.ForeignKey(Category, on_delete=models.CASCADE)
    question = models.ForeignKey(QuestionAnswer, on_delete=models.CASCADE)
    user_email = models.EmailField()
    description = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f"Feedback by {self.user_email} on {self.question}"