using BCards.Web.Configuration;
using BCards.Web.Services;
using BCards.Web.Repositories;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Authentication.Google;
using Microsoft.AspNetCore.Authentication.MicrosoftAccount;
using Microsoft.AspNetCore.Localization;
using Microsoft.Extensions.Options;
using MongoDB.Driver;
using System.Globalization;
using Stripe;
using Microsoft.AspNetCore.Authentication.OAuth;
using SendGrid;
using BCards.Web.Middleware;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.HttpOverrides;

var builder = WebApplication.CreateBuilder(args);

// 🔥 CONFIGURAR FORWARDED HEADERS NO BUILDER
builder.Services.Configure<ForwardedHeadersOptions>(options =>
{
    options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
    options.RequireHeaderSymmetry = false;
    options.KnownNetworks.Clear();
    options.KnownProxies.Clear();
    // 🚨 PERMITIR QUALQUER PROXY (NGINX)
    options.ForwardLimit = null;
});

// Add services to the container.
builder.Services.AddControllersWithViews()
    .AddRazorRuntimeCompilation()
    .AddViewLocalization()
    .AddDataAnnotationsLocalization();

// MongoDB Configuration
builder.Services.Configure<MongoDbSettings>(
    builder.Configuration.GetSection("MongoDb"));

builder.Services.AddSingleton<IMongoClient>(serviceProvider =>
{
    var settings = serviceProvider.GetRequiredService<IOptions<MongoDbSettings>>().Value;
    return new MongoClient(settings.ConnectionString);
});

builder.Services.AddScoped(serviceProvider =>
{
    var client = serviceProvider.GetRequiredService<IMongoClient>();
    var settings = serviceProvider.GetRequiredService<IOptions<MongoDbSettings>>().Value;
    return client.GetDatabase(settings.DatabaseName);
});

// Stripe Configuration
builder.Services.Configure<StripeSettings>(
    builder.Configuration.GetSection("Stripe"));

// OAuth Configuration
builder.Services.Configure<GoogleAuthSettings>(
    builder.Configuration.GetSection("Authentication:Google"));

builder.Services.Configure<MicrosoftAuthSettings>(
    builder.Configuration.GetSection("Authentication:Microsoft"));

// Adicionar configurações
builder.Services.Configure<ModerationSettings>(
    builder.Configuration.GetSection("Moderation"));

// Authentication
builder.Services.AddAuthentication(options =>
{
    options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = GoogleDefaults.AuthenticationScheme;
})
.AddCookie(options =>
{
    options.LoginPath = "/Auth/Login";
    options.LogoutPath = "/Auth/Logout";
    options.ExpireTimeSpan = TimeSpan.FromDays(30);
    options.SlidingExpiration = true;
})
.AddGoogle(options =>
{
    var googleAuth = builder.Configuration.GetSection("Authentication:Google");
    options.ClientId = googleAuth["ClientId"] ?? "";
    options.ClientSecret = googleAuth["ClientSecret"] ?? "";
})
.AddMicrosoftAccount(options =>
{
    var msAuth = builder.Configuration.GetSection("Authentication:Microsoft");
    options.ClientId = msAuth["ClientId"] ?? "";
    options.ClientSecret = msAuth["ClientSecret"] ?? "";
    options.CallbackPath = "/signin-microsoft";

    // Força seleção de conta a cada login
    options.AuthorizationEndpoint = "https://login.microsoftonline.com/common/oauth2/v2.0/authorize";
    options.TokenEndpoint = "https://login.microsoftonline.com/common/oauth2/v2.0/token";

    // 🔥 SOLUÇÃO RADICAL: SEMPRE FORÇAR HTTPS
    options.Events = new OAuthEvents
    {
        OnRedirectToAuthorizationEndpoint = context =>
        {
            var logger = context.HttpContext.RequestServices.GetRequiredService<ILogger<Program>>();

            // Debug info
            logger.LogWarning($"=== MICROSOFT AUTH DEBUG ===");
            logger.LogWarning($"Original RedirectUri: {context.RedirectUri}");
            logger.LogWarning($"Request Scheme: {context.Request.Scheme}");
            logger.LogWarning($"Request IsHttps: {context.Request.IsHttps}");
            logger.LogWarning($"Request Host: {context.Request.Host}");
            logger.LogWarning($"X-Forwarded-Proto: {context.Request.Headers["X-Forwarded-Proto"]}");

            // 🚨 FORÇA HTTPS SEMPRE (exceto localhost)
            var originalUri = context.RedirectUri;

            // Se contém bcards.site, força HTTPS
            if (originalUri.Contains("bcards.site"))
            {
                context.RedirectUri = originalUri
                    .Replace("http://bcards.site", "https://bcards.site")
                    .Replace("http%3A%2F%2Fbcards.site", "https%3A%2F%2Fbcards.site");

                logger.LogWarning($"FORCED HTTPS - Modified RedirectUri: {context.RedirectUri}");
            }

            // Adiciona prompt=login para forçar seleção de conta
            var redirectUri = context.RedirectUri;
            if (!redirectUri.Contains("prompt="))
            {
                redirectUri += "&prompt=login";
            }

            logger.LogWarning($"Final RedirectUri: {redirectUri}");

            context.Response.Redirect(redirectUri);
            return Task.CompletedTask;
        }
    };
});

