download 1 tile, first integration test

SatelliteProvider.Services/GoogleMapsDownloader.cs

@@ -11,17 +11,17 @@ using SixLabors.ImageSharp;
 
 namespace SatelliteProvider.Services;
 
+public record DownloadedTileInfo(int X, int Y, int ZoomLevel, double Latitude, double Longitude, string FilePath, double TileSizeMeters);
 
-public class GoogleMapsDownloader(ILogger<GoogleMapsDownloader> logger, IOptions<MapConfig> mapConfig, IHttpClientFactory httpClientFactory)
+public class GoogleMapsDownloader(ILogger<GoogleMapsDownloader> logger, IOptions<MapConfig> mapConfig, IOptions<StorageConfig> storageConfig, IHttpClientFactory httpClientFactory)
     : ISatelliteDownloader
 {
     private const string TILE_URL_TEMPLATE = "https://mt{0}.google.com/vt/lyrs=s&x={1}&y={2}&z={3}&token={4}";
     private const string USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.0.0 Safari/537.36";
     private const int NUM_SERVERS = 4;
+    private const int TILE_SIZE_PIXELS = 256;
     private readonly string _apiKey = mapConfig.Value.ApiKey;
-
-    private readonly string _satDirectory = Path.Combine(Directory.GetCurrentDirectory(), "maps");
-
+    private readonly string _tilesDirectory = storageConfig.Value.TilesDirectory;
 
     private record SessionResponse(string Session);
 
@@ -45,6 +45,11 @@ public class GoogleMapsDownloader(ILogger<GoogleMapsDownloader> logger, IOptions
     }
 
     public async Task GetTiles(GeoPoint centerGeoPoint, double radiusM, int zoomLevel, CancellationToken token = default)
+    {
+        await GetTilesWithMetadataAsync(centerGeoPoint, radiusM, zoomLevel, token);
+    }
+
+    public async Task<List<DownloadedTileInfo>> GetTilesWithMetadataAsync(GeoPoint centerGeoPoint, double radiusM, int zoomLevel, CancellationToken token = default)
     {
         var (latMin, latMax, lonMin, lonMax) = GeoUtils.GetBoundingBox(centerGeoPoint, radiusM);
 
@@ -52,6 +57,7 @@ public class GoogleMapsDownloader(ILogger<GoogleMapsDownloader> logger, IOptions
         var (xMax, yMax) = GeoUtils.WorldToTilePos(new GeoPoint(latMin, lonMax), zoomLevel);
 
         var tilesToDownload = new ConcurrentQueue<SatTile>();
+        var downloadedTiles = new ConcurrentBag<DownloadedTileInfo>();
         var server = 0;
         var sessionToken = await GetSessionToken();
 
@@ -69,13 +75,14 @@ public class GoogleMapsDownloader(ILogger<GoogleMapsDownloader> logger, IOptions
 
         for (int i = 0; i < NUM_SERVERS; i++)
         {
-            downloadTasks.Add(Task.Run(() => DownloadTilesWorker(tilesToDownload, token), token));
+            downloadTasks.Add(Task.Run(() => DownloadTilesWorker(tilesToDownload, downloadedTiles, zoomLevel, token), token));
         }
 
         await Task.WhenAll(downloadTasks);
+        return downloadedTiles.ToList();
     }
 
-    private async Task DownloadTilesWorker(ConcurrentQueue<SatTile> tilesToDownload, CancellationToken token)
+    private async Task DownloadTilesWorker(ConcurrentQueue<SatTile> tilesToDownload, ConcurrentBag<DownloadedTileInfo> downloadedTiles, int zoomLevel, CancellationToken token)
     {
         using var httpClient = httpClientFactory.CreateClient();
 
@@ -84,12 +91,33 @@ public class GoogleMapsDownloader(ILogger<GoogleMapsDownloader> logger, IOptions
             if (token.IsCancellationRequested) break;
             try
             {
+                Directory.CreateDirectory(_tilesDirectory);
+                
+                var timestamp = DateTime.UtcNow.ToString("yyyyMMddHHmmss");
+                var fileName = $"tile_{tileInfo.Zoom}_{tileInfo.X}_{tileInfo.Y}_{timestamp}.jpg";
+                var filePath = Path.Combine(_tilesDirectory, fileName);
+                
                 httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(USER_AGENT);
                 var response = await httpClient.GetAsync(tileInfo.Url, token);
                 response.EnsureSuccessStatusCode();
                 var tileData = await response.Content.ReadAsByteArrayAsync(token);
                 using var tileImage = Image.Load(tileData);
-                await tileImage.SaveAsync(Path.Combine(_satDirectory, tileInfo.FileName), token);
+                await tileImage.SaveAsync(filePath, token);
+                
+                var tileCenter = GeoUtils.TileToWorldPos(tileInfo.X, tileInfo.Y, tileInfo.Zoom);
+                var tileSizeMeters = CalculateTileSizeInMeters(tileInfo.Zoom, tileCenter.Lat);
+                
+                var downloadedTile = new DownloadedTileInfo(
+                    tileInfo.X, 
+                    tileInfo.Y, 
+                    tileInfo.Zoom, 
+                    tileCenter.Lat, 
+                    tileCenter.Lon, 
+                    filePath, 
+                    tileSizeMeters
+                );
+                
+                downloadedTiles.Add(downloadedTile);
             }
             catch (HttpRequestException requestException)
             {
@@ -101,4 +129,12 @@ public class GoogleMapsDownloader(ILogger<GoogleMapsDownloader> logger, IOptions
             }
         }
     }
+
+    private static double CalculateTileSizeInMeters(int zoomLevel, double latitude)
+    {
+        const double EARTH_CIRCUMFERENCE_METERS = 40075016.686;
+        var latRad = latitude * Math.PI / 180.0;
+        var metersPerPixel = (EARTH_CIRCUMFERENCE_METERS * Math.Cos(latRad)) / (Math.Pow(2, zoomLevel) * TILE_SIZE_PIXELS);
+        return metersPerPixel * TILE_SIZE_PIXELS;
+    }
 }

SatelliteProvider.Services/SatelliteProvider.Services.csproj

@@ -16,6 +16,7 @@
 
     <ItemGroup>
       <ProjectReference Include="..\SatelliteProvider.Common\SatelliteProvider.Common.csproj" />
+      <ProjectReference Include="..\SatelliteProvider.DataAccess\SatelliteProvider.DataAccess.csproj" />
     </ItemGroup>
 
 </Project>

SatelliteProvider.Services/TileService.cs

@@ -0,0 +1,115 @@
+using Microsoft.Extensions.Logging;
+using SatelliteProvider.Common.DTO;
+using SatelliteProvider.Common.Interfaces;
+using SatelliteProvider.DataAccess.Models;
+using SatelliteProvider.DataAccess.Repositories;
+
+namespace SatelliteProvider.Services;
+
+public class TileService : ITileService
+{
+    private readonly GoogleMapsDownloader _downloader;
+    private readonly ITileRepository _tileRepository;
+    private readonly ILogger<TileService> _logger;
+
+    public TileService(
+        GoogleMapsDownloader downloader,
+        ITileRepository tileRepository,
+        ILogger<TileService> logger)
+    {
+        _downloader = downloader;
+        _tileRepository = tileRepository;
+        _logger = logger;
+    }
+
+    public async Task<List<TileMetadata>> DownloadAndStoreTilesAsync(
+        double latitude, 
+        double longitude, 
+        double sizeMeters, 
+        int zoomLevel, 
+        CancellationToken cancellationToken = default)
+    {
+        var existingTiles = await _tileRepository.GetTilesByRegionAsync(latitude, longitude, sizeMeters, zoomLevel);
+        var existingTilesList = existingTiles.ToList();
+        
+        _logger.LogInformation("Found {Count} existing tiles for region", existingTilesList.Count);
+        
+        var centerPoint = new GeoPoint(latitude, longitude);
+        var downloadedTiles = await _downloader.GetTilesWithMetadataAsync(centerPoint, sizeMeters / 2, zoomLevel, cancellationToken);
+        
+        var result = new List<TileMetadata>();
+        
+        foreach (var downloadedTile in downloadedTiles)
+        {
+            var existingTile = existingTilesList.FirstOrDefault(t =>
+                Math.Abs(t.Latitude - downloadedTile.Latitude) < 0.0001 &&
+                Math.Abs(t.Longitude - downloadedTile.Longitude) < 0.0001 &&
+                t.ZoomLevel == downloadedTile.ZoomLevel);
+
+            if (existingTile != null)
+            {
+                _logger.LogDebug("Reusing existing tile at ({Lat}, {Lon})", downloadedTile.Latitude, downloadedTile.Longitude);
+                result.Add(MapToMetadata(existingTile));
+            }
+            else
+            {
+                var now = DateTime.UtcNow;
+                var tileEntity = new TileEntity
+                {
+                    Id = Guid.NewGuid(),
+                    ZoomLevel = downloadedTile.ZoomLevel,
+                    Latitude = downloadedTile.Latitude,
+                    Longitude = downloadedTile.Longitude,
+                    TileSizeMeters = downloadedTile.TileSizeMeters,
+                    TileSizePixels = 256,
+                    ImageType = "jpg",
+                    MapsVersion = $"downloaded_{now:yyyy-MM-dd}",
+                    FilePath = downloadedTile.FilePath,
+                    CreatedAt = now,
+                    UpdatedAt = now
+                };
+
+                await _tileRepository.InsertAsync(tileEntity);
+                _logger.LogInformation("Saved new tile {Id} at ({Lat}, {Lon})", tileEntity.Id, tileEntity.Latitude, tileEntity.Longitude);
+                result.Add(MapToMetadata(tileEntity));
+            }
+        }
+
+        return result;
+    }
+
+    public async Task<TileMetadata?> GetTileAsync(Guid id)
+    {
+        var tile = await _tileRepository.GetByIdAsync(id);
+        return tile != null ? MapToMetadata(tile) : null;
+    }
+
+    public async Task<IEnumerable<TileMetadata>> GetTilesByRegionAsync(
+        double latitude, 
+        double longitude, 
+        double sizeMeters, 
+        int zoomLevel)
+    {
+        var tiles = await _tileRepository.GetTilesByRegionAsync(latitude, longitude, sizeMeters, zoomLevel);
+        return tiles.Select(MapToMetadata);
+    }
+
+    private static TileMetadata MapToMetadata(TileEntity entity)
+    {
+        return new TileMetadata
+        {
+            Id = entity.Id,
+            ZoomLevel = entity.ZoomLevel,
+            Latitude = entity.Latitude,
+            Longitude = entity.Longitude,
+            TileSizeMeters = entity.TileSizeMeters,
+            TileSizePixels = entity.TileSizePixels,
+            ImageType = entity.ImageType,
+            MapsVersion = entity.MapsVersion,
+            FilePath = entity.FilePath,
+            CreatedAt = entity.CreatedAt,
+            UpdatedAt = entity.UpdatedAt
+        };
+    }
+}
+