Skip to content

armgit / Filee

Public Imported from GitHub
0

Free, open-source file converter. Convert 263 formats offline by drag & drop — images, PDF, Word, Excel, PowerPoint, HWP/HWPX, video, audio, e-books and archives. No upload, no Office needed.

15.0 KB
Raw Blame
// Decides whether a preset can run for a set of files and why not — used to grey out donut slices.

using Filee.Core.Conversion;
using Filee.Core.Formats;
using Filee.Core.Localization;
using Filee.Core.Presets;

namespace Filee.App.Services;

public enum PresetUse { Usable, NeedsPackage, Unusable }

/// <summary>Why a preset can or cannot run; usable presets have no reason.</summary>
public readonly record struct PresetJudgement(PresetUse Use, string? Reason);

public sealed class PresetAvailability
{
    private readonly ConverterCatalog _catalog;
    private readonly ILocalizer _loc;
    private readonly IReadOnlyList<EnginePackageState> _packages;
    private readonly Func<RoutePlanner> _installedPlanner;

    public PresetAvailability(ConverterCatalog catalog, ILocalizer loc, EngineDownloadService downloads)
        : this(catalog, loc, downloads.Packages) { }

    internal PresetAvailability(ConverterCatalog catalog, ILocalizer loc, IReadOnlyList<EnginePackageState> packages)
        : this(catalog, loc, packages, catalog.CreatePlanner) { }

    internal PresetAvailability(ConverterCatalog catalog, ILocalizer loc, IReadOnlyList<EnginePackageState> packages,
        Func<RoutePlanner> installedPlanner)
    {
        _catalog = catalog;
        _loc = loc;
        _packages = packages;
        _installedPlanner = installedPlanner;
    }

    private static readonly HashSet<string> WritableSingleFrameRasterFormats =
    [
        "jpg", "png", "webp", "bmp", "avif", "jxl", "jp2", "tga", "qoi", "dds", "pcx",
    ];
    /// <summary>
    /// Returns <c>null</c> when at least one of <paramref name="formats"/> can be converted with the preset,
    /// otherwise a localized reason — naming the optional engine to download when that would help.
    /// </summary>
    public string? Check(Preset preset, IReadOnlyList<FileFormat> formats) =>
        Evaluate(preset, formats, _installedPlanner,
            possible => PackageEnabling(possible, p => _catalog.CreatePlanner(p.Package.ConverterIds))).Reason;

    /// <summary>Formats for which this preset is usable, in the input order.</summary>
    public IReadOnlyList<FileFormat> UsableFormats(Preset preset, IReadOnlyList<FileFormat> formats)
    {
        RoutePlanner? installed = null;
        var packagePlanners = new Dictionary<EnginePackageState, RoutePlanner>();
        RoutePlanner Installed() => installed ??= _installedPlanner();
        EnginePackageState? Enabling(Func<RoutePlanner, bool> possible) =>
            PackageEnabling(possible, p => packagePlanners.TryGetValue(p, out var planner)
                ? planner : packagePlanners[p] = _catalog.CreatePlanner(p.Package.ConverterIds));

        var usable = new List<FileFormat>();
        foreach (var format in formats)
            if (Evaluate(preset, [format], Installed, Enabling).Use == PresetUse.Usable)
                usable.Add(format);
        return usable;
    }

    private EnginePackageState? PackageEnabling(Func<RoutePlanner, bool> possible, Func<EnginePackageState, RoutePlanner> plannerFor) =>
        _packages.FirstOrDefault(p => !p.IsInstalled && possible(plannerFor(p)));

    public PaletteSession ForPalette(IReadOnlyList<FileFormat> formats) => new(this, formats);

    public sealed class PaletteSession
    {
        private readonly PresetAvailability _owner;
        private readonly IReadOnlyList<FileFormat> _formats;
        private RoutePlanner? _installed;
        private readonly Dictionary<EnginePackageState, RoutePlanner> _packagePlanners = [];

        internal PaletteSession(PresetAvailability owner, IReadOnlyList<FileFormat> formats)
        {
            _owner = owner;
            _formats = formats;
        }

        private RoutePlanner Installed() => _installed ??= _owner._installedPlanner();

        private EnginePackageState? Enabling(Func<RoutePlanner, bool> possible) =>
            _owner.PackageEnabling(possible, p => _packagePlanners.TryGetValue(p, out var r)
                ? r : _packagePlanners[p] = _owner._catalog.CreatePlanner(p.Package.ConverterIds));

        public PresetJudgement Judge(Preset preset)
        {
            if (preset.IsGroup)
                return new(PresetUse.Usable, null);
            if (preset.IsTool && _formats.Count > 0)
            {
                PresetJudgement first = default;
                foreach (var format in _formats)
                {
                    var result = _owner.Evaluate(preset, [format], Installed, Enabling);
                    if (result.Use == PresetUse.Usable)
                        return result;
                    if (first == default)
                        first = result;
                }
                return first;
            }
            return _owner.Evaluate(preset, _formats, Installed, Enabling);
        }
    }

