"""
Tests for Project freshness calculation functionality.
"""
from datetime import timedelta

from django.test import TestCase
from django.utils import timezone

from website.models import Organization, Project, Repo


class ProjectFreshnessCalculationTestCase(TestCase):
    """Test cases for Project.calculate_freshness() method"""

    def setUp(self):
        """Set up test data"""
        self.org = Organization.objects.create(
            name="Test Organization",
            url="https://test.org"
        )
        self.project = Project.objects.create(
            name="Test Project",
            organization=self.org,
            url="https://github.com/test/project"
        )
        self.now = timezone.now()

    def test_freshness_no_repos(self):
        """Test freshness calculation when project has no repositories"""
        freshness = self.project.calculate_freshness()
        self.assertEqual(freshness, 0.0)

    def test_freshness_all_archived_repos(self):
        """Test freshness when all repos are archived"""
        Repo.objects.create(
            project=self.project,
            name="archived-repo",
            repo_url="https://github.com/test/archived",
            is_archived=True,
            updated_at=self.now - timedelta(days=1)
        )
        freshness = self.project.calculate_freshness()
        self.assertEqual(freshness, 0.0)

    def test_freshness_single_repo_7_days(self):
        """Test freshness with one repo active in last 7 days"""
        Repo.objects.create(
            project=self.project,
            name="active-repo",
            repo_url="https://github.com/test/active",
            is_archived=False,
            updated_at=self.now - timedelta(days=3)
        )
        freshness = self.project.calculate_freshness()
        # 1 repo * 1.0 weight = 1.0, normalized: (1/20)*100 = 5.0
        self.assertEqual(freshness, 5.0)

    def test_freshness_single_repo_30_days(self):
        """Test freshness with one repo active in 8-30 day window"""
        Repo.objects.create(
            project=self.project,
            name="recent-repo",
            repo_url="https://github.com/test/recent",
            is_archived=False,
            updated_at=self.now - timedelta(days=15)
        )
        freshness = self.project.calculate_freshness()
        # 1 repo * 0.6 weight = 0.6, normalized: (0.6/20)*100 = 3.0
        self.assertEqual(freshness, 3.0)

    def test_freshness_single_repo_90_days(self):
        """Test freshness with one repo active in 31-90 day window"""
        Repo.objects.create(
            project=self.project,
            name="older-repo",
            repo_url="https://github.com/test/older",
            is_archived=False,
            updated_at=self.now - timedelta(days=60)
        )
        freshness = self.project.calculate_freshness()
        # 1 repo * 0.3 weight = 0.3, normalized: (0.3/20)*100 = 1.5
        self.assertEqual(freshness, 1.5)

    def test_freshness_mixed_activity(self):
        """Test freshness with repos in different time windows"""
        # 2 repos in last 7 days
        Repo.objects.create(
            project=self.project,
            name="very-active-1",
            repo_url="https://github.com/test/active1",
            is_archived=False,
            updated_at=self.now - timedelta(days=2)
        )
        Repo.objects.create(
            project=self.project,
            name="very-active-2",
            repo_url="https://github.com/test/active2",
            is_archived=False,
            updated_at=self.now - timedelta(days=5)
        )
        # 3 repos in 8-30 day window
        for i in range(3):
            Repo.objects.create(
                project=self.project,
                name=f"recent-{i}",
                repo_url=f"https://github.com/test/recent{i}",
                is_archived=False,
                updated_at=self.now - timedelta(days=10 + i)
            )
        # 1 repo in 31-90 day window
        Repo.objects.create(
            project=self.project,
            name="older",
            repo_url="https://github.com/test/older",
            is_archived=False,
            updated_at=self.now - timedelta(days=45)
        )
        
        freshness = self.project.calculate_freshness()
        # raw_score = 2*1.0 + 3*0.6 + 1*0.3 = 2 + 1.8 + 0.3 = 4.1
        # normalized: (4.1/20)*100 = 20.5
        self.assertEqual(freshness, 20.5)

    def test_freshness_no_recent_activity(self):
        """Test freshness when all repos are inactive (>90 days)"""
        Repo.objects.create(
            project=self.project,
            name="stale-repo",
            repo_url="https://github.com/test/stale",
            is_archived=False,
            updated_at=self.now - timedelta(days=120)
        )
        freshness = self.project.calculate_freshness()
        self.assertEqual(freshness, 0.0)

    def test_freshness_max_score_cap(self):
        """Test that freshness is capped at 100"""
        # Create 25 repos active in last 7 days (25*1.0 = 25 > MAX_SCORE)
        for i in range(25):
            Repo.objects.create(
                project=self.project,
                name=f"active-repo-{i}",
                repo_url=f"https://github.com/test/repo{i}",
                is_archived=False,
                updated_at=self.now - timedelta(days=1)
            )
        
        freshness = self.project.calculate_freshness()
        # raw_score = 25, normalized: (25/20)*100 = 125, capped at 100
        self.assertEqual(freshness, 100.0)

    def test_freshness_exact_boundaries(self):
        """Test repos exactly at time boundaries"""
        # Repo exactly 7 days old (should be in 7-day window)
        Repo.objects.create(
            project=self.project,
            name="boundary-7",
            repo_url="https://github.com/test/boundary7",
            is_archived=False,
            updated_at=self.now - timedelta(days=7)
        )
        # Repo exactly 30 days old (should be in 30-day window)
        Repo.objects.create(
            project=self.project,
            name="boundary-30",
            repo_url="https://github.com/test/boundary30",
            is_archived=False,
            updated_at=self.now - timedelta(days=30)
        )
        # Repo exactly 90 days old (should be in 90-day window)
        Repo.objects.create(
            project=self.project,
            name="boundary-90",
            repo_url="https://github.com/test/boundary90",
            is_archived=False,
            updated_at=self.now - timedelta(days=90)
        )
        
        freshness = self.project.calculate_freshness()
        # All three should be counted: 1*1.0 + 1*0.6 + 1*0.3 = 1.9
        # normalized: (1.9/20)*100 = 9.5
        self.assertEqual(freshness, 9.5)

    def test_freshness_mixed_archived_and_active(self):
        """Test that archived repos are excluded from calculation"""
        # Active repo
        Repo.objects.create(
            project=self.project,
            name="active",
            repo_url="https://github.com/test/active",
            is_archived=False,
            updated_at=self.now - timedelta(days=2)
        )
        # Archived repo (should be ignored)
        Repo.objects.create(
            project=self.project,
            name="archived",
            repo_url="https://github.com/test/archived",
            is_archived=True,
            updated_at=self.now - timedelta(days=1)
        )
        
        freshness = self.project.calculate_freshness()
        # Only 1 active repo counted: 1*1.0 = 1.0, (1/20)*100 = 5.0
        self.assertEqual(freshness, 5.0)

    def test_freshness_rounding(self):
        """Test that freshness is rounded to 2 decimal places"""
        # Create scenario that produces non-round number
        for i in range(7):
            Repo.objects.create(
                project=self.project,
                name=f"repo-{i}",
                repo_url=f"https://github.com/test/repo{i}",
                is_archived=False,
                updated_at=self.now - timedelta(days=1)
            )
        
        freshness = self.project.calculate_freshness()
        # raw_score = 7, normalized: (7/20)*100 = 35.0
        self.assertEqual(freshness, 35.0)
        # Verify it's a float with max 2 decimal places
        self.assertIsInstance(freshness, float)
        self.assertEqual(len(str(freshness).split('.')[-1]), 1)  # Only 1 decimal place for .0

    def test_freshness_persistence(self):
        """Test that freshness can be saved to the database"""
        Repo.objects.create(
            project=self.project,
            name="test-repo",
            repo_url="https://github.com/test/repo",
            is_archived=False,
            updated_at=self.now - timedelta(days=5)
        )
        
        freshness = self.project.calculate_freshness()
        self.project.freshness = freshness
        self.project.save()
        
        # Reload from database
        reloaded = Project.objects.get(id=self.project.id)
        self.assertEqual(float(reloaded.freshness), freshness)

