using Microsoft.Extensions.Logging;
using Webzine.Entity;
using Webzine.Repository.Contracts;

namespace Webzine.Repository;

/// <summary>
/// Classe qui implémente le repository pour les titres en utilisant une liste locale comme source de données.
/// </summary>
public class LocalTitreRepository : ITitreRepository
{
    private readonly ILogger<LocalTitreRepository> logger;
    private readonly List<Titre> titres;

    /// <summary>
    /// Initializes a new instance of the <see cref="LocalTitreRepository"/> class.
    /// </summary>
    /// <param name="logger">Le service de journalisation injecté pour suivre les opérations du repository.</param>
    /// <param name="titres">La liste de titres à utiliser comme source de données pour le repository.</param>
    public LocalTitreRepository(ILogger<LocalTitreRepository> logger, List<Titre> titres)
    {
        this.logger = logger;
        this.titres = titres;
        this.logger.LogDebug(1, "NLog injected into LocalTitreRepository");
    }

    /// <summary>
    /// Ajoute un titre à la liste des titres.
    /// </summary>
    /// <param name="titre">L'objet titre à ajouter.</param>
    public void Add(Titre titre)
    {
        this.titres.Add(titre);
    }

    /// <summary>
    /// Remonte le nombre de titres.
    /// </summary>
    /// <returns>Le nombre total de titres présents dans la liste après l'incrémentation du nombre de lectures.</returns>
    public int Count()
    {
        return this.titres.Count;
    }

    /// <summary>
    /// Supprime un titre de la liste des titres.
    /// </summary>
    /// <param name="titre">L'objet titre à supprimer.</param>
    public void Delete(Titre titre)
    {
        if (!this.titres.Contains(titre))
        {
            this.logger.LogWarning("Le titre avec l'identifiant {IdTitre} n'existe pas dans la liste.", titre.IdTitre);
        }

        this.titres.Remove(titre);
    }

    /// <summary>
    /// Recherche les titres dans la liste des titres en fonction de l'offset et de la limite spécifiés, permettant ainsi une pagination des résultats.
    /// </summary>
    /// <param name="offset">Le nombre de titres à ignorer avant de commencer à retourner les résultats.</param>
    /// <param name="limit">Le nombre maximum de titres à retourner.</param>
    /// <returns>Une collection de titres correspondant au critère de pagination, triée par libellé.</returns>
    public IEnumerable<Titre> FindTitres(int offset, int limit)
    {
        if (offset < 0 || limit <= 0)
        {
            this.logger.LogWarning("FindTitres called with invalid offset {Offset} or limit {Limit}.", offset, limit);
            return Enumerable.Empty<Titre>();
        }

        return this.titres.Skip(offset).Take(limit).ToList();
    }

    /// <summary>
    /// Incrémente le nombre de lectures d'un titre donné. Si le titre est null, un message d'avertissement est enregistré dans les logs et aucune action n'est effectuée.
    /// </summary>
    /// <param name="titre">L'objet titre dont le nombre de lectures doit être incrémenté.</param>
    public void IncrementNbLectures(Titre titre)
    {
        titre.NbLectures++;
    }

    /// <summary>
    /// Incrémente le nombre de likes d'un titre donné. Si le titre est null, un message d'avertissement est enregistré dans les logs et aucune action n'est effectuée.
    /// </summary>
    /// <param name="titre">L'objet titre dont le nombre de likes doit être incrémenté.</param>
    public void IncrementNbLikes(Titre titre)
    {
        titre.NbLikes++;
    }

    /// <summary>
    /// Recherche les titres dont le libellé contient le mot spécifié, en ignorant la casse.
    /// </summary>
    /// <param name="mot">Le mot à rechercher dans les libellés des titres.</param>
    /// <returns>Une collection de titres correspondant au critère de recherche, triée par libellé.</returns>
    public IEnumerable<Titre> Search(string mot)
    {
        if (string.IsNullOrWhiteSpace(mot))
        {
            this.logger.LogWarning("Search called with an empty or whitespace string.");
            return Enumerable.Empty<Titre>();
        }

        IEnumerable<Titre> list = this.titres
            .Where(t => !string.IsNullOrWhiteSpace(t.Libelle)
                        && t.Libelle.Contains(mot, StringComparison.OrdinalIgnoreCase))
            .OrderBy(t => t.Libelle)
            .ToList();

        if (!list.Any())
        {
            this.logger.LogInformation("No titres found matching the search term '{Mot}'.", mot);
        }

        return list;
    }

    /// <summary>
    /// Trouve un titre dans la liste des titres en fonction de son identifiant.
    /// </summary>
    /// <param name="idTitre">L'identifiant du titre à trouver.</param>
    /// <returns>Le titre correspondant à l'identifiant fourni, ou null si aucun titre n'est trouvé.</returns>
    public Titre? Find(int idTitre)
    {
        Titre? titre = titres.FirstOrDefault(t => t.IdTitre == idTitre);

        if (titre == null)
        {
            this.logger.LogInformation("No titre found with IdTitre {IdTitre}.", idTitre);
        }

        return titre;
    }

    /// <summary>
    /// Trouve tous les titres dans la liste des titres.
    /// </summary>
    /// <returns>Une collection de tous les titres présents dans la liste.</returns>
    public IEnumerable<Titre> FindAll()
    {
        return this.titres;
    }

    /// <summary>
    /// Recherche les titres associés à un style dont le libellé contient la chaîne spécifiée, en ignorant la casse.
    /// </summary>
    /// <param name="libelle">Le libellé du style à rechercher dans les titres.</param>
    /// <returns>Une collection de titres correspondant au critère de recherche, triée par libellé.</returns>
    public IEnumerable<Titre> SearchByStyle(string libelle)
    {
        if (string.IsNullOrWhiteSpace(libelle))
        {
            this.logger.LogWarning("SearchByStyle called with an empty or whitespace string.");
            return Enumerable.Empty<Titre>();
        }

        IEnumerable<Titre> list = this.titres
            .Where(t => t.Styles.Any(s => !string.IsNullOrWhiteSpace(s.Libelle)
                                            && s.Libelle.Contains(libelle, StringComparison.OrdinalIgnoreCase)))
            .OrderBy(t => t.Libelle)
            .ToList();

        if (!list.Any())
        {
            this.logger.LogInformation("No titres found matching the style '{Libelle}'.", libelle);
        }

        return list;
    }

    /// <summary>
    /// Met à jour un titre dans la liste des titres en fonction de son identifiant. Si aucun titre correspondant à l'identifiant du titre fourni n'est trouvé, un message d'avertissement est enregistré dans les logs et aucune mise à jour n'est effectuée.
    /// </summary>
    /// <param name="titre">L'objet titre à mettre à jour.</param>
    public void Update(Titre titre)
    {
        int index = this.titres.FindIndex(t => t.IdTitre == titre.IdTitre);

        if (index == -1)
        {
            this.logger.LogWarning("Aucun titre trouvé avec l'identifiant {IdTitre}.", titre.IdTitre);
        }

        this.titres[index] = titre;
    }
}