from django.db import models
from django.contrib.auth import get_user_model
from customers.models import Customer

User = get_user_model()

class Ticket(models.Model):
    PRIORITY_CHOICES = [
        ('low', 'Low'),
        ('medium', 'Medium'),
        ('high', 'High'),
        ('urgent', 'Urgent'),
    ]

    STATUS_CHOICES = [
        ('open', 'Open'),
        ('in_progress', 'In Progress'),
        ('resolved', 'Resolved'),
        ('closed', 'Closed'),
        ('scheduled', 'Scheduled'),
        ('postponed', 'Postponed'),
    ]

    CATEGORY_CHOICES = [
        ('technical', 'Technical Issue'),
        ('billing', 'Billing Issue'),
        ('installation', 'Installation Request'),
        ('maintenance', 'Maintenance'),
        ('complaint', 'Complaint'),
        ('reminder', 'Reminder/Follow-up'),
        ('enquiry', 'Customer Enquiry'),
        ('site_visit', 'Site Visit'),
        ('other', 'Other'),
    ]

    TICKET_TYPE_CHOICES = [
        ('task', 'Task/Work Order'),
        ('reminder', 'Reminder'),
        ('event', 'Event'),
        ('appointment', 'Appointment'),
    ]

    ticket_id = models.CharField(max_length=20, unique=True, editable=False)
    title = models.CharField(max_length=200)
    description = models.TextField()
    customer = models.ForeignKey(Customer, on_delete=models.CASCADE, related_name='tickets', null=True, blank=True, help_text="Optional - leave blank for infrastructure/company tickets")
    created_by = models.ForeignKey(User, on_delete=models.CASCADE, related_name='created_tickets', default=1)
    assigned_to = models.ForeignKey(User, on_delete=models.SET_NULL, null=True, blank=True, related_name='assigned_tickets')
    assigned_employee = models.ForeignKey('hr.Employee', on_delete=models.SET_NULL, null=True, blank=True, related_name='assigned_tickets', help_text="Assign to specific employee")

    priority = models.CharField(max_length=10, choices=PRIORITY_CHOICES, default='medium')
    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='open')
    category = models.CharField(max_length=20, choices=CATEGORY_CHOICES, default='technical')
    ticket_type = models.CharField(max_length=20, choices=TICKET_TYPE_CHOICES, default='task', help_text="Type of ticket/event")
    
    # Customer contact information for reminders/enquiries
    contact_phone = models.CharField(max_length=15, blank=True, help_text="Contact phone for this event")
    contact_email = models.EmailField(blank=True, help_text="Contact email for this event")
    
    # Location information
    location = models.CharField(max_length=200, blank=True, help_text="Location for this task/event")
    
    # Reminder settings
    is_reminder = models.BooleanField(default=False, help_text="Is this a reminder/follow-up?")
    reminder_before = models.DurationField(null=True, blank=True, help_text="Send reminder before scheduled time")
    reminder_sent = models.BooleanField(default=False, help_text="Has reminder been sent?")

    # Scheduling fields
    scheduled_date = models.DateTimeField(null=True, blank=True, help_text="When this task should be performed")
    scheduled_end_date = models.DateTimeField(null=True, blank=True, help_text="When this task should end (optional)")
    estimated_duration = models.DurationField(null=True, blank=True, help_text="Estimated time to complete")
    actual_duration = models.DurationField(null=True, blank=True, help_text="Actual time taken to complete")
    is_scheduled = models.BooleanField(default=False, help_text="Is this a scheduled task?")
    is_all_day = models.BooleanField(default=False, help_text="Is this an all-day event?")
    work_started_at = models.DateTimeField(null=True, blank=True, help_text="When work actually started")
    completed_at = models.DateTimeField(null=True, blank=True, help_text="When work was completed")
    
    # Recurring event fields
    is_recurring = models.BooleanField(default=False, help_text="Is this a recurring event?")
    recurrence_pattern = models.CharField(max_length=50, blank=True, choices=[
        ('daily', 'Daily'),
        ('weekly', 'Weekly'),
        ('monthly', 'Monthly'),
        ('yearly', 'Yearly'),
    ], help_text="How often this event repeats")
    recurrence_end_date = models.DateField(null=True, blank=True, help_text="When recurring events should stop")
    
    # Notes and special instructions
    special_instructions = models.TextField(blank=True, help_text="Special instructions or notes for this task/event")
    requires_customer_confirmation = models.BooleanField(default=False, help_text="Does this require customer confirmation?")
    customer_confirmed = models.BooleanField(default=False, help_text="Has customer confirmed this appointment?")
    
    # Timestamps
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    resolved_at = models.DateTimeField(null=True, blank=True)

    def save(self, *args, **kwargs):
        if not self.ticket_id:
            # Generate unique ticket ID with TKT prefix
            last_ticket = Ticket.objects.filter(ticket_id__startswith='TKT').order_by('-ticket_id').first()
            if last_ticket:
                last_number = int(last_ticket.ticket_id[3:])
                new_number = last_number + 1
            else:
                new_number = 1
            self.ticket_id = f"TKT{new_number:03d}"
        super().save(*args, **kwargs)

    @property
    def assigned_person(self):
        """Return the assigned person (employee or user)"""
        if self.assigned_employee:
            return self.assigned_employee.full_name
        elif self.assigned_to:
            return self.assigned_to.get_full_name() or self.assigned_to.username
        return "Unassigned"
    
    @property
    def assigned_person_id(self):
        """Return the assigned person ID for display"""
        if self.assigned_employee:
            return self.assigned_employee.employee_id
        elif self.assigned_to:
            return self.assigned_to.username
        return None
    
    @property
    def scheduled_end_time(self):
        """Calculate scheduled end time based on start time and estimated duration"""
        if self.scheduled_end_date:
            return self.scheduled_end_date
        elif self.scheduled_date and self.estimated_duration:
            return self.scheduled_date + self.estimated_duration
        return None
    
    @property
    def is_past_due(self):
        """Check if scheduled task is past due"""
        if self.scheduled_date and self.status not in ['resolved', 'closed']:
            from django.utils import timezone
            return timezone.now() > self.scheduled_date
        return False
    
    @property
    def is_today(self):
        """Check if task is scheduled for today"""
        if self.scheduled_date:
            from django.utils import timezone
            return self.scheduled_date.date() == timezone.now().date()
        return False
    
    @property
    def customer_name(self):
        """Return customer name or indicate it's a company ticket"""
        if self.customer:
            return self.customer.full_name
        return "Company/Infrastructure"

    def __str__(self):
        return f"{self.ticket_id} - {self.title}"

    class Meta:
        ordering = ['-created_at']
        permissions = [
            ('can_view_calendar', 'Can view calendar and scheduling'),
            ('can_edit_schedule', 'Can edit and manage schedules'),
            ('can_view_all_schedules', 'Can view all technician schedules'),
            ('can_assign_tickets', 'Can assign tickets to technicians'),
        ]

