"""
Tests pour l'application News
"""
from django.test import TestCase, Client
from django.urls import reverse
from django.utils import timezone
from datetime import timedelta

from .models import NewsCategory, NewsArticle, EventType, Event


class NewsCategoryModelTest(TestCase):
    """Tests pour le modèle NewsCategory"""

    def test_category_creation(self):
        """Test création d'une catégorie"""
        category = NewsCategory.objects.create(
            name="Actualités",
            slug="actualites",
            color="#3B82F6"
        )
        self.assertEqual(category.name, "Actualités")
        self.assertEqual(category.color, "#3B82F6")

    def test_str_representation(self):
        """Test de la représentation string"""
        category = NewsCategory.objects.create(name="Test Category")
        self.assertEqual(str(category), "Test Category")

    def test_slug_auto_generation(self):
        """Test génération automatique du slug"""
        category = NewsCategory.objects.create(name="Test Category")
        self.assertEqual(category.slug, "test-category")


class NewsArticleModelTest(TestCase):
    """Tests pour le modèle NewsArticle"""

    def setUp(self):
        self.category = NewsCategory.objects.create(
            name="Tech",
            slug="tech"
        )

    def test_article_creation(self):
        """Test création d'un article"""
        article = NewsArticle.objects.create(
            title="Test Article",
            content="Article content here",
            category=self.category,
            is_published=True
        )
        self.assertEqual(article.title, "Test Article")
        self.assertTrue(article.is_published)

    def test_str_representation(self):
        """Test de la représentation string"""
        article = NewsArticle.objects.create(
            title="Test Article",
            content="Content"
        )
        self.assertEqual(str(article), "Test Article")

    def test_slug_auto_generation(self):
        """Test génération automatique du slug"""
        article = NewsArticle.objects.create(
            title="My Test Article",
            content="Content"
        )
        self.assertEqual(article.slug, "my-test-article")

    def test_excerpt_generation(self):
        """Test génération automatique de l'extrait"""
        article = NewsArticle.objects.create(
            title="Test",
            content="This is a long content " * 50
        )
        # L'extrait est généré automatiquement si vide
        if not article.excerpt:
            article.excerpt = article.content[:200]
            article.save()
        self.assertTrue(len(article.excerpt) <= 300)

    def test_is_featured(self):
        """Test article à la une"""
        article = NewsArticle.objects.create(
            title="Featured",
            content="Content",
            is_featured=True,
            is_published=True
        )
        self.assertTrue(article.is_featured)

    def test_publication_date_auto_set(self):
        """Test date de publication automatique"""
        article = NewsArticle.objects.create(
            title="Test",
            content="Content",
            is_published=True
        )
        self.assertIsNotNone(article.publication_date)


class EventTypeModelTest(TestCase):
    """Tests pour le modèle EventType"""

    def test_event_type_creation(self):
        """Test création d'un type d'événement"""
        event_type = EventType.objects.create(
            name="Conférence Test",
            slug="conference-test-type",
            color="#3B82F6"
        )
        self.assertEqual(event_type.name, "Conférence Test")

    def test_str_representation(self):
        """Test de la représentation string"""
        event_type = EventType.objects.create(name="Séminaire Test", slug="seminaire-test")
        self.assertEqual(str(event_type), "Séminaire Test")


class EventModelTest(TestCase):
    """Tests pour le modèle Event"""

    def setUp(self):
        self.event_type = EventType.objects.create(
            name="Model Test Conference",
            slug="model-test-conference"
        )

    def test_event_creation(self):
        """Test création d'un événement"""
        event = Event.objects.create(
            title="Annual Conference 2024",
            description="Description of the event",
            event_type=self.event_type,
            event_date=timezone.now() + timedelta(days=30),
            location="Paris, France",
            is_active=True
        )
        self.assertEqual(event.title, "Annual Conference 2024")
        self.assertTrue(event.is_active)

    def test_str_representation(self):
        """Test de la représentation string"""
        event = Event.objects.create(
            title="Test Event",
            event_type=self.event_type,
            event_date=timezone.now()
        )
        self.assertEqual(str(event), "Test Event")

    def test_slug_auto_generation(self):
        """Test génération automatique du slug"""
        event = Event.objects.create(
            title="My Test Event",
            event_type=self.event_type,
            event_date=timezone.now()
        )
        self.assertEqual(event.slug, "my-test-event")

    def test_is_past(self):
        """Test méthode is_past"""
        past_event = Event.objects.create(
            title="Past Event",
            event_type=self.event_type,
            event_date=timezone.now() - timedelta(days=1)
        )
        future_event = Event.objects.create(
            title="Future Event",
            event_type=self.event_type,
            event_date=timezone.now() + timedelta(days=1)
        )
        self.assertTrue(past_event.is_past)
        self.assertFalse(future_event.is_past)