"""
Tests for the update_project_freshness management command.
"""
from datetime import timedelta
from io import StringIO
from unittest.mock import patch

from django.core.management import call_command
from django.test import TestCase
from django.utils import timezone

from website.models import Organization, Project, Repo


class UpdateProjectFreshnessCommandTestCase(TestCase):
    """Test cases for update_project_freshness management command"""

    def setUp(self):
        """Set up test data"""
        self.org = Organization.objects.create(
            name="Test Org",
            url="https://test.org"
        )
        self.now = timezone.now()

    def test_command_updates_all_projects(self):
        """Test that command updates freshness for all projects"""
        # Create projects with different activity levels
        project1 = Project.objects.create(
            name="Active Project",
            organization=self.org,
            url="https://github.com/test/active"
        )
        Repo.objects.create(
            project=project1,
            name="active-repo",
            repo_url="https://github.com/test/active-repo",
            is_archived=False,
            updated_at=self.now - timedelta(days=2)
        )

        project2 = Project.objects.create(
            name="Inactive Project",
            organization=self.org,
            url="https://github.com/test/inactive"
        )
        Repo.objects.create(
            project=project2,
            name="old-repo",
            repo_url="https://github.com/test/old-repo",
            is_archived=False,
            updated_at=self.now - timedelta(days=100)
        )

        project3 = Project.objects.create(
            name="No Repos Project",
            organization=self.org,
            url="https://github.com/test/empty"
        )

        # Run command
        out = StringIO()
        call_command('update_project_freshness', stdout=out)

        # Verify all projects were updated
        project1.refresh_from_db()
        project2.refresh_from_db()
        project3.refresh_from_db()

        self.assertEqual(float(project1.freshness), 5.0)  # 1 repo * 1.0 weight
        self.assertEqual(float(project2.freshness), 0.0)  # No recent activity
        self.assertEqual(float(project3.freshness), 0.0)  # No repos

        # Check output
        output = out.getvalue()
        self.assertIn('Starting freshness update', output)
        self.assertIn('Processed: 3', output)
        self.assertIn('Errors: 0', output)
        self.assertIn('Freshness update completed', output)

    def test_command_progress_reporting(self):
        """Test that command reports progress every 100 projects"""
        # Create 250 projects
        for i in range(250):
            Project.objects.create(
                name=f"Project {i}",
                organization=self.org,
                url=f"https://github.com/test/project{i}"
            )

        out = StringIO()
        call_command('update_project_freshness', stdout=out)

        output = out.getvalue()
        # Should see progress at 100 and 200
        self.assertIn('Processed 100/250', output)
        self.assertIn('Processed 200/250', output)

    def test_command_handles_errors_gracefully(self):
        """Test that command handles individual project errors without stopping"""
        project1 = Project.objects.create(
            name="Good Project",
            organization=self.org,
            url="https://github.com/test/good"
        )
        Repo.objects.create(
            project=project1,
            name="good-repo",
            repo_url="https://github.com/test/good-repo",
            is_archived=False,
            updated_at=self.now - timedelta(days=5)
        )

        project2 = Project.objects.create(
            name="Error Project",
            organization=self.org,
            url="https://github.com/test/error"
        )

        out = StringIO()
        err = StringIO()

        # Mock calculate_freshness to raise error for one project
        original_calculate = Project.calculate_freshness
        def mock_calculate(self):
            if self.name == "Error Project":
                raise ValueError("Test error")
            return original_calculate(self)

        with patch.object(Project, 'calculate_freshness', mock_calculate):
            call_command('update_project_freshness', stdout=out, stderr=err)

        # Check that good project was updated
        project1.refresh_from_db()
        self.assertEqual(float(project1.freshness), 5.0)

        # Check error was logged
        error_output = err.getvalue()
        self.assertIn(f'[ERROR] Project ID {project2.id}', error_output)
        self.assertIn('Test error', error_output)

        # Check summary shows 1 error
        output = out.getvalue()
        self.assertIn('Processed: 1', output)
        self.assertIn('Errors: 1', output)

    def test_command_only_updates_freshness_field(self):
        """Test that command only updates the freshness field, not other fields"""
        project = Project.objects.create(
            name="Test Project",
            organization=self.org,
            url="https://github.com/test/project"
        )
        Repo.objects.create(
            project=project,
            name="repo",
            repo_url="https://github.com/test/repo",
            is_archived=False,
            updated_at=self.now - timedelta(days=3)
        )

        # Get original updated timestamp
        original_name = project.name

        # Mock save to track what fields are updated
        with patch.object(Project, 'save') as mock_save:
            call_command('update_project_freshness', stdout=StringIO())
            
            # Verify save was called with update_fields=['freshness']
            self.assertTrue(mock_save.called)
            call_args = mock_save.call_args
            self.assertEqual(call_args[1].get('update_fields'), ['freshness'])

    def test_command_execution_time_reported(self):
        """Test that command reports execution time"""
        Project.objects.create(
            name="Test Project",
            organization=self.org,
            url="https://github.com/test/project"
        )

        out = StringIO()
        call_command('update_project_freshness', stdout=out)

        output = out.getvalue()
        self.assertIn('Execution time:', output)
        self.assertIn('s', output)  # Should have 's' for seconds

    def test_command_with_zero_projects(self):
        """Test command behavior when there are no projects"""
        out = StringIO()
        call_command('update_project_freshness', stdout=out)

        output = out.getvalue()
        self.assertIn('Starting freshness update for 0 projects', output)
        self.assertIn('Processed: 0', output)
        self.assertIn('Errors: 0', output)

