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 GoogleMapsDownloaderV2 _downloader;
    private readonly ITileRepository _tileRepository;
    private readonly ILogger<TileService> _logger;

    public TileService(
        GoogleMapsDownloaderV2 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 currentVersion = DateTime.UtcNow.Year;
        
        var existingTiles = await _tileRepository.GetTilesByRegionAsync(latitude, longitude, sizeMeters, zoomLevel);
        var existingTilesList = existingTiles.Where(t => t.Version == currentVersion).ToList();
        
        _logger.LogInformation("Found {Count} existing tiles for region (version {Version})", existingTilesList.Count, currentVersion);
        
        if (existingTilesList.Any())
        {
            _logger.LogInformation("Existing tiles in DB:");
            foreach (var et in existingTilesList)
            {
                _logger.LogInformation("  DB Tile: Lat={Lat:F12}, Lon={Lon:F12}, Zoom={Zoom}", et.Latitude, et.Longitude, et.ZoomLevel);
            }
        }
        
        var centerPoint = new GeoPoint(latitude, longitude);
        var downloadedTiles = await _downloader.GetTilesWithMetadataAsync(
            centerPoint, 
            sizeMeters / 2, 
            zoomLevel, 
            existingTilesList,
            cancellationToken);
        
        _logger.LogInformation("Downloaded {Count} new tiles from Google", downloadedTiles.Count);
        
        var result = new List<TileMetadata>();
        int reusedCount = existingTilesList.Count;
        int downloadedCount = downloadedTiles.Count;
        
        foreach (var existingTile in existingTilesList)
        {
            result.Add(MapToMetadata(existingTile));
        }
        
        foreach (var downloadedTile in downloadedTiles)
        {
            var now = DateTime.UtcNow;
            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("Saved new tile {Id} at ({Lat:F12}, {Lon:F12}) version {Version}", tileEntity.Id, tileEntity.Latitude, tileEntity.Longitude, currentVersion);
            result.Add(MapToMetadata(tileEntity));
        }
        
        _logger.LogInformation("Tile processing summary: {Reused} reused, {Downloaded} new", reusedCount, downloadedCount);

        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,
            Version = entity.Version,
            FilePath = entity.FilePath,
            CreatedAt = entity.CreatedAt,
            UpdatedAt = entity.UpdatedAt
        };
    }
}