#!/usr/bin/env python3
"""Tests pour CORRECTION 5 : filtre anti-homonyme photo avec prenom."""
import sys
import os
import unittest

sys.path.insert(0, os.path.join(os.path.dirname(__file__), "agents_python"))


class TestValidatePortraitNameRejections(unittest.TestCase):
    """Cas de rejet : mauvaise personne."""

    def setUp(self):
        from media_fetcher import _validate_portrait_name
        self.validate = _validate_portrait_name

    def test_marie_therese_boiteux_rejected(self):
        """Marie-Therese Boiteux ≠ Marie Le Boiteux."""
        self.assertFalse(self.validate(
            "MARIE-THERESE-BOITEUX-rotated.jpg",
            "Marie", "Le Boiteux"))

    def test_herve_elie_bokobza_rejected(self):
        """Herve Elie Bokobza ≠ Herve Bokobza."""
        self.assertFalse(self.validate(
            "herve_elie-bokobza.jpg",
            "Herve", "Bokobza"))

    def test_jean_pierre_martin_rejected(self):
        """Jean-Pierre Martin ≠ Jean Martin."""
        self.assertFalse(self.validate(
            "jean-pierre-martin-portrait.jpg",
            "Jean", "Martin"))

    def test_different_firstname_rejected(self):
        """Philippe Boiteux ≠ Marie Le Boiteux."""
        self.assertFalse(self.validate(
            "philippe-boiteux-2024.jpg",
            "Marie", "Le Boiteux"))


class TestValidatePortraitNameAcceptances(unittest.TestCase):
    """Cas d'acceptation : bonne personne."""

    def setUp(self):
        from media_fetcher import _validate_portrait_name
        self.validate = _validate_portrait_name

    def test_pascal_herard(self):
        self.assertTrue(self.validate(
            "pascal-herard-journaliste.jpg",
            "Pascal", "Herard"))

    def test_olivier_iteanu(self):
        self.assertTrue(self.validate(
            "olivier-iteanu-avocat.jpg",
            "Olivier", "Iteanu"))

    def test_lastname_only_no_contradiction(self):
        """Nom seul sans prenom contradictoire → OK."""
        self.assertTrue(self.validate(
            "bokobza-portrait.jpg",
            "Herve", "Bokobza"))

    def test_marie_le_boiteux_full(self):
        """Nom compose complet dans le fichier."""
        self.assertTrue(self.validate(
            "marie-le-boiteux-autrice.jpg",
            "Marie", "Le Boiteux"))

    def test_marie_boiteux_core_lastname_rejected(self):
        """v4.9f C2: Marie Boiteux ≠ Marie Le Boiteux (particule manquante)."""
        self.assertFalse(self.validate(
            "marie-boiteux-portrait.jpg",
            "Marie", "Le Boiteux"))

    def test_boiteux_alone_no_contradiction(self):
        """Nom seul sans prenom → OK (pas de contradiction)."""
        self.assertTrue(self.validate(
            "boiteux-portrait-cenon.jpg",
            "Marie", "Le Boiteux"))

    def test_jean_pierre_dupont_composite(self):
        """Prenom compose recherche dans le fichier."""
        self.assertTrue(self.validate(
            "jean-pierre-dupont.jpg",
            "Jean-Pierre", "Dupont"))


class TestValidatePortraitNameEdgeCases(unittest.TestCase):
    """Cas limites."""

    def setUp(self):
        from media_fetcher import _validate_portrait_name
        self.validate = _validate_portrait_name

    def test_particle_de_not_firstname(self):
        """Particule 'de' ne doit pas etre prise pour un prenom."""
        self.assertTrue(self.validate(
            "de-boiteux-photo.jpg",
            "Marie", "Le Boiteux"))

    def test_no_name_at_all(self):
        """Ni prenom ni nom → rejet."""
        self.assertFalse(self.validate(
            "profile-displayphoto.jpg",
            "Pascal", "Herard"))

    def test_accented_names(self):
        """Noms avec accents."""
        self.assertTrue(self.validate(
            "herve-bokobza-psychiatre.jpg",
            "Herve", "Bokobza"))

    def test_accented_source(self):
        """Accents dans le fichier."""
        self.assertTrue(self.validate(
            "pascal-herard-formateur.jpg",
            "Pascal", "Herard"))

    def test_url_with_path(self):
        """URL complete avec chemin."""
        self.assertTrue(self.validate(
            "https://example.com/uploads/pascal-herard-2024.jpg",
            "Pascal", "Herard"))

    def test_url_with_title_context(self):
        """URL + titre combines."""
        self.assertTrue(self.validate(
            "https://hebdo25.net/photo.jpg Marie Le Boiteux autrice",
            "Marie", "Le Boiteux"))

    def test_marie_therese_in_url_and_title(self):
        """URL + titre avec le mauvais prenom."""
        self.assertFalse(self.validate(
            "https://hebdo25.net/MARIE-THERESE-BOITEUX.jpg Marie Therese Boiteux",
            "Marie", "Le Boiteux"))