    private PresetJudgement Evaluate(Preset preset, IReadOnlyList<FileFormat> formats,
        Func<RoutePlanner> installedPlanner, Func<Func<RoutePlanner, bool>, EnginePackageState?> packageEnabling)
    {
        if (preset.IsCopyToFolder)
            return new(PresetUse.Usable, null);

        if (preset.IsClipTool)
        {
            // Any video among the files: the others are left out when the clip window opens.
            var videos = formats.Where(f => f.Category == FormatCategory.Video).ToList();
            if (videos.Count == 0)
                return new(PresetUse.Unusable, _loc["error.unsupported_source"]);
            bool CanCut(RoutePlanner planner) => videos.Any(f => ClipTool.CanCut(f.Id, planner));
            if (CanCut(installedPlanner()))
                return new(PresetUse.Usable, null);
            return packageEnabling(CanCut) is { } needed
                ? new(PresetUse.NeedsPackage, _loc.Format("engine.reason.needs_package", needed.Name))
                : new(PresetUse.Unusable, _loc["error.no_route"]);
        }

        // Any picture among the files: the others are left out when the window opens.
        if (preset.IsImageEditTool)
            return formats.Any(f => ImageEditTool.CanEdit(f.Id))
                ? new(PresetUse.Usable, null)
                : new(PresetUse.Unusable, _loc["error.images_only"]);
        if (preset.IsHideTool)
            return formats.Any(f => HideService.CanOpen(f.Id))
                ? new(PresetUse.Usable, null)
                : new(PresetUse.Unusable, _loc["error.images_only"]);

        if (preset.IsTool)
        {
            if (preset.Id == "tool-sheet-studio")
            {
                if (formats.Count > 0 && formats.All(format => format.Id == "xlsx"))
                {
                    var libreOffice = _catalog.All.FirstOrDefault(converter => converter.Id == "libreoffice");
                    if (libreOffice?.GetStatus().IsAvailable == true)
                        return new(PresetUse.Usable, null);
                    var libreOfficePackage = _packages.FirstOrDefault(item => !item.IsInstalled
                        && item.Package.ConverterIds.Contains("libreoffice"));
                    return libreOfficePackage is not null
                        ? new(PresetUse.NeedsPackage, _loc.Format("engine.reason.needs_package", libreOfficePackage.Name))
                        : new(PresetUse.Unusable, _loc["error.no_route"]);
                }
                return new(PresetUse.Unusable, _loc["error.unsupported_source"]);
            }
            if (preset.Id.StartsWith("tool-pdf-", StringComparison.Ordinal))
                return formats.Count > 0 && formats.All(f => f.Id == "pdf")
                    ? new(PresetUse.Usable, null)
                    : new(PresetUse.Unusable, _loc["error.unsupported_source"]);
            if (preset.IsCropTool && formats.Count > 0 && formats.All(f => WritableSingleFrameRasterFormats.Contains(f.Id)))
                return new(PresetUse.Usable, null);
            return new(PresetUse.Unusable, _loc["error.unsupported_source"]);
        }

        // "Compress into one archive" packs the files as they are, so any file works, even of an unknown type.
        if (preset.PacksIntoOneArchive)
        {
            var archive = FormatRegistry.Get(preset.TargetFormat).Id;
            return _catalog.All.OfType<IFileCombiner>().Any(c => c.CanCombineInto(archive))
                ? new(PresetUse.Usable, null) : new(PresetUse.Unusable, _loc["error.no_route"]);
        }

        if (formats.Count == 0)
            return new(PresetUse.Unusable, _loc["error.unsupported_source"]);

        // Resizing, greyscale, trimming or squeezing a file into its own format needs a picture: an MP3 or a ZIP has none.
        if (preset.TargetFormat == BuiltInData.SameAsSource && preset.Image.EditsPicture)
        {
            formats = [.. formats.Where(f => f.Category == FormatCategory.Image)];
            if (formats.Count == 0)
                return new(PresetUse.Unusable, _loc["error.images_only"]);
        }

        // "Trim transparent borders" on JPG and other formats without transparency would only re-encode them.
        if (preset.Image.TrimTransparent
            && formats.All(f => !Filee.Engines.Magick.ImageEncoder.HoldsAlpha(preset.TargetFormat == BuiltInData.SameAsSource ? f.Id : preset.TargetFormat)))
            return new(PresetUse.Unusable, _loc["error.no_transparency"]);
        // "Merge images": ImageMagick reads most pictures as they are; others need a route into PNG first.
        if (preset.JoinsImages)
        {
            if (_catalog.All.OfType<IImageJoiner>().FirstOrDefault() is not { } joiner
                || preset.TargetFormat != BuiltInData.SameAsSource && !joiner.CanWrite(preset.TargetFormat))
                return new(PresetUse.Unusable, _loc["error.no_route"]);
            var pictures = formats.Where(f => f.Category is FormatCategory.Image or FormatCategory.Vector).ToList();
            if (pictures.Count == 0)
                return new(PresetUse.Unusable, _loc["error.images_only"]);
            bool Readable(RoutePlanner planner) => pictures.Any(f => joiner.CanRead(f.Id) || planner.CanConvert(f.Id, "png"));
            if (Readable(installedPlanner()))
                return new(PresetUse.Usable, null);
            return packageEnabling(Readable) is { } reader
                ? new(PresetUse.NeedsPackage, _loc.Format("engine.reason.needs_package", reader.Name))
                : new(PresetUse.Unusable, _loc["error.no_route"]);
        }

        // "Caption": Whisper transcribes speech in video and audio into SRT subtitles.
        if (formats.Any(f => preset.CaptionsVideo(f.Id)))
        {
            if (!OperatingSystem.IsWindows())
                return new(PresetUse.Unusable, _loc["engine.reason.unsupported_platform"]);

            var mediaFiles = formats.Where(f => f.Category is FormatCategory.Video or FormatCategory.Audio).ToList();
            if (mediaFiles.Count == 0)
                return new(PresetUse.Unusable, _loc["error.unsupported_source"]);
            bool CanCaption(RoutePlanner planner) => mediaFiles.Any(f => planner.CanConvert(f.Id, preset.TargetFormat, caption: true));
            if (CanCaption(installedPlanner()))
                return new(PresetUse.Usable, null);
            return packageEnabling(CanCaption) is { } needed
                ? new(PresetUse.NeedsPackage, _loc.Format("engine.reason.needs_package", needed.Name))
                : new(PresetUse.Unusable, _loc["error.no_route"]);
        }

        // "Merge videos" / "Merge audio" / "Video from images": FFmpeg joins the files, so a route into the target (or,
        // for pictures, into PNG and from PNG into a video) says whether it is installed.
        // "Translate": Ollama / Translator translates documents and e-books.
        if (preset.Translate.Enabled)
        {
            var docFiles = formats.Where(f => preset.TranslatesDocument(f.Id)).ToList();
            if (docFiles.Count == 0)
                return new(PresetUse.Unusable, _loc["error.unsupported_source"]);
            bool CanTranslate(RoutePlanner planner) => docFiles.Any(f =>
            {
                var target = TargetFor(f);
                return planner.CanConvert(f.Id, target, translate: true);
            });
            if (CanTranslate(installedPlanner()))
                return new(PresetUse.Usable, null);
            return packageEnabling(CanTranslate) is { } needed
                ? new(PresetUse.NeedsPackage, _loc.Format("engine.reason.needs_package", needed.Name))
                : new(PresetUse.Unusable, _loc["error.no_route"]);
        }

        if (preset.JoinsIntoOneMedia)
        {
            var target = preset.TargetFormat;
            bool Joinable(RoutePlanner planner) => formats.Any(f => preset.Media.Slideshow
                ? f.Category is FormatCategory.Image or FormatCategory.Vector
                  && (f.Id == "png" || planner.CanConvert(f.Id, "png")) && planner.CanConvert("png", target)
                : (f.Category == FormatCategory.Video || f.Category == FormatCategory.Audio && target == "m4a")
                  && planner.CanConvert(f.Id, target));
            if (Joinable(installedPlanner()))
                return new(PresetUse.Usable, null);
            return packageEnabling(Joinable) is { } joiner
                ? new(PresetUse.NeedsPackage, _loc.Format("engine.reason.needs_package", joiner.Name))
                : new(PresetUse.Unusable, _loc["error.no_route"]);
        }

        var merge = preset.Pdf.MergeIntoSingle && preset.TargetFormat == "pdf";
        var turns = preset.Image.TurnsOrMirrors;
        string TargetFor(FileFormat f) => preset.TargetFormat == BuiltInData.SameAsSource ? f.Id : preset.TargetFormat;
        var copiesUnturned = false;
        bool Possible(RoutePlanner planner) => formats.Any(f =>
        {
            var target = TargetFor(f);
            if (merge && f.Id == "pdf" && !turns && !preset.RecognizesTextOf(f.Id))
                return true; // merged as it is
            var frames = preset.SavesFramesOf(f.Id);
            var motion = preset.ExtractsMotionOf(f.Id);
            var live = preset.MakesLivePhotoOf(f.Id);
            var ocr = preset.RecognizesTextOf(f.Id);
            var translate = preset.TranslatesDocument(f.Id);
            if (!turns)
                return planner.CanConvert(f.Id, target, frames, motionPhoto: motion, livePhoto: live, ocr: ocr, translate: translate);
            // Rotate / flip: a route only counts when an engine on it turns images (not a PDF or a video copied).
            if (planner.Plan(f.Id, target, frames, motionPhoto: motion, livePhoto: live, ocr: ocr, translate: translate) is not { } route)
                return false;
            if (route.FirstTransformStep() >= 0)
                return true;
            copiesUnturned = true;
            return false;
        });

        if (Possible(installedPlanner()))
            return new(PresetUse.Usable, null);
        // It converts these files, just without turning them: say that, not "no engine" or "download one".
        if (copiesUnturned)
            return new(PresetUse.Unusable, _loc["error.cannot_turn"]);
        return packageEnabling(Possible) is { } package
            ? new(PresetUse.NeedsPackage, _loc.Format("engine.reason.needs_package", package.Name))
            : new(PresetUse.Unusable, _loc["error.no_route"]);
    }
}