"""
Tests for django_cronjob_utils models.
"""
from datetime import date, timedelta
from django.test import TestCase
from django.utils import timezone
from django_cronjob_utils.models import CronExecution


class CronExecutionModelTests(TestCase):
    """Tests for CronExecution model."""
    
    def test_create_execution(self):
        """Test creating an execution record."""
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15),
            completed=False,
            success=False
        )
        
        self.assertIsNotNone(execution.id)
        self.assertEqual(execution.task_code, 'A001')
        self.assertEqual(execution.task_name, 'Test Task')
        self.assertEqual(execution.execution_date, date(2024, 1, 15))
        self.assertFalse(execution.completed)
        self.assertFalse(execution.success)
        self.assertEqual(execution.retry_count, 0)
        self.assertIsNotNone(execution.started)
    
    def test_execution_defaults(self):
        """Test execution record default values."""
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15)
        )
        
        self.assertFalse(execution.completed)
        self.assertFalse(execution.success)
        self.assertEqual(execution.retry_count, 0)
        self.assertEqual(execution.message, '')
        self.assertEqual(execution.error_code, '')
        self.assertIsNone(execution.ended)
    
    def test_execution_string_representation(self):
        """Test execution string representation."""
        # Pending execution
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15),
            completed=False
        )
        self.assertIn('→', str(execution))
        self.assertIn('Test Task', str(execution))
        self.assertIn('A001', str(execution))
        
        # Successful execution
        execution.mark_completed(success=True, message='Success')
        self.assertIn('✓', str(execution))
        
        # Failed execution
        execution2 = CronExecution.objects.create(
            task_code='A002',
            task_name='Failed Task',
            execution_date=date(2024, 1, 15),
            completed=True,
            success=False
        )
        self.assertIn('✗', str(execution2))
    
    def test_duration_property_completed(self):
        """Test duration calculation for completed execution."""
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15)
        )
        
        # Set started time
        started_time = timezone.now() - timedelta(seconds=100)
        execution.started = started_time
        execution.save()
        
        # Mark as completed
        execution.mark_completed(success=True)
        
        duration = execution.duration
        self.assertIsNotNone(duration)
        self.assertGreaterEqual(duration, 100)
        self.assertLess(duration, 110)  # Allow small margin
    
    def test_duration_property_running(self):
        """Test duration calculation for running execution."""
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15),
            completed=False
        )
        
        # Set started time
        started_time = timezone.now() - timedelta(seconds=50)
        execution.started = started_time
        execution.save()
        
        duration = execution.duration
        self.assertIsNotNone(duration)
        self.assertGreaterEqual(duration, 50)
        self.assertLess(duration, 60)  # Allow small margin
    
    def test_duration_property_no_started(self):
        """Test duration calculation when started is None (edge case).
        
        Note: Since started has auto_now_add=True, it cannot actually be None.
        This test verifies that the duration property handles the theoretical
        case where started might be None (though it shouldn't happen in practice).
        """
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15)
        )
        
        # Since started has auto_now_add=True, it will always have a value
        # The duration property already handles None cases, but this scenario
        # cannot occur with the current model definition
        # We verify that started is always set
        self.assertIsNotNone(execution.started)
        
        # Verify duration works correctly with valid started time
        duration = execution.duration
        self.assertIsNotNone(duration)
        self.assertGreaterEqual(duration, 0)
    
    def test_mark_completed_success(self):
        """Test marking execution as completed successfully."""
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15)
        )
        
        execution.mark_completed(success=True, message='Task completed', error_code='')
        
        execution.refresh_from_db()
        self.assertTrue(execution.completed)
        self.assertTrue(execution.success)
        self.assertEqual(execution.message, 'Task completed')
        self.assertEqual(execution.error_code, '')
        self.assertIsNotNone(execution.ended)
    
    def test_mark_completed_failure(self):
        """Test marking execution as completed with failure."""
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15)
        )
        
        execution.mark_completed(success=False, message='Task failed', error_code='ERROR_001')
        
        execution.refresh_from_db()
        self.assertTrue(execution.completed)
        self.assertFalse(execution.success)
        self.assertEqual(execution.message, 'Task failed')
        self.assertEqual(execution.error_code, 'ERROR_001')
        self.assertIsNotNone(execution.ended)
    
    def test_mark_completed_partial_update(self):
        """Test marking completed with partial message/error_code."""
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15),
            message='Original message',
            error_code='ORIGINAL_ERROR'
        )
        
        # Only update success, keep original message
        execution.mark_completed(success=True, message='', error_code='')
        
        execution.refresh_from_db()
        self.assertTrue(execution.completed)
        self.assertTrue(execution.success)
        # Message should remain unchanged if empty string passed
        self.assertEqual(execution.message, '')  # Empty string overwrites
    
    def test_mark_failed(self):
        """Test mark_failed convenience method."""
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15)
        )
        
        execution.mark_failed(message='Failed', error_code='FAIL')
        
        execution.refresh_from_db()
        self.assertTrue(execution.completed)
        self.assertFalse(execution.success)
        self.assertEqual(execution.message, 'Failed')
        self.assertEqual(execution.error_code, 'FAIL')
    
    def test_increment_retry(self):
        """Test incrementing retry count."""
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15),
            retry_count=0
        )
        
        execution.increment_retry()
        execution.refresh_from_db()
        self.assertEqual(execution.retry_count, 1)
        
        execution.increment_retry()
        execution.refresh_from_db()
        self.assertEqual(execution.retry_count, 2)
    
    def test_increment_retry_multiple_times(self):
        """Test incrementing retry count multiple times."""
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15),
            retry_count=0
        )
        
        for i in range(5):
            execution.increment_retry()
            execution.refresh_from_db()
            self.assertEqual(execution.retry_count, i + 1)
    
    def test_pid_field(self):
        """Test PID field for timeout handling."""
        import os
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15),
            pid=os.getpid()
        )
        
        self.assertEqual(execution.pid, os.getpid())
    
    def test_pid_field_null(self):
        """Test PID field can be null."""
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15),
            pid=None
        )
        
        self.assertIsNone(execution.pid)
    
    def test_indexes_exist(self):
        """Test that database indexes are created (indirect test)."""
        # Create multiple executions to test indexes
        for i in range(5):
            CronExecution.objects.create(
                task_code=f'A00{i}',
                task_name=f'Task {i}',
                execution_date=date(2024, 1, 15 + i)
            )
        
        # Query using indexed fields should work efficiently
        executions = CronExecution.objects.filter(
            task_code='A001',
            execution_date=date(2024, 1, 16)
        )
        self.assertEqual(executions.count(), 1)
    
    def test_ordering(self):
        """Test default ordering (most recent first)."""
        dates = [date(2024, 1, 15), date(2024, 1, 16), date(2024, 1, 17)]
        
        for d in dates:
            CronExecution.objects.create(
                task_code='A001',
                task_name='Test Task',
                execution_date=d
            )
        
        executions = list(CronExecution.objects.all())
        # Should be ordered by -started (most recent first)
        self.assertGreaterEqual(executions[0].started, executions[1].started)
    
    def test_multiple_executions_same_task_date(self):
        """Test multiple executions for same task and date."""
        execution1 = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15)
        )
        
        execution2 = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15)
        )
        
        self.assertNotEqual(execution1.id, execution2.id)
        self.assertEqual(execution1.task_code, execution2.task_code)
        self.assertEqual(execution1.execution_date, execution2.execution_date)
    
    def test_long_message(self):
        """Test execution with very long message (edge case)."""
        long_message = 'A' * 10000
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15),
            message=long_message
        )
        
        execution.refresh_from_db()
        self.assertEqual(len(execution.message), 10000)
    
    def test_special_characters_in_message(self):
        """Test execution with special characters in message."""
        special_message = 'Error: "Test" <test@example.com> & more\nNew line\tTab'
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=date(2024, 1, 15),
            message=special_message
        )
        
        execution.refresh_from_db()
        self.assertEqual(execution.message, special_message)
    
    def test_future_execution_date(self):
        """Test execution with future date (edge case)."""
        future_date = date(2030, 12, 31)
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=future_date
        )
        
        self.assertEqual(execution.execution_date, future_date)
    
    def test_past_execution_date(self):
        """Test execution with past date."""
        past_date = date(2020, 1, 1)
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name='Test Task',
            execution_date=past_date
        )
        
        self.assertEqual(execution.execution_date, past_date)
    
    def test_empty_task_code(self):
        """Test execution with empty task code (edge case - should validate)."""
        # Empty string should be allowed by model (validation happens at task level)
        execution = CronExecution.objects.create(
            task_code='',
            task_name='Test Task',
            execution_date=date(2024, 1, 15)
        )
        
        self.assertEqual(execution.task_code, '')
    
    def test_very_long_task_code(self):
        """Test execution with very long task code (edge case)."""
        long_code = 'A' * 50  # Max length is 50
        execution = CronExecution.objects.create(
            task_code=long_code,
            task_name='Test Task',
            execution_date=date(2024, 1, 15)
        )
        
        self.assertEqual(execution.task_code, long_code)
    
    def test_very_long_task_name(self):
        """Test execution with very long task name (edge case)."""
        long_name = 'A' * 100  # Max length is 100
        execution = CronExecution.objects.create(
            task_code='A001',
            task_name=long_name,
            execution_date=date(2024, 1, 15)
        )
        
        self.assertEqual(execution.task_name, long_name)