satellite-provider/SatelliteProvider.Api/Program.cs

using System.ComponentModel.DataAnnotations;
using Microsoft.AspNetCore.Mvc;
using Microsoft.OpenApi.Models;
using Swashbuckle.AspNetCore.SwaggerGen;
using SatelliteProvider.DataAccess;
using SatelliteProvider.DataAccess.Repositories;
using SatelliteProvider.Common.Configs;
using SatelliteProvider.Common.DTO;
using SatelliteProvider.Common.Interfaces;
using SatelliteProvider.Services.RegionProcessing;
using SatelliteProvider.Services.RouteManagement;
using SatelliteProvider.Services.TileDownloader;
using Serilog;

var builder = WebApplication.CreateBuilder(args);

builder.Host.UseSerilog((context, configuration) => 
    configuration.ReadFrom.Configuration(context.Configuration));

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection") 
    ?? throw new InvalidOperationException("Connection string 'DefaultConnection' not found.");

builder.Services.Configure<MapConfig>(builder.Configuration.GetSection("MapConfig"));
builder.Services.Configure<StorageConfig>(builder.Configuration.GetSection("StorageConfig"));
builder.Services.Configure<ProcessingConfig>(builder.Configuration.GetSection("ProcessingConfig"));

builder.Services.AddSingleton<ITileRepository>(sp => new TileRepository(connectionString, sp.GetRequiredService<ILogger<TileRepository>>()));
builder.Services.AddSingleton<IRegionRepository>(sp => new RegionRepository(connectionString, sp.GetRequiredService<ILogger<RegionRepository>>()));
builder.Services.AddSingleton<IRouteRepository>(sp => new RouteRepository(connectionString, sp.GetRequiredService<ILogger<RouteRepository>>()));

builder.Services.AddHttpClient();

builder.Services.AddTileDownloader();
builder.Services.AddRegionProcessing();
builder.Services.AddRouteManagement();

var allowedOrigins = builder.Configuration.GetSection("CorsConfig:AllowedOrigins").Get<string[]>() ?? Array.Empty<string>();
builder.Services.AddCors(options =>
{
    options.AddPolicy("TilesCors", policy =>
    {
        if (allowedOrigins.Length > 0)
            policy.WithOrigins(allowedOrigins).AllowAnyHeader().AllowAnyMethod();
        else
            policy.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod();
    });
});

builder.Services.ConfigureHttpJsonOptions(options =>
{
    options.SerializerOptions.PropertyNamingPolicy = System.Text.Json.JsonNamingPolicy.CamelCase;
    options.SerializerOptions.PropertyNameCaseInsensitive = true;
});

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo { Title = "Satellite Provider API", Version = "v1" });
    
    c.MapType<UploadImageRequest>(() => new OpenApiSchema
    {
        Type = "object",
        Properties = new Dictionary<string, OpenApiSchema>
        {
            ["timestamp"] = new() { Type = "string", Format = "date-time", Description = "Image capture timestamp" },
            ["image"] = new() { Type = "string", Format = "binary", Description = "Image file to upload" },
            ["lat"] = new() { Type = "number", Format = "double", Description = "Latitude coordinate where image was captured" },
            ["lon"] = new() { Type = "number", Format = "double", Description = "Longitude coordinate where image was captured" },
            ["height"] = new() { Type = "number", Format = "double", Description = "Height/altitude in meters where image was captured" },
            ["focalLength"] = new() { Type = "number", Format = "double", Description = "Camera focal length in millimeters" },
            ["sensorWidth"] = new() { Type = "number", Format = "double", Description = "Camera sensor width in millimeters" },
            ["sensorHeight"] = new() { Type = "number", Format = "double", Description = "Camera sensor height in millimeters" }
        },
        Required = new HashSet<string> { "timestamp", "image", "lat", "lon", "height", "focalLength", "sensorWidth", "sensorHeight" }
    });
    
    c.OperationFilter<ParameterDescriptionFilter>();
});

var app = builder.Build();

var logger = app.Services.GetRequiredService<ILogger<Program>>();
var migrator = new DatabaseMigrator(connectionString, logger as ILogger<DatabaseMigrator>);
if (!migrator.RunMigrations())
{
    throw new Exception("Database migration failed. Application cannot start.");
}

var storageConfig = app.Configuration.GetSection("StorageConfig").Get<StorageConfig>() ?? new StorageConfig();
Directory.CreateDirectory(storageConfig.TilesDirectory);
Directory.CreateDirectory(storageConfig.ReadyDirectory);

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();
app.UseCors("TilesCors");

