using ItAcademy.EventsManagement.API.Infrastructure.Auth;
using ItAcademy.EventsManagement.API.Infrastructure.Auth.JWT;
using ItAcademy.EventsManagement.API.Infrastructure.Extensions;
using ItAcademy.EventsManagement.API.Infrastructure.Middlewares;
using ItAcademy.EventsManagement.API.Infrastructure.Swagger;
using ItAcademy.EventsManagement.Application.Helpers;
using ItAcademy.EventsManagement.Domain.Models;
using ItAcademy.EventsManagement.Infrastructure.Helpers;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using Microsoft.OpenApi.Models;
using ItAcademy.EventsManagement.Persistence.Data;
using Serilog;
using Swashbuckle.AspNetCore.SwaggerGen;
using System.Reflection;
using Microsoft.AspNetCore.Mvc.ApiExplorer;
using Microsoft.AspNetCore.Mvc;
using FluentValidation;
using FluentValidation.AspNetCore;
using ItAcademy.EventsManagement.Persistence.Data.Seed;
using ItAcademy.EventsManagement.API.Infrastructure.BackgroundWorkers;

namespace ItAcademy.EventsManagement.API
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);
            builder.Logging.ClearProviders();

            Log.Logger = new LoggerConfiguration()
                .ReadFrom.Configuration(builder.Configuration)
                .CreateLogger();

            builder.Host.UseSerilog();
            // Add services to the container.

            builder.Services.AddControllers();
            // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
            builder.Services.AddEndpointsApiExplorer();

            builder.Services.AddApiVersioning(o =>
            {
                o.AssumeDefaultVersionWhenUnspecified = true;
                o.DefaultApiVersion = new ApiVersion(1, 0);
            });
            builder.Services.AddVersionedApiExplorer(o =>
            {
                o.GroupNameFormat = "'v'VVV";
                o.SubstituteApiVersionInUrl = true;
            });
            builder.Services.AddSwaggerGen(option =>
            {
                option.OperationFilter<SwaggerDefaultValues>();
                option.AddSecurityDefinition("basic", new OpenApiSecurityScheme
                {
                    Name = "Authorization",
                    Type = SecuritySchemeType.ApiKey,
                    Scheme = "basic",
                    In = ParameterLocation.Header,
                    Description = "Basic Authorization header using the Bearer scheme."
                });
                option.AddSecurityRequirement(new OpenApiSecurityRequirement
                {
                    {
                          new OpenApiSecurityScheme
                            {
                                Reference = new OpenApiReference
                                {
                                    Type = ReferenceType.SecurityScheme,
                                    Id = "basic"
                                }
                            },
                            Array.Empty<string>()
                    }
                });
                var xmlFilename = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
                option.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, xmlFilename));
            });

            builder.Services.AddHostedService<EventArchiverWorker>();
            builder.Services.AddHostedService<BookedTicketManagementWorker>();

            builder.Services.AddTransient<IConfigureOptions<SwaggerGenOptions>, ConfigureSwaggerGenOptions>();

            builder.Services.AddTokenAuthentication(builder.Configuration.GetSection(nameof(JWTConfiguration)).GetSection(nameof(JWTConfiguration.Secret)).Value);

            builder.Services.AddServices();
            builder.Services.AddHttpContextAccessor();

            builder.Services.AddFluentValidationAutoValidation().AddFluentValidationClientsideAdapters();
            builder.Services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());
            string connectionString;
            if (builder.Environment.IsDevelopment())
            {
                connectionString = builder.Configuration.GetConnectionString("DevelopmentConnection");
            }
            else
            {
                connectionString = builder.Configuration.GetConnectionString("ReleaseConnection");
            }
            builder.Services.AddDbContext(connectionString!);
            var secret = builder.Configuration["User:SecretKey"];
            builder.Services.Configure<UserHashingSecret>( e => e.SecretKey = secret)
            .Configure<JWTConfiguration>(builder.Configuration.GetSection("JWTConfiguration"))
            .Configure<CoreJWTConfiguration>(builder.Configuration.GetSection("JWTConfiguration"))
            .Configure<SMTPConfiguration>(builder.Configuration.GetSection("SMTPConfiguration"));

            var app = builder.Build();
            app.UseMiddleware<GlobalErrorHandlerMiddleware>()
            .UseMiddleware<CultureMiddleware>();
            // Configure the HTTP request pipeline.
            if (app.Environment.IsDevelopment())
            {
                app.UseSwagger();
                app.UseSwaggerUI(o =>
                {
                    var versionDescriptionProvider = app.Services.GetService<IApiVersionDescriptionProvider>();
                    foreach (var description in versionDescriptionProvider.ApiVersionDescriptions)
                    {
                        o.SwaggerEndpoint($"/swagger/{description.GroupName}/swagger.json",
                            $"ToDoManagement - {description.GroupName.ToUpper()}");
                    }
                });
            }

            app.UseHttpsRedirection();
            app.UseAuthentication();
            app.UseAuthorization();


            app.MapControllers();

            DataSeed.Initialize(app.Services, secret);
            app.Run();
        }
    }
}