using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using NLog;
using NLog.Targets;
using NLog.Config;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.FileProviders;
using Microsoft.AspNetCore.Localization;
using System.Globalization;

namespace ION
{
    public class Startup
    {
        private static FileTarget logFile;
        private static ConsoleTarget consoleLog;

        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        /// <summary>
        /// This method gets called by the runtime. Use this method to add services to the container.
        /// </summary>
        /// <param name="services"></param>
        public static void ConfigureServices(IServiceCollection services)
        {
            StartLogger();

            Utilities.Config.ReadConfig();

            services.Configure<CookiePolicyOptions>(options => {
                options.CheckConsentNeeded = context => true;
                options.MinimumSameSitePolicy = Microsoft.AspNetCore.Http.SameSiteMode.None;
            });
            services.AddMvc(options => {
                        options.EnableEndpointRouting = false;
                        options.Filters.Add(new Utilities.Page.MvcPagesFilter());
                    })
                    .SetCompatibilityVersion(CompatibilityVersion.Version_3_0)
                    .AddRazorRuntimeCompilation(options => {
                        string customFilesPath = System.IO.Path.Combine(System.IO.Directory.GetCurrentDirectory(), "Pages" + System.IO.Path.DirectorySeparatorChar + "Custom");

                        // Check if "Custom" path exists. If not, create it
                        if (!System.IO.Directory.Exists(customFilesPath))
                            System.IO.Directory.CreateDirectory(customFilesPath);

                        options.FileProviders.Add(new PhysicalFileProvider(customFilesPath));
                    });

            services.AddSession();

            // Locale stuff
            services.AddLocalization();
            services.Configure<RequestLocalizationOptions>(options => {
                var supportedCultures = new[]
                {
                    new CultureInfo("en"),
                    new CultureInfo("fr"),
                    new CultureInfo("pt"),
                };

                options.DefaultRequestCulture = new RequestCulture(Utilities.Config.Get("site.language").ToString());
                options.SupportedCultures = supportedCultures;
                options.SupportedUICultures = supportedCultures;
            });

        }


        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public static void Configure(IApplicationBuilder app,
                                     IWebHostEnvironment env,
                                     IHostApplicationLifetime appLifetime)
        {
            // Register custom events
            var applicationLifetime = app.ApplicationServices.GetRequiredService<IHostApplicationLifetime>();
            applicationLifetime.ApplicationStopping.Register(OnShutdown);

            app.UseDeveloperExceptionPage();
            app.UseStatusCodePagesWithReExecute("/Status/{0}");
            app.UseExceptionHandler("/Status");

            if (!env.IsDevelopment())
            {
                app.UseHsts();
            }

            StaticObjects.isDevelopmentRun = env.IsDevelopment();
            StaticObjects.appLifetime = applicationLifetime;
            applicationLifetime.ApplicationStarted.Register(Actions.AppLifetime.Started);
            applicationLifetime.ApplicationStopped.Register(Actions.AppLifetime.Stopped);
            applicationLifetime.ApplicationStopping.Register(Actions.AppLifetime.Stopping);

            DefaultFilesOptions options = new DefaultFilesOptions();
            options.DefaultFileNames.Clear();
            options.DefaultFileNames.Add("Index");
            app.UseDefaultFiles(options);

            app.UseStaticFiles()
               .UseHttpsRedirection()
               .UseSession()
               .UseRouting()
               .UseEndpoints(routes =>
               {
                   routes.MapControllers();
                   routes.MapRazorPages();
               });
            StaticObjects.rootFolder = new PhysicalFileProvider(System.IO.Directory.GetCurrentDirectory());
        }

        public static void StartLogger()
        {
            LoggingConfiguration config = new LoggingConfiguration();

            logFile = new FileTarget("target_file_other")
            {
                FileName = "ION.log",
                Layout = "{\"timestamp\":${ticks},\"type\":\"${level}\",\"frame\":{\"file\":\"${event-properties:file}\",\"line\":${event-properties:line}},\"message\":\"${message}\"}"
            };
            config.AddTarget(logFile);


            consoleLog = new ConsoleTarget("target_console")
            {
                Layout = "[${ticks} | ${level}] ${event-properties:file} @ ${event-properties:line}: ${message}"
            };
            config.AddTarget(consoleLog);

            config.AddRuleForAllLevels(logFile);
            config.AddRuleForAllLevels(consoleLog);

            LogManager.Configuration = config;
            StaticObjects.log = LogManager.GetLogger("logger");
        }

        public static void OnShutdown()
        {
            logFile.Dispose();
            consoleLog.Dispose();
        }
    }
}