app.MapGet("/tiles/{z:int}/{x:int}/{y:int}", ServeTile)
    .WithOpenApi(op => new(op) { Summary = "Get satellite tile image by z/x/y coordinates (Slippy Map tile server)" });

app.MapGet("/api/satellite/tiles/latlon", GetTileByLatLon)
    .WithOpenApi(op => new(op) { Summary = "Get satellite tile by latitude and longitude coordinates" });

app.MapGet("/api/satellite/tiles/mgrs", GetSatelliteTilesByMgrs)
    .WithOpenApi(op => new(op) { Summary = "Get satellite tiles by MGRS coordinates" });

app.MapPost("/api/satellite/upload", UploadImage)
    .Accepts<UploadImageRequest>("multipart/form-data")
    .WithOpenApi(op => new(op) { Summary = "Upload image with metadata and save to /maps folder" })
    .DisableAntiforgery();

app.MapPost("/api/satellite/request", RequestRegion)
    .WithOpenApi(op => new(op) { Summary = "Request tiles for a region" });

app.MapGet("/api/satellite/region/{id:guid}", GetRegionStatus)
    .WithOpenApi(op => new(op) { Summary = "Get region status and file paths" });

app.MapPost("/api/satellite/route", CreateRoute)
    .WithOpenApi(op => new(op) { Summary = "Create a route with intermediate points" });

app.MapGet("/api/satellite/route/{id:guid}", GetRoute)
    .WithOpenApi(op => new(op) { Summary = "Get route information with calculated points" });

app.Run();

async Task<IResult> ServeTile(int z, int x, int y, HttpContext httpContext, ITileService tileService, ILogger<Program> logger)
{
    try
    {
        var tile = await tileService.GetOrDownloadTileAsync(z, x, y, httpContext.RequestAborted);
        httpContext.Response.Headers.CacheControl = $"public, max-age={(long)tile.MaxAge.TotalSeconds}";
        httpContext.Response.Headers.ETag = tile.ETag;
        return Results.Bytes(tile.Bytes, tile.ContentType);
    }
    catch (Exception ex)
    {
        logger.LogError(ex, "Failed to serve tile {Z}/{X}/{Y}", z, x, y);
        return Results.Problem(detail: ex.Message, statusCode: 500);
    }
}

async Task<IResult> GetTileByLatLon([FromQuery] double Latitude, [FromQuery] double Longitude, [FromQuery] int ZoomLevel, ITileService tileService, ILogger<Program> logger)
{
    try
    {
        var tile = await tileService.DownloadAndStoreSingleTileAsync(Latitude, Longitude, ZoomLevel);

        var response = new DownloadTileResponse
        {
            Id = tile.Id,
            ZoomLevel = tile.TileZoom,
            Latitude = tile.Latitude,
            Longitude = tile.Longitude,
            TileSizeMeters = tile.TileSizeMeters,
            TileSizePixels = tile.TileSizePixels,
            ImageType = tile.ImageType,
            MapsVersion = tile.MapsVersion,
            Version = tile.Version,
            FilePath = tile.FilePath,
            CreatedAt = tile.CreatedAt,
            UpdatedAt = tile.UpdatedAt
        };

        return Results.Ok(response);
    }
    catch (Exception ex)
    {
        logger.LogError(ex, "Failed to get tile");
        return Results.Problem(detail: ex.Message, statusCode: 500);
    }
}

IResult GetSatelliteTilesByMgrs(string mgrs, double squareSideMeters)
{
    return Results.Ok(new GetSatelliteTilesResponse());
}

IResult UploadImage([FromForm] UploadImageRequest request)
{
    return Results.Ok(new SaveResult { Success = false });
}

async Task<IResult> RequestRegion([FromBody] RequestRegionRequest request, IRegionService regionService, ILogger<Program> logger)
{
    try
    {
        if (request.SizeMeters < 100 || request.SizeMeters > 10000)
        {
            return Results.BadRequest(new { error = "Size must be between 100 and 10000 meters" });
        }

        var status = await regionService.RequestRegionAsync(
            request.Id, 
            request.Latitude, 
            request.Longitude, 
            request.SizeMeters,
            request.ZoomLevel,
            request.StitchTiles);

        return Results.Ok(status);
    }
    catch (Exception ex)
    {
        logger.LogError(ex, "Failed to request region");
        return Results.Problem(detail: ex.Message, statusCode: 500);
    }
}

