using EonaCat.Logger;
using EonaCat.Logger.EonaCatCoreLogger;
using EonaCat.Logger.EonaCatCoreLogger.Extensions;
using EonaCat.Logger.EonaCatCoreLogger.Models;
using EonaCat.Logger.Managers;
using EonaCat.Logger.Test.Web;
using EonaCat.Web.RateLimiter;
using EonaCat.Web.RateLimiter.Endpoints.Extensions;
using EonaCat.Web.Tracer.Extensions;

var builder = WebApplication.CreateBuilder(args);
int onLogCounter = 0;
var defaultColor = Console.ForegroundColor;

// Add services to the container.
Logger logger = new Logger();
logger.UseLocalTime = true;
logger.MaxLogType = ELogType.TRACE;
logger.LoggerSettings.OnLog += LoggerSettings_OnLog;

void LoggerSettings_OnLog(EonaCatLogMessage message)
{
    Console.ForegroundColor = ConsoleColor.Yellow;
    Console.WriteLine($"LogCounter: {++onLogCounter} {message}");
    Console.ForegroundColor = defaultColor;
}

var options = new FileLoggerOptions();
options.MaxRolloverFiles = 5;
//options.FileSizeLimit = 1 * 1024 * 1024 / 4;
options.UseLocalTime = true;
builder.Logging.AddEonaCatFileLogger(fileLoggerOptions: options, filenamePrefix: "web");

builder.Services.AddRazorPages();

//var rateLimitOptions = new RateLimitOptions
//{
//    Capacity = 10,
//    Duration = TimeSpan.FromMinutes(1)
//};

//builder.Services.AddRateLimiting(rateLimitOptions);
var rateOptions = new RateLimiterOptions();
rateOptions.OutputLimitMessageAsHtml = false;
rateOptions.OutputLimitMessageAsXml = false;
rateOptions.OutputLimitMessageAsJson = true;

rateOptions.AddDefaultConfiguration(config =>
    config.AddIpResolver().AddRule(3, TimeSpan.FromSeconds(10))
);

RateLimiterMiddleware.OnLimitResponseCreated += RateLimiterMiddlewareOnLimitResponseCreatedAsync;

async void RateLimiterMiddlewareOnLimitResponseCreatedAsync(object? sender, HttpContext httpContext)
{
    await httpContext.Response.WriteAsync(" THIS IS MY CUSTOM RATE LIMIT MESSAGE").ConfigureAwait(false);
}

//builder.Services.UseWebRateLimiter(rateOptions);
builder.Services.UseWebRateLimiter(rateOptions);
builder.Services.UseWebRateLimiter(rateOptions =>
{
    // Configures the default rateLimitConfiguration
    rateOptions.AddDefaultConfiguration(rateLimitConfiguration =>
    {
        // throttling is based on request ip
        rateLimitConfiguration.AddIpResolver()
            // add general rules for all ips
            .AddRule(3, TimeSpan.FromSeconds(10)) // 3 requests could be called every 10 seconds
            .AddRule(30, TimeSpan.FromMinutes(1)) // 30 requests could be called every 1 minute
            .AddRule(500, TimeSpan.FromHours(1)); // 500 requests could be called every 1 hour
    });
});
builder.Services.AddMemoryCache();


var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

//EonaCat.Web.RateLimiter.RateLimiterOptions options = new EonaCat.Web.RateLimiter.RateLimiterOptions();
//options.LimitMessage = "FUCKING NOOB!";
//options.WriteLimitMessageToResponse = true;
//options.WriteLimitMessageStatusCodeToResponse = true;
//app.UseRateLimiter(options);
//RateLimiterMiddleware.OnLimitResponseCreated += RateLimiterMiddleware_OnLimitResponseCreatedAsync;
//async void RateLimiterMiddleware_OnLimitResponseCreatedAsync(object? sender, HttpContext httpContext)
//{
//    await httpContext.Response.WriteAsync("THIS IS MY CUSTOM RATE LIMIT MESSAGE");
//}
WebTracer.OnLog += WebTracer_OnLog;

void WebTracer_OnLog(object? sender, string e)
{
    Console.WriteLine(e);
}
//app.UseWebTracer();

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

app.UseRouting();
app.UseAuthorization();
app.UseWebRateLimiter();

app.MapRazorPages().RateLimit();

void RunLoggingExceptionTests()
{
    var loggerSettings = new LoggerSettings();
    loggerSettings.FileLoggerOptions.UseLocalTime = true;
    loggerSettings.UseLocalTime = true;
    loggerSettings.MaxLogType = ELogType.INFO;
    var logger = new LogManager(loggerSettings);

    for (var i = 0; i < 10; i++)
    {
        try
        {
            throw new Exception($"Normal Exception {i}");
        }
        catch (Exception exception)
        {
            logger.WriteAsync(exception).ConfigureAwait(false);
            Console.WriteLine($"Normal ExceptionLogged: {i}");
        }

        Task.Delay(1);
    }
}