// Localization
builder.Services.AddLocalization(options => options.ResourcesPath = "Resources");

builder.Services.Configure<RequestLocalizationOptions>(options =>
{
    var supportedCultures = new[]
    {
        new CultureInfo("pt-BR"),
        new CultureInfo("es-ES")
    };

    options.DefaultRequestCulture = new RequestCulture("pt-BR");
    options.SupportedCultures = supportedCultures;
    options.SupportedUICultures = supportedCultures;
});

// Register Services
builder.Services.AddScoped<IUserRepository, UserRepository>();
builder.Services.AddScoped<IUserPageRepository, UserPageRepository>();
builder.Services.AddScoped<ICategoryRepository, CategoryRepository>();
builder.Services.AddScoped<ISubscriptionRepository, SubscriptionRepository>();
builder.Services.AddSingleton<IModerationAuthService, ModerationAuthService>();
//builder.Services.AddScoped<IModerationAuthService, ModerationAuthService>();

builder.Services.AddScoped<IUserPageService, UserPageService>();
builder.Services.AddScoped<IThemeService, ThemeService>();
builder.Services.AddScoped<ISeoService, SeoService>();
builder.Services.AddScoped<IAuthService, AuthService>();
builder.Services.AddScoped<IPaymentService, PaymentService>();
builder.Services.AddScoped<ICategoryService, CategoryService>();
builder.Services.AddScoped<IOpenGraphService, OpenGraphService>();
builder.Services.AddScoped<IModerationService, ModerationService>();
builder.Services.AddScoped<IEmailService, EmailService>();

// Image Storage Service
builder.Services.AddScoped<IImageStorageService, GridFSImageStorage>();

// Configure upload limits for file uploads
builder.Services.Configure<FormOptions>(options =>
{
    options.MultipartBodyLengthLimit = 10 * 1024 * 1024; // 10MB for forms with files
    options.ValueLengthLimit = int.MaxValue;
    options.ValueCountLimit = int.MaxValue;
    options.KeyLengthLimit = int.MaxValue;
});

// 🔥 NOVO: LivePage Services
builder.Services.AddScoped<ILivePageRepository, LivePageRepository>();
builder.Services.AddScoped<ILivePageService, LivePageService>();

// Add HttpClient for OpenGraphService
builder.Services.AddHttpClient<OpenGraphService>();

// Add SendGrid
builder.Services.AddSingleton<ISendGridClient>(provider =>
{
    var apiKey = builder.Configuration["SendGrid:ApiKey"];
    return new SendGridClient(apiKey);
});

// Background Services
builder.Services.AddHostedService<TrialExpirationService>();

// Response Caching
builder.Services.AddResponseCaching();
builder.Services.AddMemoryCache();

builder.Services.AddRazorPages();

var app = builder.Build();

// 🔥 PRIMEIRA COISA APÓS BUILD - FORWARDED HEADERS + BASE URL OVERRIDE
app.UseForwardedHeaders();

// 🚨 FORÇA BASE URL HTTPS EM PRODUÇÃO
if (!app.Environment.IsDevelopment())
{
    app.Use(async (context, next) =>
    {
        // Força o contexto a pensar que está em HTTPS
        context.Request.Scheme = "https";

        // Override do Host se necessário
        if (context.Request.Host.Host == "bcards.site")
        {
            context.Request.Host = new HostString("bcards.site", 443);
        }

        await next();
    });
}

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    app.UseHsts();
}

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

app.UseRouting();

app.UseRequestLocalization();

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

