using System.ComponentModel.DataAnnotations;
using Microsoft.AspNetCore.Mvc;
using Microsoft.OpenApi.Models;
using Swashbuckle.AspNetCore.SwaggerGen;
using SatelliteProvider.DataAccess;
using SatelliteProvider.DataAccess.Models;
using SatelliteProvider.DataAccess.Repositories;
using SatelliteProvider.Common.Configs;
using SatelliteProvider.Common.DTO;
using SatelliteProvider.Common.Interfaces;
using SatelliteProvider.Services;
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));
builder.Services.AddSingleton<IRegionRepository>(sp => new RegionRepository(connectionString));
builder.Services.AddSingleton<IRouteRepository>(sp => new RouteRepository(connectionString));

builder.Services.AddHttpClient();
builder.Services.AddSingleton<GoogleMapsDownloaderV2>();
builder.Services.AddSingleton<ITileService, TileService>();

var processingConfig = builder.Configuration.GetSection("ProcessingConfig").Get<ProcessingConfig>() ?? new ProcessingConfig();
builder.Services.AddSingleton<IRegionRequestQueue>(sp => new RegionRequestQueue(processingConfig.QueueCapacity));
builder.Services.AddSingleton<IRegionService, RegionService>();
builder.Services.AddHostedService<RegionProcessingService>();
builder.Services.AddSingleton<IRouteService, RouteService>();
builder.Services.AddHostedService<RouteProcessingService>();

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);
logger.LogInformation("Storage directories created: Tiles={TilesDir}, Ready={ReadyDir}", 
    storageConfig.TilesDirectory, storageConfig.ReadyDirectory);

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

app.UseHttpsRedirection();

app.MapGet("/api/satellite/tiles/latlon", GetSatelliteTilesByLatLon)
    .WithOpenApi(op => new(op) { Summary = "Get satellite tiles 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/tiles/download", DownloadSingleTile)
    .WithOpenApi(op => new(op) { Summary = "TEMPORARY: Download single tile at specified coordinates" });

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();

IResult GetSatelliteTilesByLatLon(double lat, double lon, double squareSideMeters)
{
    return Results.Ok(new GetSatelliteTilesResponse());
}

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> DownloadSingleTile([FromBody] DownloadTileRequest request, GoogleMapsDownloaderV2 downloader, ITileRepository tileRepository, ILogger<Program> logger)
{
    try
    {
        logger.LogInformation("Downloading single tile at ({Lat}, {Lon}) with zoom level {Zoom}", 
            request.Latitude, request.Longitude, request.ZoomLevel);

        var downloadedTile = await downloader.DownloadSingleTileAsync(
            request.Latitude,
            request.Longitude,
            request.ZoomLevel);

        var now = DateTime.UtcNow;
        var currentVersion = now.Year;
        var tileEntity = new TileEntity
        {
            Id = Guid.NewGuid(),
            ZoomLevel = downloadedTile.ZoomLevel,
            Latitude = downloadedTile.CenterLatitude,
            Longitude = downloadedTile.CenterLongitude,
            TileSizeMeters = downloadedTile.TileSizeMeters,
            TileSizePixels = 256,
            ImageType = "jpg",
            MapsVersion = $"downloaded_{now:yyyy-MM-dd}",
            Version = currentVersion,
            FilePath = downloadedTile.FilePath,
            CreatedAt = now,
            UpdatedAt = now
        };

        await tileRepository.InsertAsync(tileEntity);
        logger.LogInformation("Tile saved to database with ID: {Id}", tileEntity.Id);

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

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

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" });
        }

        logger.LogInformation("Region request received: ID={Id}, Lat={Lat}, Lon={Lon}, Size={Size}m, Zoom={Zoom}, Stitch={Stitch}",
            request.Id, request.Latitude, request.Longitude, request.SizeMeters, request.ZoomLevel, request.StitchTiles);

        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
    {
        logger.LogInformation("Route creation request: ID={Id}, Name={Name}, Points={PointCount}, RegionSize={RegionSize}m, Zoom={Zoom}",
            request.Id, request.Name, request.Points.Count, request.RegionSizeMeters, request.ZoomLevel);

        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 DownloadTileRequest
{
    [Required]
    public double Latitude { get; set; }
    
    [Required]
    public double Longitude { get; set; }
    
    [Required]
    public int ZoomLevel { get; set; } = 20;
}

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"
        };

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