class TicketComment(models.Model):
    ticket = models.ForeignKey(Ticket, on_delete=models.CASCADE, related_name='comments')
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    comment = models.TextField()
    is_internal = models.BooleanField(default=False, help_text="Internal notes only visible to staff")
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f"Comment on {self.ticket.ticket_id} by {self.user.username}"

    class Meta:
        ordering = ['created_at']

class TicketAttachment(models.Model):
    ticket = models.ForeignKey(Ticket, on_delete=models.CASCADE, related_name='attachments')
    uploaded_by = models.ForeignKey(User, on_delete=models.CASCADE)
    file = models.FileField(upload_to='tickets/attachments/')
    description = models.CharField(max_length=200, blank=True)
    uploaded_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f"Attachment for {self.ticket.ticket_id}"

    @property
    def file_size(self):
        """Return file size in human readable format"""
        if self.file:
            size = self.file.size
            for unit in ['B', 'KB', 'MB', 'GB']:
                if size < 1024:
                    return f"{size:.1f} {unit}"
                size /= 1024
            return f"{size:.1f} TB"
        return "Unknown"

    @property
    def is_image(self):
        """Check if the file is an image"""
        if self.file:
            return self.file.name.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp'))
        return False

    class Meta:
        ordering = ['-uploaded_at']