// L'erreur SA1200 (ordre des using directives) est desactivee pour Program.cs
#pragma warning disable SA1200

using Microsoft.EntityFrameworkCore;

using NLog;
using NLog.Web;

using Webzine.Business.Seeders;
using Webzine.EntitiesContext;
using Webzine.Entity;
using Webzine.Entity.Fixtures;
using Webzine.Repository;
using Webzine.Repository.Contracts;
using Webzine.WebApplication.Configuration;
using Webzine.WebApplication.Extensions;

// Initiation du logger NLog pour la classe courante afin de pouvoir l'utiliser pour logger des messages d'information, d'erreur, etc avant la construction de l'application.
var logger = LogManager.Setup().LoadConfigurationFromAppSettings().GetCurrentClassLogger();
logger.Debug("init main");

try
{
    var builder = WebApplication.CreateBuilder(args);

    // Ajoute les services necessaires pour permettre l'utilisation des controllers avec des vues.
    builder.Services.AddControllersWithViews()

        // Ajoute la compilation des vues lors de l'execution de l'application.
        // Cela nous evite de recompiler l'application a chaque modification de vue.
        // Necessite le package Nuget Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation.
        .AddRazorRuntimeCompilation();

    // NLog: Setup NLog for Dependency injection
    builder.Logging.ClearProviders();
    builder.Host.UseNLog();
    builder.Services.Configure<SpotifySeederOptions>(builder.Configuration.GetSection("SpotifySeeder"));
    builder.Services.AddHttpClient<SeedDataSpotify>();

    // En fonction de la configuration, utilise soit les repositories bases sur une base de donnees, soit les repositories bases sur des listes locales.
    var repositoryType = builder.Configuration.GetValue<RepositoryType>("Repository");
    var seederType = builder.Configuration.GetValue<SeederType>("Seeder");
    var shouldSeed = args.Contains("--seed");

    if (repositoryType == RepositoryType.Db)
    {
        if (builder.Environment.IsProduction())
        {
            builder.Services.AddDbContext<WebzineDbContext>(options =>
                options.UseNpgsql(builder.Configuration.GetConnectionString("PostGreSQLConnection")));
        }
        else
        {
            builder.Services.AddDbContext<WebzineDbContext>(options =>
                options.UseSqlite(builder.Configuration.GetConnectionString("SqliteConnection")));
        }

        builder.Services.AddScoped<DbEntityRepository>();
        builder.Services.AddScoped<ITitreRepository, DbTitreRepository>();
        builder.Services.AddScoped<IStyleRepository, DbStyleRepository>();
        builder.Services.AddScoped<IArtisteRepository, DbArtisteRepository>();
        builder.Services.AddScoped<ICommentaireRepository, DbCommentaireRepository>();
    }
    else
    {
        builder.Services.AddScoped<ITitreRepository, LocalTitreRepository>();
        builder.Services.AddScoped<IStyleRepository, LocalStyleRepository>();
        builder.Services.AddScoped<IArtisteRepository, LocalArtisteRepository>();
        builder.Services.AddScoped<ICommentaireRepository, LocalCommentaireRepository>();
        builder.Services.AddSingleton<InMemoryDataStore>();
    }

    // https://learn.microsoft.com/fr-fr/aspnet/core/performance/response-compression?view=aspnetcore-10.0#configuration
    // Ajoute le service de compression des reponses HTTP pour reduire la taille des donnees envoyees au client et ameliorer les performances de l'application.
    builder.Services.AddResponseCompression();

    var app = builder.Build();

    if (repositoryType == RepositoryType.Db)
    {
        using (var scope = app.Services.CreateScope())
        {
            var db = scope.ServiceProvider.GetRequiredService<WebzineDbContext>();
            if (shouldSeed)
            {
                db.Database.EnsureDeleted();
                db.Database.EnsureCreated();
                var repo = scope.ServiceProvider.GetRequiredService<DbEntityRepository>();

                if (seederType == SeederType.Local)
                {
                    repo.SeedBaseDeDonnees();
                }
                else if (seederType == SeederType.Spotify)
                {
                    var spotifySeeder = scope.ServiceProvider.GetRequiredService<SeedDataSpotify>();
                    var jeuDeDonnees = await spotifySeeder.GenererJeuDeDonneesAsync();
                    repo.SeedBaseDeDonnees(jeuDeDonnees);
                }
            }
        }
    }
    else
    {
        using (var scope = app.Services.CreateScope())
        {
            var store = scope.ServiceProvider.GetRequiredService<InMemoryDataStore>();

            var artistes = SeedDataLocal.GenererListeArtiste(100);
            var styles = SeedDataLocal.GenererListeStyle(15, 20);
            var albums = SeedDataLocal.GenererListeAlbums(50);
            var commentaires = new List<Commentaire>();
            var titres = SeedDataLocal.GenererListeTitre(500, artistes, styles, albums);

            foreach (var titre in titres)
            {
                var commentairesForTitre = SeedDataLocal.GenererListeCommentaire(titre, 0, 5);
                titre.Commentaires.AddRange(commentairesForTitre);
                commentaires.AddRange(commentairesForTitre);
            }

            store.Artistes.AddRange(artistes);
            store.Styles = styles;
            store.Titres = titres;
            store.Commentaires.AddRange(commentaires);
        }
    }

    app.UseResponseCompression();

    // Active la possibilite de servir des fichiers statiques presents dans le dossier wwwroot.
    app.UseStaticFiles(new StaticFileOptions
    {
        OnPrepareResponse = ctx =>
        {
            // https://learn.microsoft.com/fr-fr/aspnet/core/fundamentals/static-files?view=aspnetcore-10.0#set-http-response-headers
            ctx.Context.Response.Headers.Append("Cache-Control", "public, max-age=31536000");
        },
    });

    // Active le middleware permettant le routage des requetes entrantes.
    app.UseRouting();

    // Appelle les routes definies dans le dossier Extensions.
    app.MapCustomRoutes();

    app.Run();
}
catch (Exception exception)
{
    // NLog: attrape les exceptions non gerees et les logger.
    logger.Error(exception, "Stopped program because of exception");
    throw;
}
finally
{
    // Assure que NLog flush tous les messages de log avant de fermer l'application.
    LogManager.Shutdown();
}