using Model.Classes;
using Model.Managers;
using Model.Serializer;
using Model.Stub;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TestProject1
{
    public class TestManager
    {
        public Manager manager = new Manager(new StubManager());

        [Fact]
        public void Constructor_InitializesCollections()
        {
          
            Assert.NotNull(manager.Bateaux);
            Assert.NotNull(manager.Personnages);
            Assert.NotNull(manager.Fruits);
            Assert.NotNull(manager.Iles);
            Assert.NotNull(manager.Bestiaire);
            Assert.NotNull(manager.Equipages);
        }

        [Fact]
        public void FiltrerFDD_ReturnsFilteredFruits()
        {
            // Arrange
            var type = "Paramecia";
            var fruits = new List<FruitDuDemon>
            {
                new FruitDuDemon("fruit1", "", "Paramecia", 0, 0,"","",""),
                new FruitDuDemon("fruit2", "", "Logia", 0, 0,"","",""),
                new FruitDuDemon("fruit3", "", "Zoan", 0, 0,"","",""),
                  
            };
            manager.Fruits = new ObservableCollection<FruitDuDemon>(fruits);

            // Act
            var result = manager.FiltrerFDD(type);

            // Assert
            Assert.True(1== result.Count);
            Assert.True("Paramecia"== result[0].Type);
        }
        [Fact]
        public void FiltrerBateau_ReturnsMatchingBateaux()
        {
  
            var bateau1 = new Bateau("bateau1", "", 0, 0, "", "");
            var bateau2 = new Bateau("bateau1", "", 0, 0, "", "");
            var bateau3 = new Bateau("bateau", "", 0, 0, "", "");
            bateau1.Affiliation = new Equipage("Mugiwara", "","",0,0,true,"");
            bateau2.Affiliation = new Equipage("Barbe noire", "", "", 0, 0, true, "");
            bateau3.Affiliation = new Equipage("Barbe blanche", "", "", 0, 0, true, "");

            var bateaux = new List<Bateau> { bateau1,bateau2 ,bateau3};
            manager.Bateaux = new ObservableCollection<Bateau>(bateaux);


            var result = manager.FiltrerBateau("Mugiwara");

            Assert.True(1 == result.Count);
            Assert.True("Mugiwara" == result[0].Affiliation.Nom);
        }

        [Fact]
        public void FiltrerIle_ReturnsMatchingIles()
        {
            var iles = new List<Ile> { 
                new Ile("ile1","","East Blue",0,0,"",""),
                new Ile("ile2","","Grand Line",0,0,"",""),
                new Ile("ile3","","West Blue",0,0,"",""),
            };
            manager.Iles = new ObservableCollection<Ile>(iles);

            var result = manager.FiltrerIle("East Blue");

            Assert.True(1 == result.Count);
            Assert.True("East Blue" == result[0].Region);
        }
        [Fact]
        public void RechercheObjetOhara_ReturnsFilteredList()
        {
            // Arrange
            var text = "abc";
            var obj1 = new ObjetOhara("abcd");
            var obj2 = new ObjetOhara("bcde");
            var obj3 = new ObjetOhara("defg");
            var liste = new List<ObjetOhara> { obj1, obj2, obj3 };

            // Act
            var result = manager.RechercheObjetOhara(text, liste);

            // Assert
            Assert.True(1==result.Count);
            Assert.Contains(obj1, result);
 
            Assert.True(!result.Contains(obj3));
        }

        [Fact]
        public void GetFavoris_ReturnsFavoritedObjects()
        {
            var obj1 =manager.Fruits.First();
            var obj2 = manager.Equipages.First();
            manager.ModifierFavFDD(obj1, true);
            var result = manager.GetFavoris();
          
            Assert.True(1==result.Count);
            Assert.Contains(obj1, result);
            Assert.True(!result.Contains(obj2));       
        }
        [Fact]
        public void ModifierFavFDD_UpdatesFruitDuDemonFavori()
        {
            var fruit = new FruitDuDemon("Fruit", "", "", 0, 0, "", "","");
            manager.Fruits.Add(fruit);

            manager.ModifierFavFDD(fruit, true);

            fruit = manager.Fruits.FirstOrDefault(p => fruit.Nom == p.Nom);
            Assert.NotNull(fruit);
            Assert.True(fruit.EstFavori);
        }

        [Fact]
        public void ModifierFavEquip_UpdatesEquipageFavori()
        {         
            var equip = new Equipage("Equipage","","",0,0,true,"");
            manager.Equipages.Add(equip);

            manager.ModifierFavEquip(equip, true);

            equip = manager.Equipages.FirstOrDefault(p=> equip.Nom == p.Nom);
            Assert.NotNull(equip);
            Assert.True(equip.EstFavori);
        }

        [Fact]
        public void ModifierFavBest_UpdatesBestiaireFavori()
        {
            var best = new Bestiaire("Bestiaire", "", "","");
            manager.Bestiaire.Add(best);

            manager.ModifierFavBest(best, true);

            best = manager.Bestiaire.FirstOrDefault(p => best.Nom == p.Nom);
            Assert.NotNull(best);
            Assert.True(best.EstFavori);
        }

        [Fact]
        public void ModifierFavPerso_UpdatesPersonnageFavori()
        {
            var perso = new Personnage("Personnage", 0, "", 0, 0, "", "", "");
            manager.Personnages.Add(perso);

            manager.ModifierFavPerso(perso, true);

            perso = manager.Personnages.FirstOrDefault(p => perso.Nom == p.Nom);
            Assert.NotNull(perso);
            Assert.True(perso.EstFavori);
        }

        [Fact]
        public void ModifierFavIle_UpdatesIleFavori()
        {
            var ile = new Ile("Ile", "", "", 0, 0, "", "");
            manager.Iles.Add(ile);

            manager.ModifierFavIle(ile, true);

            ile = manager.Iles.FirstOrDefault(p => ile.Nom == p.Nom);
            Assert.NotNull(ile);
            Assert.True(ile.EstFavori);
        }

        [Fact]
        public void ModifierFavBateau_UpdatesBateauFavori()
        {
            var bateau = new Bateau("Bateau", "", 0, 0, "", "");
            manager.Bateaux.Add(bateau);

            manager.ModifierFavBateau(bateau, true);

            bateau = manager.Bateaux.FirstOrDefault(p => bateau.Nom == p.Nom);
            Assert.NotNull(bateau);
            Assert.True(bateau.EstFavori);
        }
        [Fact]
        public void ModifierIle_Should_UpdateIle_When_ExistingAncienNom()
        {
            Ile ancienneIle = new Ile("AncienNom","","",0,0,"","");
            Ile nouvelleIle = new Ile("NouveauNom", "", "", 0, 0, "", "");
            manager.Iles.Add(ancienneIle);

            manager.ModifierIle(nouvelleIle, "AncienNom");

            Assert.DoesNotContain(ancienneIle,manager.Iles);
            Assert.Contains(nouvelleIle,manager.Iles); ;
        }

        [Fact]
        public void ModifierIle_Should_NotUpdateIle_When_NonExistingAncienNom()
        {
            Ile ancienneIle = new Ile("AncienNom", "", "", 0, 0, "", "");
            Ile nouvelleIle = new Ile("NouveauNom", "", "", 0, 0, "", "");
            manager.Iles.Add(ancienneIle);

            manager.ModifierIle(nouvelleIle, "iadjadiozadioazj");

            Assert.Contains(ancienneIle, manager.Iles);
            Assert.DoesNotContain(nouvelleIle, manager.Iles);
        }
        [Fact]
        public void ModifierFDD_Should_UpdateIle_When_ExistingAncienNom()
        {
            FruitDuDemon ancienneFDD = new FruitDuDemon("AncienNom", "", "",0, 0, "", "","");
            FruitDuDemon nouvelleFDD = new FruitDuDemon("NouveauNom", "", "", 0, 0, "", "","");
            manager.Fruits.Add(ancienneFDD);

            manager.ModifierFDD(nouvelleFDD, "AncienNom");

            Assert.DoesNotContain(ancienneFDD, manager.Fruits);
            Assert.Contains(nouvelleFDD, manager.Fruits); ;
        }

        [Fact]
        public void ModifierFDD_Should_NotUpdateIle_When_NonExistingAncienNom()
        {
            FruitDuDemon ancienneFDD = new FruitDuDemon("AncienNom", "", "", 0, 0, "", "", "");
            FruitDuDemon nouvelleFDD = new FruitDuDemon("NouveauNom", "", "", 0, 0, "", "", "");
            manager.Fruits.Add(ancienneFDD);

            manager.ModifierFDD(nouvelleFDD, "ADADADAZDAZD");

            Assert.Contains(ancienneFDD, manager.Fruits);
            Assert.DoesNotContain(nouvelleFDD, manager.Fruits);
        }
        [Fact]
        public void ModifierPerso_Should_UpdateIle_When_ExistingAncienNom()
        {
            Personnage ancienPerso = new Personnage("AncienNom",0,"",0,0, "", "", "");
            Personnage nouveauPerso = new Personnage("NouveauNom", 0, "", 0,0, "", "", "");
            manager.Personnages.Add(ancienPerso);

            manager.ModifierPerso(nouveauPerso, "AncienNom");

            Assert.DoesNotContain(ancienPerso, manager.Personnages);
            Assert.Contains(nouveauPerso, manager.Personnages); 
        }

        [Fact]
        public void ModifierPerso_Should_NotUpdateIle_When_NonExistingAncienNom()
        {
            Personnage ancienPerso = new Personnage("AncienNom", 0, "", 0, 0, "", "", "");
            Personnage nouveauPerso = new Personnage("NouveauNom", 0, "", 0, 0, "", "", "");
            manager.Personnages.Add(ancienPerso);

            manager.ModifierPerso(nouveauPerso, "adadadadzdd");

            Assert.Contains(ancienPerso, manager.Personnages);
            Assert.DoesNotContain(nouveauPerso, manager.Personnages);
        }
        [Fact]
        public void ModifierBest_Should_UpdateIle_When_ExistingAncienNom()
        {
            Bestiaire ancienBest = new Bestiaire("AncienNom", "", "", "", "");
            Bestiaire nouveauBest = new Bestiaire("NouveauNom", "", "", "", "");
            manager.Bestiaire.Add(ancienBest);

            manager.ModifierBest(nouveauBest, "AncienNom");

            Assert.DoesNotContain(ancienBest, manager.Bestiaire);
            Assert.Contains(nouveauBest, manager.Bestiaire);
        }

        [Fact]
        public void ModifierBest_Should_NotUpdateIle_When_NonExistingAncienNom()
        {
            Bestiaire ancienBest = new Bestiaire("AncienNom", "", "", "", "");
            Bestiaire nouveauBest = new Bestiaire("NouveauNom", "", "", "", "");
            manager.Bestiaire.Add(ancienBest);

            manager.ModifierBest(nouveauBest, "adadadadzdd");
            
            Assert.Contains(ancienBest, manager.Bestiaire);
            Assert.DoesNotContain(nouveauBest, manager.Bestiaire);
        }
        [Fact]
        public void ModifierEquip_Should_UpdateIle_When_ExistingAncienNom()
        {
            Equipage ancienEquîp = new Equipage("AncienNom", "", "",0,0 ,true, "");
            Equipage nouveauEquip = new Equipage("NouveauNom", "", "", 0, 0, true, "");
            manager.Equipages.Add(ancienEquîp);

            manager.ModifierEquipage(nouveauEquip, "AncienNom");

            Assert.DoesNotContain(ancienEquîp, manager.Equipages);
            Assert.Contains(nouveauEquip, manager.Equipages);
        }

        [Fact]
        public void ModifierEquipage_Should_NotUpdateIle_When_NonExistingAncienNom()
        {
            Equipage ancienEquîp = new Equipage("AncienNom", "", "", 0, 0, true, "");
            Equipage nouveauEquip = new Equipage("NouveauNom", "", "", 0, 0, true, "");
            manager.Equipages.Add(ancienEquîp);

            manager.ModifierEquipage(nouveauEquip, "adadadda");


            Assert.Contains(ancienEquîp, manager.Equipages);
            Assert.DoesNotContain(nouveauEquip, manager.Equipages);
        }

        [Fact]
        public void ModifierBateau_Should_UpdateIle_When_ExistingAncienNom()
        {
            Bateau ancienBateau = new Bateau("AncienNom", "", 0, 0, "", "");
            Bateau nouveauBateau = new Bateau("NouveauNom", "", 0, 0, "", "");
            manager.Bateaux.Add(ancienBateau);

            manager.ModifierBateau(nouveauBateau, "AncienNom");

            Assert.DoesNotContain(ancienBateau, manager.Bateaux);
            Assert.Contains(nouveauBateau, manager.Bateaux);
        }

        [Fact]
        public void ModifierBateau_Should_NotUpdateIle_When_NonExistingAncienNom()
        {
            Bateau ancienBateau = new Bateau("AncienNom", "", 0, 0, "", "");
            Bateau nouveauBateau = new Bateau("NouveauNom", "", 0, 0, "", "");
            manager.Bateaux.Add(ancienBateau);

            manager.ModifierBateau(nouveauBateau, "adfadadzdaz");


            Assert.Contains(ancienBateau, manager.Bateaux);
            Assert.DoesNotContain(nouveauBateau, manager.Bateaux);
        }
    }
}