class TestParticleHandling(unittest.TestCase):
    """v4.9f CORRECTION 2 : gestion des particules de nom."""

    def setUp(self):
        from media_fetcher import _validate_portrait_name
        self._validate = _validate_portrait_name

    def validate(self, text, fn, ln):
        return self._validate(text, fn, ln)

    # --- REJETS (particule manquante = homonyme) ---

    def test_marie_boiteux_linkedin_rejected(self):
        """Marie Boiteux Designer ≠ Marie Le Boiteux."""
        self.assertFalse(self.validate(
            "marie-boiteux-070a171a0 Marie Boiteux Designer vegetal",
            "Marie", "Le Boiteux"))

    def test_philippe_boiteux_rejected(self):
        """Philippe Boiteux ≠ Marie Le Boiteux (autre prenom, sans particule)."""
        self.assertFalse(self.validate(
            "philippe-boiteux-portrait.jpg",
            "Marie", "Le Boiteux"))

    # --- ACCEPTATIONS (nom complet avec particule) ---

    def test_marie_le_boiteux_full_name(self):
        """Nom complet avec particule → OK."""
        self.assertTrue(self.validate(
            "marie-le-boiteux-psychomotricienne.jpg",
            "Marie", "Le Boiteux"))

    def test_boiteux_alone_prudent(self):
        """Nom seul sans prenom → OK (pas de contradiction)."""
        self.assertTrue(self.validate(
            "boiteux-portrait.jpg",
            "Marie", "Le Boiteux"))

    # --- NON-REGRESSION : noms sans particule ---

    def test_gil_charpenet_no_particle(self):
        """Gil Charpenet : nom sans particule → OK."""
        self.assertTrue(self.validate(
            "Gil Charpenet linkedin profile",
            "Gil", "Charpenet"))

    def test_herve_elie_bokobza_intercale(self):
        """Herve Elie Bokobza ≠ Herve Bokobza (prenom intercale)."""
        self.assertFalse(self.validate(
            "herve_elie-bokobza.jpg Herve Elie Bokobza",
            "Herve", "Bokobza"))

    # --- CAS BEN OSMAN (particule dans le nom) ---

    def test_khelil_ben_osman_full(self):
        """Khelil Ben Osman : nom complet → OK."""
        self.assertTrue(self.validate(
            "khelilbenosman linkedin Khelil Ben Osman",
            "Khelil", "Ben Osman"))

    def test_khelil_osman_without_ben(self):
        """Khelil Osman sans Ben → REJET (particule manquante)."""
        self.assertFalse(self.validate(
            "khelil osman some profile",
            "Khelil", "Ben Osman"))

    def test_osman_alone_no_prenom(self):
        """Osman seul sans prenom → OK (prudent)."""
        self.assertTrue(self.validate(
            "osman-conference.jpg",
            "Khelil", "Ben Osman"))

    # --- CAS DE/DU/VON ---

    def test_jean_de_la_fontaine_full(self):
        """Jean de La Fontaine complet → OK."""
        self.assertTrue(self.validate(
            "jean-de-la-fontaine-portrait.jpg",
            "Jean", "de La Fontaine"))

    def test_jean_fontaine_without_particle(self):
        """Jean Fontaine sans de/la → REJET."""
        self.assertFalse(self.validate(
            "jean-fontaine.jpg",
            "Jean", "de La Fontaine"))


if __name__ == "__main__":
    unittest.main()