Wp2ghost/GhostImageManager/Services/ImageDeletionService.cs

using GhostImageManager.Models;

namespace GhostImageManager.Services;

public class ImageDeletionService
{
    private readonly ILogger<ImageDeletionService> _logger;

    public ImageDeletionService(ILogger<ImageDeletionService> logger)
    {
        _logger = logger;
    }

    public Task<bool> DeleteImageAsync(GhostImage image)
    {
        _logger.LogInformation("Lösche Bild: {FileName} ({FilePath})", image.FileName, image.FilePath);
        var deleted = DeleteFile(image.FilePath);
        if (deleted)
            DeleteSizeVariants(image);
        return Task.FromResult(deleted);
    }

    // Von Ghost erzeugte Varianten unter size/w600/..., size/w600/format/webp/... mit entfernen
    private void DeleteSizeVariants(GhostImage image)
    {
        var relativePath = image.RelativePath.Replace('/', Path.DirectorySeparatorChar);
        if (!image.FilePath.EndsWith(relativePath, StringComparison.OrdinalIgnoreCase))
            return;

        var sizeRoot = Path.Combine(image.FilePath[..^relativePath.Length], "size");
        if (!Directory.Exists(sizeRoot))
            return;

        try
        {
            foreach (var widthDir in Directory.EnumerateDirectories(sizeRoot))
            {
                var candidates = new List<string> { Path.Combine(widthDir, relativePath) };
                var formatRoot = Path.Combine(widthDir, "format");
                if (Directory.Exists(formatRoot))
                    candidates.AddRange(Directory.EnumerateDirectories(formatRoot).Select(d => Path.Combine(d, relativePath)));

                foreach (var variant in candidates.Where(File.Exists))
                {
                    File.Delete(variant);
                    _logger.LogInformation("Größen-Variante gelöscht: {Path}", variant);
                }
            }
        }
        catch (Exception ex)
        {
            _logger.LogWarning(ex, "Größen-Varianten von {File} konnten nicht vollständig gelöscht werden", image.FileName);
        }
    }

    private bool DeleteFile(string filePath)
    {
        try
        {
            if (!File.Exists(filePath))
            {
                _logger.LogWarning("Datei nicht gefunden: {Path}", filePath);
                return false;
            }

            File.Delete(filePath);

            // Auch Backup löschen, falls vorhanden
            var backupPath = filePath + ".backup";
            if (File.Exists(backupPath))
                File.Delete(backupPath);

            _logger.LogInformation("Datei gelöscht: {Path}", filePath);
            return true;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Fehler beim Löschen von {Path}", filePath);
            return false;
        }
    }
}