DiunaBI/src/Backend/DiunaBI.API/Program.cs

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Reflection;
using System.Text;
using DiunaBI.API.Services;
using DiunaBI.Infrastructure.Data;
using DiunaBI.Infrastructure.Services;
using Google.Apis.Sheets.v4;
using Serilog;

var builder = WebApplication.CreateBuilder(args);

if (builder.Environment.IsProduction())
{
    builder.Host.UseSerilog((context, configuration) =>
    {
        var instanceName = context.Configuration["InstanceName"] ?? "unknown";
        configuration
            .ReadFrom.Configuration(context.Configuration)
            .Enrich.FromLogContext()
            .Enrich.WithProperty("Application", $"DiunaBI-{instanceName}")
            .Enrich.WithProperty("Version", Assembly.GetExecutingAssembly().GetName().Version?.ToString() ?? "unknown")
            .Enrich.WithEnvironmentName()
            .Enrich.WithMachineName();
    });
}

var connectionString = builder.Configuration.GetConnectionString("SQLDatabase");

builder.Services.AddDbContext<AppDbContext>(x =>
{
    x.UseSqlServer(connectionString);
    x.EnableSensitiveDataLogging();
});

builder.Services.AddCors(options =>
{
    options.AddPolicy("CORSPolicy", corsPolicyBuilder =>
    {
        corsPolicyBuilder.WithOrigins("http://localhost:4200")
        .AllowAnyMethod()
        .AllowAnyHeader()
        .AllowCredentials();

        corsPolicyBuilder.WithOrigins("https://diuna.bim-it.pl")
        .AllowAnyMethod()
        .AllowAnyHeader()
        .AllowCredentials();
        
        corsPolicyBuilder.WithOrigins("https://morska.diunabi.com")
            .AllowAnyMethod()
            .AllowAnyHeader()
            .AllowCredentials();
    });
});

builder.Services.AddControllers();

builder.Services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(options =>
{
    options.TokenValidationParameters = new TokenValidationParameters
    {
        ValidateIssuer = false,
        ValidateAudience = false,
        ValidateLifetime = true,
        ValidateIssuerSigningKey = true,
        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["JwtSettings:SecurityKey"]!))
    };
});

builder.Services.AddScoped<GoogleAuthService>();
builder.Services.AddScoped<JwtTokenService>();

// Google Sheets dependencies
Console.WriteLine("Adding Google Sheets dependencies...");
builder.Services.AddSingleton<GoogleSheetsHelper>();
builder.Services.AddSingleton<GoogleDriveHelper>();
builder.Services.AddSingleton<SpreadsheetsResource.ValuesResource>(provider =>
{
    var googleSheetsHelper = provider.GetRequiredService<GoogleSheetsHelper>();
    var valuesResource = googleSheetsHelper.Service?.Spreadsheets.Values;

    if (valuesResource == null)
    {
        throw new InvalidOperationException("Google Sheets Service is not initialized properly");
    }

    return valuesResource;
});

builder.Services.AddSingleton<PluginManager>();

var app = builder.Build();

if (app.Environment.IsProduction())
{
    app.UseSerilogRequestLogging(options =>
    {
        options.MessageTemplate = "HTTP {RequestMethod} {RequestPath} responded {StatusCode} in {Elapsed:0.0000} ms";
        options.EnrichDiagnosticContext = (diagnosticContext, httpContext) =>
        {
            diagnosticContext.Set("RequestHost", httpContext.Request.Host.Value);
            diagnosticContext.Set("RequestScheme", httpContext.Request.Scheme);

            var userAgent = httpContext.Request.Headers.UserAgent.FirstOrDefault();
            if (!string.IsNullOrEmpty(userAgent))
            {
                diagnosticContext.Set("UserAgent", userAgent);
            }

            diagnosticContext.Set("RemoteIP", httpContext.Connection.RemoteIpAddress?.ToString() ?? "unknown");
            diagnosticContext.Set("RequestContentType", httpContext.Request.ContentType ?? "none");
        };
    });
}

// Plugin initialization
var pluginManager = app.Services.GetRequiredService<PluginManager>();
var executablePath = Assembly.GetExecutingAssembly().Location;
var executableDir = Path.GetDirectoryName(executablePath)!;
var pluginsPath = Path.Combine(executableDir, "Plugins");

if (app.Environment.IsProduction())
{
    Log.Information("Starting DiunaBI application");
    Log.Information("Loading plugins from: {PluginsPath}", pluginsPath);
}
else
{
    var logger = app.Services.GetRequiredService<ILogger<Program>>();
    logger.LogInformation("Starting DiunaBI application (Development)");
    logger.LogInformation("Loading plugins from: {PluginsPath}", pluginsPath);
}

pluginManager.LoadPluginsFromDirectory(pluginsPath);

app.Use(async (context, next) =>
{
    var token = context.Request.Headers.Authorization.ToString();
    if (token.Length > 0
        && !context.Request.Path.ToString().Contains("getForPowerBI")
        && !context.Request.Path.ToString().Contains("getConfiguration")
        && !context.Request.Path.ToString().Contains("DataInbox/Add"))
    {
        var handler = new JwtSecurityTokenHandler();
        var data = handler.ReadJwtToken(token.Split(' ')[1]);
        context.Request.Headers.Append("UserId", new Microsoft.Extensions.Primitives.StringValues(data.Subject));
    }
    await next(context);
});

app.UseCors("CORSPolicy");

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

app.MapControllers();

app.MapGet("/health", () => Results.Ok(new { status = "OK", timestamp = DateTime.UtcNow }))
    .AllowAnonymous();

app.Run();

if (app.Environment.IsProduction())
{
    Log.CloseAndFlush();
}
// for testing purposes
public partial class Program { }