await Task.Run(RunWebLoggerTestsAsync).ConfigureAwait(false);
await Task.Run(RunWebLoggingTests).ConfigureAwait(false);
await Task.Run(RunLoggingTestsAsync).ConfigureAwait(false);
await Task.Run(RunLoggingExceptionTests).ConfigureAwait(false);
await Task.Run(RunWebLoggingExceptionTests).ConfigureAwait(false);

void RunWebLoggingExceptionTests()
{
    for (var i = 0; i < 10; i++)
    {
        try
        {
            throw new Exception($"WebException {i}");
        }
        catch (Exception exception)
        {
            app.Logger.LogCritical(exception, "CRITICAL");
            app.Logger.LogDebug(exception, "DEBUG");
            app.Logger.LogError(exception, "ERROR");
            app.Logger.LogTrace(exception, "TRACE");
            app.Logger.LogWarning(exception, "WARNING");
            app.Logger.LogInformation(exception, "INFORMATION");
            Console.WriteLine($"WebExceptionLogged: {i}");
        }

        Task.Delay(1);
    }
}

async void RunWebLoggingTests()
{
    if (!Directory.Exists(logger.LogFolder))
    {
        Directory.CreateDirectory(logger.LogFolder);
    }

    for (var i = 0; i < 9000000; i++)
    {
        app.Logger.LogInformation($"web-test {i}");
        using (var file = new StreamWriter(Path.Combine(logger.LogFolder, "test.log"), true))
        {
            await file.WriteAsync($"WebLogged: {i}{Environment.NewLine}").ConfigureAwait(false);
        }
        Console.WriteLine($"WebLogged: {i}");
        Task.Delay(1);
    }
}

async Task RunLoggingTestsAsync()
{
    var loggerSettings = new LoggerSettings();
    loggerSettings.UseLocalTime = true;
    loggerSettings.FileLoggerOptions.UseLocalTime = true;
    loggerSettings.MaxLogType = ELogType.DEBUG;
    loggerSettings.FileLoggerOptions.FileSizeLimit = 1024 * 1024 * 1;
    loggerSettings.FileLoggerOptions.FileNamePrefix = "AllTypes";
    loggerSettings.FileLoggerOptions.MaxRolloverFiles = 5;
    var logger = new LogManager(loggerSettings);

    for (var i = 0; i < 9000000; i++)
    {
        await logger.WriteAsync($"test to file {i} INFO").ConfigureAwait(false);
        await logger.WriteAsync($"test to file {i} CRITICAL", ELogType.CRITICAL).ConfigureAwait(false);
        await logger.WriteAsync($"test to file {i} DEBUG", ELogType.DEBUG).ConfigureAwait(false);
        await logger.WriteAsync($"test to file {i} ERROR", ELogType.ERROR).ConfigureAwait(false);
        await logger.WriteAsync($"test to file {i} TRACE", ELogType.TRACE).ConfigureAwait(false);
        await logger.WriteAsync($"test to file {i} TRAFFIC", ELogType.TRAFFIC).ConfigureAwait(false);
        await logger.WriteAsync($"test to file {i} WARNING", ELogType.WARNING).ConfigureAwait(false);
        await logger.WriteAsync($"test to file {i} NONE", ELogType.NONE).ConfigureAwait(false);
        Console.WriteLine($"Logged: {i}");
        await Task.Delay(1).ConfigureAwait(false);
    }
}

async Task RunWebLoggerTestsAsync()
{
    var i = 0;
    while (true)
    {
        i++;
        await Task.Run(async () =>
        {
            await logger.LogAsync($"test via logger {i} INFO").ConfigureAwait(false);
            await logger.LogAsync($"test via logger {i} CRITICAL", ELogType.CRITICAL).ConfigureAwait(false);
            await logger.LogAsync($"test via logger {i} DEBUG", ELogType.DEBUG).ConfigureAwait(false);
            await logger.LogAsync($"test via logger {i} ERROR", ELogType.ERROR).ConfigureAwait(false);
            await logger.LogAsync($"test via logger {i} TRACE", ELogType.TRACE).ConfigureAwait(false);
            await logger.LogAsync($"test via logger {i} TRAFFIC", ELogType.TRAFFIC).ConfigureAwait(false);
            await logger.LogAsync($"test via logger {i} WARNING", ELogType.WARNING).ConfigureAwait(false);
            await logger.LogAsync($"test via logger {i} NONE", ELogType.NONE).ConfigureAwait(false);
        }).ConfigureAwait(false);
        await Task.Delay(1).ConfigureAwait(false);
    }
}

app.Run();