# Add this test class to the existing test_api.py file

class ProjectFreshnessFilteringTestCase(APITestCase):
    """Test cases for Project API freshness filtering"""

    def setUp(self):
        """Set up test data"""
        self.org = Organization.objects.create(
            name="Test Organization",
            url="https://test.org"
        )
        
        # Create projects with different freshness scores
        self.high_freshness_project = Project.objects.create(
            name="High Freshness",
            organization=self.org,
            url="https://github.com/test/high",
            freshness=85.50
        )
        
        self.medium_freshness_project = Project.objects.create(
            name="Medium Freshness",
            organization=self.org,
            url="https://github.com/test/medium",
            freshness=50.25
        )
        
        self.low_freshness_project = Project.objects.create(
            name="Low Freshness",
            organization=self.org,
            url="https://github.com/test/low",
            freshness=15.75
        )
        
        self.zero_freshness_project = Project.objects.create(
            name="Zero Freshness",
            organization=self.org,
            url="https://github.com/test/zero",
            freshness=0.0
        )

    def test_filter_by_valid_freshness(self):
        """Test filtering projects by valid freshness threshold"""
        response = self.client.get('/api/v1/projects/filter/?freshness=50')
        
        self.assertEqual(response.status_code, 200)
        data = response.json()
        
        # Should return projects with freshness >= 50
        self.assertEqual(len(data['results']), 2)
        names = [p['name'] for p in data['results']]
        self.assertIn('High Freshness', names)
        self.assertIn('Medium Freshness', names)

    def test_filter_by_zero_freshness(self):
        """Test filtering with freshness=0 (should return all projects)"""
        response = self.client.get('/api/v1/projects/filter/?freshness=0')
        
        self.assertEqual(response.status_code, 200)
        data = response.json()
        
        # All projects have freshness >= 0
        self.assertEqual(len(data['results']), 4)

    def test_filter_by_high_freshness(self):
        """Test filtering with high freshness threshold"""
        response = self.client.get('/api/v1/projects/filter/?freshness=80')
        
        self.assertEqual(response.status_code, 200)
        data = response.json()
        
        # Only high freshness project should match
        self.assertEqual(len(data['results']), 1)
        self.assertEqual(data['results'][0]['name'], 'High Freshness')

    def test_filter_by_freshness_100(self):
        """Test filtering with freshness=100 (maximum valid value)"""
        response = self.client.get('/api/v1/projects/filter/?freshness=100')
        
        self.assertEqual(response.status_code, 200)
        data = response.json()
        
        # No projects have freshness >= 100
        self.assertEqual(len(data['results']), 0)

    def test_filter_freshness_invalid_negative(self):
        """Test that negative freshness values are rejected"""
        response = self.client.get('/api/v1/projects/filter/?freshness=-10')
        
        self.assertEqual(response.status_code, 400)
        self.assertIn('must be between 0 and 100', response.json()['error'])

    def test_filter_freshness_invalid_over_100(self):
        """Test that freshness values over 100 are rejected"""
        response = self.client.get('/api/v1/projects/filter/?freshness=150')
        
        self.assertEqual(response.status_code, 400)
        self.assertIn('must be between 0 and 100', response.json()['error'])

    def test_filter_freshness_invalid_non_numeric(self):
        """Test that non-numeric freshness values are rejected"""
        response = self.client.get('/api/v1/projects/filter/?freshness=invalid')
        
        self.assertEqual(response.status_code, 400)
        self.assertIn('must be a valid number', response.json()['error'])

    def test_filter_freshness_decimal_value(self):
        """Test filtering with decimal freshness value"""
        response = self.client.get('/api/v1/projects/filter/?freshness=50.5')
        
        self.assertEqual(response.status_code, 200)
        data = response.json()
        
        # Should return projects with freshness >= 50.5
        self.assertEqual(len(data['results']), 1)
        self.assertEqual(data['results'][0]['name'], 'High Freshness')

    def test_filter_freshness_combined_with_other_filters(self):
        """Test freshness filter combined with other filters"""
        # Add repos for star filtering
        Repo.objects.create(
            project=self.high_freshness_project,
            name="popular-repo",
            repo_url="https://github.com/test/popular",
            stars=1000,
            forks=100
        )
        Repo.objects.create(
            project=self.low_freshness_project,
            name="unpopular-repo",
            repo_url="https://github.com/test/unpopular",
            stars=10,
            forks=5
        )

        # Filter by both freshness and stars
        response = self.client.get('/api/v1/projects/filter/?freshness=50&stars=500')
        
        self.assertEqual(response.status_code, 200)
        data = response.json()
        
        # Should return only high freshness project with enough stars
        self.assertEqual(len(data['results']), 1)
        self.assertEqual(data['results'][0]['name'], 'High Freshness')

    def test_filter_without_freshness_parameter(self):
        """Test that filtering works when freshness parameter is not provided"""
        response = self.client.get('/api/v1/projects/filter/')
        
        self.assertEqual(response.status_code, 200)
        data = response.json()
        
        # Should return all projects
        self.assertEqual(len(data['results']), 4)

    def test_freshness_field_in_api_response(self):
        """Test that freshness field is included in API response"""
        response = self.client.get('/api/v1/projects/filter/')
        
        self.assertEqual(response.status_code, 200)
        data = response.json()
        
        # Check that freshness field exists in response
        for project in data['results']:
            self.assertIn('freshness', project)
            self.assertIsNotNone(project['freshness'])

