
using Microsoft.EntityFrameworkCore;
using DF.AppUsage.Api.Data;
using DF.AppUsage.Api.Services; 
using System.Text.Json;

var builder = WebApplication.CreateBuilder(args);

// 1. Datenbank-Anbindung
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseNpgsql(connectionString));

// 2. Swagger/OpenAPI für Tests (bleibt drin, ist nützlich!)
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Dashboard service
builder.Services.AddScoped<DashboardService>();

// unser Azure Import Service "Staubsauger"
builder.Services.AddHostedService<AzureImportService>();

var app = builder.Build();

// AUTOMATISCHE MIGRATION BEIM START
using (var scope = app.Services.CreateScope())
{
    var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
    db.Database.Migrate(); // Das erstellt die Tabellen, falls sie fehlen
}

// 3. HTTP-Pipeline konfigurieren
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

// Hier lassen wir erst mal eine leere Lücke für unsere 
// zukünftigen API-Endpunkte (Query-Interface).

// ENDPUNKTE
app.MapGet("/", () => Results.Redirect("/dashboard"));

app.MapGet("/dashboard", async (DashboardService dashboard) => 
{
    var html = await dashboard.GetDashboardHtmlAsync();
    return Results.Content(html, "text/html");
});

app.MapGet("/api/export/{type}", async (string type, AppDbContext db) =>
{
    var entries = await db.InsightEntries
        .Where(e => e.InsightType == type)
        .OrderByDescending(e => e.Timestamp)
        .Take(10000) // Großzügiges Limit für Power BI
        .ToListAsync();

    var flatList = entries.Select(e =>
    {
        // Wir erstellen ein Dictionary für die flache Struktur
        var flatEntry = new Dictionary<string, object?>();

        // Basis-Daten hinzufügen
        flatEntry["Timestamp"] = e.Timestamp;
        flatEntry["InsightType"] = e.InsightType;
        flatEntry["ExternalId"] = e.ExternalId;

        // Jetzt alle Felder aus dem JSON-"Properties"-Zweig flachklopfen
        if (e.Data.RootElement.TryGetProperty("Properties", out var props))
        {
            foreach (var prop in props.EnumerateObject())
            {
                // Wir fügen jedes Feld aus dem JSON direkt als Spalte hinzu
                // Wert-Typen werden automatisch konvertiert
                flatEntry[prop.Name] = prop.Value.ValueKind switch
                {
                    JsonValueKind.Number => prop.Value.GetDouble(),
                    JsonValueKind.True => true,
                    JsonValueKind.False => false,
                    _ => prop.Value.GetString()
                };
            }
        }
        return flatEntry;
    });

    return Results.Ok(flatList);
});

// --- TEST ENDPUNKTE ---

// 1. Übersicht: Wie viele Daten haben wir?
app.MapGet("/stats", async (AppDbContext db) =>
{
    var stats = await db.InsightEntries
        .GroupBy(e => e.InsightType)
        .Select(g => new
        {
            Typ = g.Key,
            Anzahl = g.Count(),
            LetzterEintrag = g.Max(e => e.Timestamp)
        })
        .ToListAsync();

    return stats.Any() ? Results.Ok(stats) : Results.NotFound("Noch keine Daten vorhanden.");
})
.WithName("GetStats");

// 2. Die neuesten 5 Einträge eines Typs ansehen
app.MapGet("/latest/{type}", async (string type, AppDbContext db) =>
{
    var entries = await db.InsightEntries
        .Where(e => e.InsightType == type)
        .OrderByDescending(e => e.Timestamp)
        .Take(5)
        .ToListAsync();

    return Results.Ok(entries);
})
.WithName("GetLatest");


app.Run();