tiels are cached and reused properly

SatelliteProvider.DataAccess/Migrations/004_AddVersionColumn.sql

@@ -0,0 +1,13 @@
+ALTER TABLE tiles ADD COLUMN version INT NOT NULL DEFAULT 2025;
+
+DELETE FROM tiles a
+USING tiles b
+WHERE a.id > b.id
+  AND a.latitude = b.latitude
+  AND a.longitude = b.longitude
+  AND a.zoom_level = b.zoom_level
+  AND a.tile_size_meters = b.tile_size_meters
+  AND a.version = b.version;
+
+CREATE UNIQUE INDEX idx_tiles_unique_location ON tiles(latitude, longitude, zoom_level, tile_size_meters, version);
+

SatelliteProvider.DataAccess/Models/TileEntity.cs

@@ -10,6 +10,7 @@ public class TileEntity
     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; }

SatelliteProvider.DataAccess/Repositories/ITileRepository.cs

@@ -5,7 +5,7 @@ namespace SatelliteProvider.DataAccess.Repositories;
 public interface ITileRepository
 {
     Task<TileEntity?> GetByIdAsync(Guid id);
-    Task<TileEntity?> FindExistingTileAsync(double latitude, double longitude, double tileSizeMeters, int zoomLevel);
+    Task<TileEntity?> FindExistingTileAsync(double latitude, double longitude, double tileSizeMeters, int zoomLevel, int version);
     Task<IEnumerable<TileEntity>> GetTilesByRegionAsync(double latitude, double longitude, double sizeMeters, int zoomLevel);
     Task<Guid> InsertAsync(TileEntity tile);
     Task<int> UpdateAsync(TileEntity tile);

SatelliteProvider.DataAccess/Repositories/TileRepository.cs

@@ -19,7 +19,7 @@ public class TileRepository : ITileRepository
         const string sql = @"
             SELECT id, zoom_level as ZoomLevel, latitude, longitude, 
                    tile_size_meters as TileSizeMeters, tile_size_pixels as TileSizePixels,
-                   image_type as ImageType, maps_version as MapsVersion, 
+                   image_type as ImageType, maps_version as MapsVersion, version,
                    file_path as FilePath, created_at as CreatedAt, updated_at as UpdatedAt
             FROM tiles 
             WHERE id = @Id";
@@ -27,19 +27,20 @@ public class TileRepository : ITileRepository
         return await connection.QuerySingleOrDefaultAsync<TileEntity>(sql, new { Id = id });
     }
 
-    public async Task<TileEntity?> FindExistingTileAsync(double latitude, double longitude, double tileSizeMeters, int zoomLevel)
+    public async Task<TileEntity?> FindExistingTileAsync(double latitude, double longitude, double tileSizeMeters, int zoomLevel, int version)
     {
         using var connection = new NpgsqlConnection(_connectionString);
         const string sql = @"
             SELECT id, zoom_level as ZoomLevel, latitude, longitude, 
                    tile_size_meters as TileSizeMeters, tile_size_pixels as TileSizePixels,
-                   image_type as ImageType, maps_version as MapsVersion, 
+                   image_type as ImageType, maps_version as MapsVersion, version,
                    file_path as FilePath, created_at as CreatedAt, updated_at as UpdatedAt
             FROM tiles 
             WHERE ABS(latitude - @Latitude) < 0.0001 
               AND ABS(longitude - @Longitude) < 0.0001 
               AND ABS(tile_size_meters - @TileSizeMeters) < 1
               AND zoom_level = @ZoomLevel
+              AND version = @Version
             LIMIT 1";
         
         return await connection.QuerySingleOrDefaultAsync<TileEntity>(sql, new 
@@ -47,7 +48,8 @@ public class TileRepository : ITileRepository
             Latitude = latitude, 
             Longitude = longitude, 
             TileSizeMeters = tileSizeMeters,
-            ZoomLevel = zoomLevel
+            ZoomLevel = zoomLevel,
+            Version = version
         });
     }
 
@@ -55,19 +57,27 @@ public class TileRepository : ITileRepository
     {
         using var connection = new NpgsqlConnection(_connectionString);
         
-        var latRange = sizeMeters / 111000.0;
-        var lonRange = sizeMeters / (111000.0 * Math.Cos(latitude * Math.PI / 180.0));
+        const double EARTH_CIRCUMFERENCE_METERS = 40075016.686;
+        const int TILE_SIZE_PIXELS = 256;
+        var latRad = latitude * Math.PI / 180.0;
+        var metersPerPixel = (EARTH_CIRCUMFERENCE_METERS * Math.Cos(latRad)) / (Math.Pow(2, zoomLevel) * TILE_SIZE_PIXELS);
+        var tileSizeMeters = metersPerPixel * TILE_SIZE_PIXELS;
+        
+        var expandedSizeMeters = sizeMeters + (tileSizeMeters * 2);
+        
+        var latRange = expandedSizeMeters / 111000.0;
+        var lonRange = expandedSizeMeters / (111000.0 * Math.Cos(latitude * Math.PI / 180.0));
         
         const string sql = @"
             SELECT id, zoom_level as ZoomLevel, latitude, longitude, 
                    tile_size_meters as TileSizeMeters, tile_size_pixels as TileSizePixels,
-                   image_type as ImageType, maps_version as MapsVersion, 
+                   image_type as ImageType, maps_version as MapsVersion, version,
                    file_path as FilePath, created_at as CreatedAt, updated_at as UpdatedAt
             FROM tiles 
             WHERE latitude BETWEEN @MinLat AND @MaxLat
               AND longitude BETWEEN @MinLon AND @MaxLon
               AND zoom_level = @ZoomLevel
-            ORDER BY latitude DESC, longitude ASC";
+            ORDER BY version DESC, latitude DESC, longitude ASC";
         
         return await connection.QueryAsync<TileEntity>(sql, new
         {
@@ -84,11 +94,15 @@ public class TileRepository : ITileRepository
         using var connection = new NpgsqlConnection(_connectionString);
         const string sql = @"
             INSERT INTO tiles (id, zoom_level, latitude, longitude, tile_size_meters, 
-                             tile_size_pixels, image_type, maps_version, file_path, 
+                             tile_size_pixels, image_type, maps_version, version, file_path, 
                              created_at, updated_at)
             VALUES (@Id, @ZoomLevel, @Latitude, @Longitude, @TileSizeMeters, 
-                    @TileSizePixels, @ImageType, @MapsVersion, @FilePath, 
+                    @TileSizePixels, @ImageType, @MapsVersion, @Version, @FilePath, 
                     @CreatedAt, @UpdatedAt)
+            ON CONFLICT (latitude, longitude, zoom_level, tile_size_meters, version) 
+            DO UPDATE SET 
+                file_path = EXCLUDED.file_path,
+                updated_at = EXCLUDED.updated_at
             RETURNING id";
         
         return await connection.ExecuteScalarAsync<Guid>(sql, tile);
@@ -106,6 +120,7 @@ public class TileRepository : ITileRepository
                 tile_size_pixels = @TileSizePixels,
                 image_type = @ImageType,
                 maps_version = @MapsVersion,
+                version = @Version,
                 file_path = @FilePath,
                 updated_at = @UpdatedAt
             WHERE id = @Id";