"""
Tests for SLA & On-Call Management
"""
from django.test import TestCase
from django.contrib.auth import get_user_model
from django.utils import timezone
from datetime import datetime, timedelta, time
from unittest.mock import patch, MagicMock

from sla_oncall.models import (
    BusinessHours,
    SLADefinition,
    EscalationPolicy,
    OnCallRotation,
    OnCallAssignment,
    SLAInstance,
    EscalationInstance,
    NotificationTemplate,
)
from incident_intelligence.models import Incident

User = get_user_model()


class BusinessHoursModelTest(TestCase):
    """Test BusinessHours model functionality"""
    
    def setUp(self):
        self.business_hours = BusinessHours.objects.create(
            name='Test Business Hours',
            description='Test business hours',
            timezone='UTC',
            weekday_start=time(9, 0),
            weekday_end=time(17, 0),
            weekend_start=time(10, 0),
            weekend_end=time(16, 0),
        )
    
    def test_business_hours_creation(self):
        """Test business hours creation"""
        self.assertEqual(self.business_hours.name, 'Test Business Hours')
        self.assertEqual(self.business_hours.weekday_start, time(9, 0))
        self.assertTrue(self.business_hours.is_active)
    
    def test_is_business_hours_weekday(self):
        """Test business hours check for weekday"""
        # Monday 10 AM UTC
        test_time = timezone.make_aware(datetime(2024, 1, 8, 10, 0))
        self.assertTrue(self.business_hours.is_business_hours(test_time))
        
        # Monday 6 AM UTC (before business hours)
        test_time = timezone.make_aware(datetime(2024, 1, 8, 6, 0))
        self.assertFalse(self.business_hours.is_business_hours(test_time))


class SLADefinitionModelTest(TestCase):
    """Test SLADefinition model functionality"""
    
    def setUp(self):
        self.business_hours = BusinessHours.objects.create(
            name='Test Business Hours',
            description='Test business hours',
            timezone='UTC',
        )
        
        self.sla_definition = SLADefinition.objects.create(
            name='Test SLA',
            description='Test SLA definition',
            sla_type='RESPONSE_TIME',
            incident_severities=['HIGH', 'CRITICAL'],
            incident_categories=['SYSTEM'],
            target_duration_minutes=60,
            business_hours=self.business_hours,
        )
    
    def test_sla_definition_creation(self):
        """Test SLA definition creation"""
        self.assertEqual(self.sla_definition.name, 'Test SLA')
        self.assertEqual(self.sla_definition.target_duration_minutes, 60)
        self.assertEqual(self.sla_definition.escalation_threshold_percent, 80.0)


class OnCallRotationModelTest(TestCase):
    """Test OnCallRotation model functionality"""
    
    def setUp(self):
        self.user = User.objects.create_user(
            username='testuser',
            email='test@example.com',
            password='testpass123'
        )
        
        self.rotation = OnCallRotation.objects.create(
            name='Test Rotation',
            description='Test rotation',
            rotation_type='WEEKLY',
            team_name='Test Team',
        )
    
    def test_rotation_creation(self):
        """Test on-call rotation creation"""
        self.assertEqual(self.rotation.name, 'Test Rotation')
        self.assertEqual(self.rotation.rotation_type, 'WEEKLY')
        self.assertEqual(self.rotation.status, 'ACTIVE')


class SLAInstanceModelTest(TestCase):
    """Test SLAInstance model functionality"""
    
    def setUp(self):
        self.user = User.objects.create_user(
            username='testuser',
            email='test@example.com',
            password='testpass123'
        )
        
        self.incident = Incident.objects.create(
            title='Test Incident',
            description='Test incident description',
            severity='HIGH',
            category='SYSTEM',
            reporter=self.user,
        )
        
        self.sla_definition = SLADefinition.objects.create(
            name='Test SLA',
            description='Test SLA definition',
            sla_type='RESPONSE_TIME',
            target_duration_minutes=60,
        )
        
        self.sla_instance = SLAInstance.objects.create(
            sla_definition=self.sla_definition,
            incident=self.incident,
            target_time=timezone.now() + timedelta(minutes=60),
        )
    
    def test_sla_instance_creation(self):
        """Test SLA instance creation"""
        self.assertEqual(self.sla_instance.incident, self.incident)
        self.assertEqual(self.sla_instance.sla_definition, self.sla_definition)
        self.assertEqual(self.sla_instance.status, 'ACTIVE')
    
    def test_is_breached_property(self):
        """Test SLA breach detection"""
        # Active SLA with future target time
        self.assertFalse(self.sla_instance.is_breached)
        
        # Active SLA with past target time
        self.sla_instance.target_time = timezone.now() - timedelta(minutes=1)
        self.assertTrue(self.sla_instance.is_breached)