using AutoMapper;
using Hangfire;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Mappings.DbContexts;
using Ladaer.BackEnd.Infrastructures.AppSettings;
using Ladaer.BackEnd.Infrastructures.DTO;
using Ladaer.BackEnd.Infrastructures.Services;
using Microsoft.AspNetCore.Identity;
using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using System.Data;

namespace Ladaer.BackEnd.Infrastructures.Startup
{
    /// <summary>
    /// L��>p m��Y r��Tng �`��� �`��ng kA� cA�c d��<ch v��� vA� c���u hA�nh ��cng d���ng.
    /// </summary>
    public static class GeneralRegister
    {
        private static readonly string policyName = "default";

        /// <summary>
        /// �?��ng kA� cA�c d��<ch v��� chung.
        /// </summary>
        /// <param name="services">�?��`i t�����ng IServiceCollection.</param>
        /// <param name="Configuration">�?��`i t�����ng IConfiguration.</param>
        public static void RegisterGeneralServices(this IServiceCollection services, IConfiguration Configuration)
        {
            services.AddControllers()
                .AddNewtonsoftJson(x =>
                {
                    x.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
                    x.SerializerSettings.ContractResolver = new DefaultContractResolver();
                });

            string connectionString = Configuration.GetConnectionString("LadaConnection");

            services.AddDbContext<LadaDbContext>(options =>
                        options.UseSqlServer(connectionString, b => b.MigrationsAssembly("Ladaer.BackEnd")), ServiceLifetime.Scoped);




            // Khai bA�o Dapper
            services.AddTransient<IDbConnection>((sp) => new SqlConnection(connectionString));

            services.AddMemoryCache();

            services.AddCors(options =>
            {
                options.AddPolicy(policyName, builder => builder.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod());
            });

            services.AddHangfire(x => x.UseSqlServerStorage(Configuration.GetConnectionString("LadaConnection")));
            services.AddHangfireServer();
        }

        /// <summary>
        /// C���u hA�nh vA� ch���y ��cng d���ng.
        /// </summary>
        /// <param name="app">�?��`i t�����ng WebApplication.</param>
        public static void ConfigAndRunApp(this WebApplication app)
        {
            // Configure the HTTP request pipeline.
            if (app.Environment.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler(appBuilder =>
                {
                    appBuilder.Run(async context =>
                    {
                        context.Response.StatusCode = 500;
                        context.Response.ContentType = "application/json";

                        var error = context.Features.Get<Microsoft.AspNetCore.Diagnostics.IExceptionHandlerFeature>();
                        if (error != null)
                        {
                            var response = new
                            {
                                error = "Internal Server Error",
                                message = error.Error.Message
                            };
                            await context.Response.WriteAsync(System.Text.Json.JsonSerializer.Serialize(response));
                        }
                    });
                });
                app.UseHsts();
            }

            app.UseSwagger();
            app.UseSwaggerUI();
            app.UseHangfireDashboard("/hangfire");

            app.UseCors(policyName);

            app.UseHttpsRedirection();
            app.UseStaticFiles();

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

            app.MapControllers();

            AutoMapperConfig.Init();

            // �?��ng kA� Hangfire recurring job cho VAT Invoice sync
            RecurringJob.AddOrUpdate<Infrastructures.Jobs.VatInvoiceSyncJob>(
                "vat-invoice-sync",
                job => job.Execute(),
                "0 3 * * *",  // Cron: 3:00 AM hA�ng ngA�y
                new RecurringJobOptions
                {
                    TimeZone = TimeZoneInfo.FindSystemTimeZoneById("SE Asia Standard Time")
                });

            // �?��ng kA� Hangfire recurring job cho Auto Penalty
            RecurringJob.AddOrUpdate<Infrastructures.Jobs.AutoPenaltyJob>(
                "auto-penalty-check",
                job => job.Execute(),
                "30 10 * * *",  // Cron: 10:30 AM hA�ng ngA�y (sau CutoffTime m���c �`��<nh 10:00 AM)
                new RecurringJobOptions
                {
                    TimeZone = TimeZoneInfo.FindSystemTimeZoneById("SE Asia Standard Time")
                });

            app.Run();
        }
    }
}