webzine/Webzine.Repository/DbStyleRepository.cs

namespace Webzine.Repository;

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;

using Webzine.EntitiesContext;
using Webzine.Entity;
using Webzine.Repository.Contracts;

/// <summary>
/// Classe qui implémente le repository pour les styles en utilisant une base de données.
/// </summary>
public class DbStyleRepository : IStyleRepository
{
    private readonly ILogger<DbStyleRepository> logger;
    private readonly WebzineDbContext context;

    /// <summary>
    /// Initializes a new instance of the <see cref="DbStyleRepository"/> class.
    /// </summary>
    /// <param name="logger">Le service de journalisation injecté pour suivre les opérations du repository.</param>
    /// <param name="context">Le contexte de base de données injecté.</param>
    public DbStyleRepository(ILogger<DbStyleRepository> logger, WebzineDbContext context)
    {
        this.logger = logger;
        this.context = context;
        this.logger.LogDebug(1, "NLog injecté dans DbStyleRepository");
    }

    /// <inheritdoc/>
    public void Add(Style style)
    {
        try
        {
            this.logger.LogInformation("Ajout d'un nouveau style: {Libelle}", style.Libelle);
            this.logger.LogDebug("Début de l'ajout du style en base de données");

            this.context.Styles.Add(style);
            this.context.SaveChanges();

            this.logger.LogDebug("Style ajouté avec succès avec l'ID: {IdStyle}", style.IdStyle);
        }
        catch (DbUpdateException ex)
        {
            this.logger.LogError(ex, "Erreur de base de données lors de l'ajout du style: {Libelle}", style.Libelle);
            throw;
        }
        catch (Exception ex)
        {
            this.logger.LogError(ex, "Erreur lors de l'ajout du style: {Libelle}", style.Libelle);
            throw;
        }
    }

    /// <inheritdoc/>
    public void Delete(Style style)
    {
        try
        {
            this.logger.LogInformation("Suppression du style avec l'ID: {IdStyle}", style.IdStyle);
            this.logger.LogDebug("Vérification de l'existence du style en base de données");

            // Check if style exists
            var existingStyle = this.context.Styles.Find(style.IdStyle);
            if (existingStyle == null)
            {
                this.logger.LogWarning("Style avec l'ID {IdStyle} non trouvé pour la suppression", style.IdStyle);
                throw new InvalidOperationException($"Style avec l'ID {style.IdStyle} non trouvé.");
            }

            this.logger.LogDebug("Style trouvé, suppression en cours");
            this.context.Styles.Remove(existingStyle);
            this.context.SaveChanges();

            this.logger.LogDebug("Style supprimé avec succès: {IdStyle}", style.IdStyle);
        }
        catch (DbUpdateException ex)
        {
            this.logger.LogError(ex, "Erreur de base de données lors de la suppression du style ID: {IdStyle}", style.IdStyle);
            throw;
        }
        catch (Exception ex)
        {
            this.logger.LogError(ex, "Erreur lors de la suppression du style ID: {IdStyle}", style.IdStyle);
            throw;
        }
    }

    /// <inheritdoc/>
    public Style Find(int id)
    {
        try
        {
            this.logger.LogDebug("Recherche du style avec l'ID: {Id}", id);

            var style = this.context.Styles
                .AsNoTracking()
                .Include(s => s.Titres)
                .SingleOrDefault(s => s.IdStyle == id);

            if (style == null)
            {
                this.logger.LogWarning("Style avec l'ID {Id} non trouvé", id);
                return null;
            }

            this.logger.LogDebug("Style trouvé: {Libelle}", style.Libelle);
            return style;
        }
        catch (Exception ex)
        {
            this.logger.LogError(ex, "Erreur lors de la recherche du style avec l'ID: {Id}", id);
            throw;
        }
    }

    /// <inheritdoc/>
    public IEnumerable<Style> FindAll()
    {
        try
        {
            this.logger.LogDebug("Récupération de tous les styles");
            this.logger.LogDebug("Tri des styles par libellé");

            var styles = this.context.Styles
                .AsNoTracking()
                .OrderBy(s => s.Libelle);

            this.logger.LogDebug("La liste de styles a été récupérée.");
            return styles;
        }
        catch (Exception ex)
        {
            this.logger.LogError(ex, "Erreur lors de la récupération de tous les styles");
            throw;
        }
    }

    /// <inheritdoc/>
    public void Update(Style style)
    {
        try
        {
            this.logger.LogInformation("Mise à jour du style avec l'ID: {IdStyle}", style.IdStyle);
            Style existingStyle = this.Find(style.IdStyle); // Vérifie que le style existe avant de tenter de le mettre à jour

            if (existingStyle == null)
            {
                this.logger.LogWarning("Style avec l'ID {IdStyle} non trouvé pour l'update.", style.IdStyle);
                throw new InvalidOperationException($"Style avec l'ID {style.IdStyle} non trouvé pour la mise à jour.");
            }

            this.context.Styles.Update(style);

            this.context.SaveChanges();
            this.logger.LogDebug("Style mis à jour avec succès: {IdStyle}", style.IdStyle);
        }
        catch (DbUpdateException ex)
        {
            this.logger.LogError(ex, "Erreur de base de données lors de la mise à jour du style ID: {IdStyle}", style.IdStyle);
            throw;
        }
        catch (Exception ex)
        {
            this.logger.LogError(ex, "Erreur lors de la mise à jour du style ID: {IdStyle}", style.IdStyle);
            throw;
        }
    }

    /// <inheritdoc/>
    public int Count()
    {
        try
        {
            int count = Enumerable.Count(this.context.Styles);
            this.logger.LogDebug("Nombre total de styles: {Count}", count);
            return count;
        }
        catch (Exception ex)
        {
            this.logger.LogError(ex, "Erreur lors du comptage des styles");
            throw;
        }
    }

    /// <inheritdoc/>
    public IEnumerable<Style> FindStyles(int offset, int limit)
    {
        try
        {
            this.logger.LogDebug("Récupération paginée des styles (offset: {Offset}, limit: {Limit})", offset, limit);

            var styles = this.context.Styles
                .AsNoTracking()
                .OrderBy(s => s.Libelle)
                .Skip(offset)
                .Take(limit);

            this.logger.LogDebug("La liste paginée de styles a été récupérée.");
            return styles;
        }
        catch (Exception ex)
        {
            this.logger.LogError(ex, "Erreur lors de la récupération paginée des styles (offset: {Offset}, limit: {Limit})", offset, limit);
            throw;
        }
    }
}