# Add this test method to the existing ProjectAggregationTestCase class

def test_freshness_calculation_integration(self):
    """Integration test for freshness calculation with real data flow"""
    from datetime import timedelta
    from django.utils import timezone
    
    # Create project with repos
    org = Organization.objects.create(name="Integration Org", url="https://int.org")
    project = Project.objects.create(
        name="Integration Project",
        organization=org,
        url="https://github.com/int/project"
    )
    
    now = timezone.now()
    
    # Add repos with different activity levels
    Repo.objects.create(
        project=project,
        name="very-active",
        repo_url="https://github.com/int/active",
        is_archived=False,
        updated_at=now - timedelta(days=2)
    )
    Repo.objects.create(
        project=project,
        name="somewhat-active",
        repo_url="https://github.com/int/somewhat",
        is_archived=False,
        updated_at=now - timedelta(days=20)
    )
    Repo.objects.create(
        project=project,
        name="old-active",
        repo_url="https://github.com/int/old",
        is_archived=False,
        updated_at=now - timedelta(days=60)
    )
    Repo.objects.create(
        project=project,
        name="archived",
        repo_url="https://github.com/int/archived",
        is_archived=True,
        updated_at=now - timedelta(days=1)  # Should be ignored
    )
    
    # Calculate freshness
    freshness = project.calculate_freshness()
    
    # Expected: 1*1.0 + 1*0.6 + 1*0.3 = 1.9, normalized: (1.9/20)*100 = 9.5
    self.assertEqual(freshness, 9.5)
    
    # Save and verify persistence
    project.freshness = freshness
    project.save()
    
    project.refresh_from_db()
    self.assertEqual(float(project.freshness), 9.5)