class NewsListViewTest(TestCase):
    """Tests pour la vue liste des actualités"""

    def setUp(self):
        self.client = Client()
        self.category = NewsCategory.objects.create(name="Test", slug="test")
        self.article = NewsArticle.objects.create(
            title="Test Article",
            content="Content",
            category=self.category,
            is_published=True
        )

    def test_list_view_status_code(self):
        """Test que la page liste retourne 200"""
        response = self.client.get(reverse('news:list'))
        self.assertEqual(response.status_code, 200)

    def test_list_view_template(self):
        """Test du template utilisé"""
        response = self.client.get(reverse('news:list'))
        self.assertTemplateUsed(response, 'news/list.html')

    def test_list_view_context(self):
        """Test du contexte de la vue"""
        response = self.client.get(reverse('news:list'))
        self.assertIn('articles', response.context)
        self.assertIn('categories', response.context)

    def test_unpublished_articles_not_shown(self):
        """Test que les articles non publiés ne sont pas affichés"""
        NewsArticle.objects.create(
            title="Unpublished",
            content="Content",
            is_published=False
        )
        response = self.client.get(reverse('news:list'))
        # translate_queryset returns a list, not a queryset
        self.assertEqual(len(response.context['articles']), 1)

    def test_category_filter(self):
        """Test filtrage par catégorie"""
        other_category = NewsCategory.objects.create(name="Other", slug="other")
        NewsArticle.objects.create(
            title="Other Article",
            content="Content",
            category=other_category,
            is_published=True
        )
        response = self.client.get(reverse('news:list') + '?category=test')
        # translate_queryset returns a list, not a queryset
        self.assertEqual(len(response.context['articles']), 1)


class NewsDetailViewTest(TestCase):
    """Tests pour la vue détail d'un article"""

    def setUp(self):
        self.client = Client()
        self.article = NewsArticle.objects.create(
            title="Test Article",
            content="Content",
            is_published=True
        )

    def test_detail_view_status_code(self):
        """Test que la page détail retourne 200"""
        response = self.client.get(
            reverse('news:detail', kwargs={'slug': self.article.slug})
        )
        self.assertEqual(response.status_code, 200)

    def test_detail_view_template(self):
        """Test du template utilisé"""
        response = self.client.get(
            reverse('news:detail', kwargs={'slug': self.article.slug})
        )
        self.assertTemplateUsed(response, 'news/detail.html')

    def test_detail_view_404_for_unpublished(self):
        """Test 404 pour article non publié"""
        self.article.is_published = False
        self.article.save()
        response = self.client.get(
            reverse('news:detail', kwargs={'slug': self.article.slug})
        )
        self.assertEqual(response.status_code, 404)


class EventListViewTest(TestCase):
    """Tests pour la vue liste des événements"""

    def setUp(self):
        self.client = Client()
        self.event_type = EventType.objects.create(name="Test Type", slug="test-type")
        self.event = Event.objects.create(
            title="Test Event",
            event_date=timezone.now() + timedelta(days=7),
            event_type=self.event_type,
            is_active=True
        )

    def test_list_view_status_code(self):
        """Test que la page liste retourne 200"""
        response = self.client.get(reverse('news:events'))
        self.assertEqual(response.status_code, 200)

    def test_list_view_context(self):
        """Test du contexte de la vue"""
        response = self.client.get(reverse('news:events'))
        self.assertIn('events', response.context)

    def test_inactive_events_not_shown(self):
        """Test que les événements inactifs ne sont pas affichés"""
        Event.objects.create(
            title="Inactive Event",
            event_type=self.event_type,
            event_date=timezone.now() + timedelta(days=7),
            is_active=False
        )
        response = self.client.get(reverse('news:events'))
        # translate_queryset returns a list, not a queryset
        self.assertEqual(len(response.context['events']), 1)


class EventDetailViewTest(TestCase):
    """Tests pour la vue détail d'un événement"""

    def setUp(self):
        self.client = Client()
        self.event_type = EventType.objects.create(
            name="Detail Test Type",
            slug="detail-test-type"
        )
        self.event = Event.objects.create(
            title="Test Event",
            event_type=self.event_type,
            event_date=timezone.now() + timedelta(days=7),
            is_active=True
        )

    def test_detail_view_status_code(self):
        """Test que la page détail retourne 200"""
        response = self.client.get(
            reverse('news:event_detail', kwargs={'slug': self.event.slug})
        )
        self.assertEqual(response.status_code, 200)

    def test_detail_view_404_for_inactive(self):
        """Test 404 pour événement inactif"""
        self.event.is_active = False
        self.event.save()
        response = self.client.get(
            reverse('news:event_detail', kwargs={'slug': self.event.slug})
        )
        self.assertEqual(response.status_code, 404)