async Task<IResult> GetRegionStatus(Guid id, IRegionService regionService, ILogger<Program> logger)
{
    try
    {
        var status = await regionService.GetRegionStatusAsync(id);
        
        if (status == null)
        {
            return Results.NotFound(new { error = $"Region {id} not found" });
        }

        return Results.Ok(status);
    }
    catch (Exception ex)
    {
        logger.LogError(ex, "Failed to get region status");
        return Results.Problem(detail: ex.Message, statusCode: 500);
    }
}

async Task<IResult> CreateRoute([FromBody] CreateRouteRequest request, IRouteService routeService, ILogger<Program> logger)
{
    try
    {
        var route = await routeService.CreateRouteAsync(request);
        return Results.Ok(route);
    }
    catch (ArgumentException ex)
    {
        logger.LogWarning(ex, "Invalid route request");
        return Results.BadRequest(new { error = ex.Message });
    }
    catch (Exception ex)
    {
        logger.LogError(ex, "Failed to create route");
        return Results.Problem(detail: ex.Message, statusCode: 500);
    }
}

async Task<IResult> GetRoute(Guid id, IRouteService routeService, ILogger<Program> logger)
{
    try
    {
        var route = await routeService.GetRouteAsync(id);
        
        if (route == null)
        {
            return Results.NotFound(new { error = $"Route {id} not found" });
        }

        return Results.Ok(route);
    }
    catch (Exception ex)
    {
        logger.LogError(ex, "Failed to get route");
        return Results.Problem(detail: ex.Message, statusCode: 500);
    }
}

public record GetSatelliteTilesResponse
{
    public List<SatelliteTile> Tiles { get; set; } = new();
}

public record SatelliteTile
{
    public string TileId { get; set; } = string.Empty;
    public byte[] ImageData { get; set; } = Array.Empty<byte>();
    public double Lat { get; set; }
    public double Lon { get; set; }
    public int ZoomLevel { get; set; }
}

public record UploadImageRequest
{
    [Required]
    public DateTime Timestamp { get; set; }
    
    [Required]
    public IFormFile? Image { get; set; }
    
    [Required]
    public double Lat { get; set; }
    
    [Required]
    public double Lon { get; set; }
    
    [Required]
    public double Height { get; set; }
    
    [Required]
    public double FocalLength { get; set; }
    
    [Required]
    public double SensorWidth { get; set; }
    
    [Required]
    public double SensorHeight { get; set; }
}

public record SaveResult
{
    public bool Success { get; set; }
    public string? Exception { get; set; }
}

public record DownloadTileResponse
{
    public Guid Id { get; set; }
    public int ZoomLevel { get; set; }
    public double Latitude { get; set; }
    public double Longitude { get; set; }
    public double TileSizeMeters { get; set; }
    public int TileSizePixels { get; set; }
    public string ImageType { get; set; } = string.Empty;
    public string? MapsVersion { get; set; }
    public int Version { get; set; }
    public string FilePath { get; set; } = string.Empty;
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}

public record RequestRegionRequest
{
    [Required]
    public Guid Id { get; set; }
    
    [Required]
    public double Latitude { get; set; }
    
    [Required]
    public double Longitude { get; set; }
    
    [Required]
    public double SizeMeters { get; set; }
    
    [Required]
    public int ZoomLevel { get; set; } = 18;
    
    public bool StitchTiles { get; set; } = false;
}

public class ParameterDescriptionFilter : IOperationFilter
{
    public void Apply(OpenApiOperation operation, OperationFilterContext context)
    {
        if (operation.Parameters == null) return;

        var parameterDescriptions = new Dictionary<string, string>
        {
            ["lat"] = "Latitude coordinate where image was captured",
            ["lon"] = "Longitude coordinate where image was captured",
            ["mgrs"] = "MGRS coordinate string",
            ["squareSideMeters"] = "Square side size in meters",
            ["Latitude"] = "Latitude coordinate of the tile center",
            ["Longitude"] = "Longitude coordinate of the tile center",
            ["ZoomLevel"] = "Zoom level for the tile (higher values = more detail)"
        };

        foreach (var parameter in operation.Parameters)
        {
            if (parameterDescriptions.TryGetValue(parameter.Name, out var description))
            {
                parameter.Description = description;
            }
        }
    }
}