// Add custom middleware
app.UseMiddleware<BCards.Web.Middleware.PlanLimitationMiddleware>();
app.UseMiddleware<BCards.Web.Middleware.PageStatusMiddleware>();
app.UseMiddleware<BCards.Web.Middleware.PreviewTokenMiddleware>();
app.UseMiddleware<ModerationAuthMiddleware>();

// 🔥 DEBUG MIDDLEWARE MELHORADO
app.Use(async (context, next) =>
{
    // Debug geral
    Console.WriteLine($"=== REQUEST DEBUG ===");
    Console.WriteLine($"Path: {context.Request.Path}");
    Console.WriteLine($"Query: {context.Request.QueryString}");
    Console.WriteLine($"Method: {context.Request.Method}");
    Console.WriteLine($"Scheme: {context.Request.Scheme}");
    Console.WriteLine($"IsHttps: {context.Request.IsHttps}");
    Console.WriteLine($"Host: {context.Request.Host}");

    // Debug específico para Microsoft signin
    if (context.Request.Path.StartsWithSegments("/signin-microsoft"))
    {
        var logger = context.RequestServices.GetRequiredService<ILogger<Program>>();
        logger.LogWarning($"=== SIGNIN-MICROSOFT CALLBACK DEBUG ===");
        logger.LogWarning($"Path: {context.Request.Path}");
        logger.LogWarning($"Query: {context.Request.QueryString}");
        logger.LogWarning($"Method: {context.Request.Method}");
        logger.LogWarning($"Scheme: {context.Request.Scheme}");
        logger.LogWarning($"IsHttps: {context.Request.IsHttps}");
        logger.LogWarning($"Host: {context.Request.Host}");
        logger.LogWarning($"X-Forwarded-Proto: {context.Request.Headers["X-Forwarded-Proto"]}");
        logger.LogWarning($"X-Forwarded-For: {context.Request.Headers["X-Forwarded-For"]}");
        logger.LogWarning($"All Headers:");
        foreach (var header in context.Request.Headers)
        {
            logger.LogWarning($"  {header.Key}: {header.Value}");
        }
    }

    await next();
});

app.UseResponseCaching();

// Rotas específicas primeiro
app.MapControllerRoute(
    name: "userpage-preview-path",
    pattern: "page/preview/{category}/{slug}",
    defaults: new { controller = "UserPage", action = "Preview" },
    constraints: new { category = @"^[a-zA-Z-]+$", slug = @"^[a-z0-9-]+$" });

app.MapControllerRoute(
    name: "userpage-click",
    pattern: "page/click/{pageId}",
    defaults: new { controller = "UserPage", action = "RecordClick" });

app.MapControllerRoute(
    name: "moderation",
    pattern: "moderation/{action=Dashboard}/{id?}",
    defaults: new { controller = "Moderation" });

// Rota principal que vai pegar ?preview=token
//app.MapControllerRoute(
//    name: "userpage",
//    pattern: "page/{category}/{slug}",
//    defaults: new { controller = "UserPage", action = "Display" },
//    constraints: new { category = @"^[a-zA-Z-]+$", slug = @"^[a-z0-9-]+$" });

// 🔥 NOVA ROTA: LivePageController para páginas otimizadas de SEO
app.MapControllerRoute(
    name: "livepage",
    pattern: "page/{category}/{slug}",
    defaults: new { controller = "LivePage", action = "Display" },
    constraints: new
    {
        category = @"^[a-zA-Z0-9\-\u00C0-\u017F]+$", // ← Aceita acentos
        slug = @"^[a-z0-9-]+$"
    });

// Rota padrão por último
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

// Initialize default data
using (var scope = app.Services.CreateScope())
{
    var themeService = scope.ServiceProvider.GetRequiredService<IThemeService>();
    var categoryService = scope.ServiceProvider.GetRequiredService<ICategoryService>();

    try
    {
        // Initialize themes
        var existingThemes = await themeService.GetAvailableThemesAsync();
        if (!existingThemes.Any())
        {
            await themeService.InitializeDefaultThemesAsync();
        }

        // Initialize categories
        var existingCategories = await categoryService.GetAllCategoriesAsync();
        if (!existingCategories.Any())
        {
            await categoryService.InitializeDefaultCategoriesAsync();
        }
    }
    catch (Exception ex)
    {
        var logger = scope.ServiceProvider.GetRequiredService<ILogger<Program>>();
        logger.LogError(ex, "Error initializing default data");
    }
}

app.Run();

// Make Program accessible for integration tests
public partial class Program { }