FontManager.cs

using System.Reflection;
using SkiaSharp;
 
namespace Gondwana.Rendering.Text;

public sealed class FontManager : IDisposable
{
    private static readonly Lazy<FontManager> _instance = new(() => new FontManager());
 
    private readonly Dictionary<string, SKTypeface> _fonts = new(StringComparer.OrdinalIgnoreCase);
    private bool _disposed;

    public static FontManager Instance => _instance.Value;

    private FontManager() { }

    public SKTypeface LoadFromFile(string key, string filePath)
    {
        ThrowIfDisposed();
 
        if (string.IsNullOrWhiteSpace(key))
            throw new ArgumentException("Font key cannot be null or whitespace.", nameof(key));
 
        if (string.IsNullOrWhiteSpace(filePath))
            throw new ArgumentException("Font file path cannot be null or whitespace.", nameof(filePath));
 
        var typeface = SKTypeface.FromFile(filePath);
        if (typeface == null)
            throw new InvalidOperationException($"Failed to load font from file: {filePath}");
 
        ReplaceInternal(key, typeface);
        return typeface;
    }

    public SKTypeface LoadFromResource(string key, Assembly assembly, string resourceName)
    {
        ThrowIfDisposed();
 
        if (string.IsNullOrWhiteSpace(key))
            throw new ArgumentException("Font key cannot be null or whitespace.", nameof(key));
 
        if (assembly == null)
            throw new ArgumentNullException(nameof(assembly));
 
        if (string.IsNullOrWhiteSpace(resourceName))
            throw new ArgumentException("Resource name cannot be null or whitespace.", nameof(resourceName));
 
        using var stream = assembly.GetManifestResourceStream(resourceName);
        if (stream == null)
            throw new InvalidOperationException(
                $"Embedded font resource not found: '{resourceName}' in assembly '{assembly.FullName}'.");
 
        var typeface = SKTypeface.FromStream(stream);
        if (typeface == null)
            throw new InvalidOperationException($"Failed to load font from embedded resource: {resourceName}");
 
        ReplaceInternal(key, typeface);
        return typeface;
    }

    public SKTypeface LoadFromResource(string key, string resourceName)
    {
        return LoadFromResource(key, Assembly.GetCallingAssembly(), resourceName);
    }

    public SKTypeface Get(string key)
    {
        ThrowIfDisposed();
 
        if (string.IsNullOrWhiteSpace(key))
            throw new ArgumentException("Font key cannot be null or whitespace.", nameof(key));
 
        if (!_fonts.TryGetValue(key, out var typeface))
            throw new KeyNotFoundException($"No font is registered under key '{key}'.");
 
        return typeface;
    }

    public bool TryGet(string key, out SKTypeface? typeface)
    {
        ThrowIfDisposed();
 
        if (string.IsNullOrWhiteSpace(key))
        {
            typeface = null;
            return false;
        }
 
        return _fonts.TryGetValue(key, out typeface);
    }

    public SKTypeface GetOrDefault(string key)
    {
        ThrowIfDisposed();
 
        if (string.IsNullOrWhiteSpace(key))
            return SKTypeface.Default;
 
        return _fonts.TryGetValue(key, out var typeface)
            ? typeface
            : SKTypeface.Default;
    }

    public bool Contains(string key)
    {
        ThrowIfDisposed();
 
        if (string.IsNullOrWhiteSpace(key))
            return false;
 
        return _fonts.ContainsKey(key);
    }

    public bool Remove(string key)
    {
        ThrowIfDisposed();
 
        if (string.IsNullOrWhiteSpace(key))
            return false;
 
        if (!_fonts.TryGetValue(key, out var existing))
            return false;
 
        _fonts.Remove(key);
        existing.Dispose();
        return true;
    }

    public void Clear()
    {
        ThrowIfDisposed();
 
        foreach (var font in _fonts.Values)
            font.Dispose();
 
        _fonts.Clear();
    }

    public IReadOnlyCollection<string> Keys
    {
        get
        {
            ThrowIfDisposed();
            return _fonts.Keys.ToArray();
        }
    }
 
    private void ReplaceInternal(string key, SKTypeface newTypeface)
    {
        if (_fonts.TryGetValue(key, out var existing))
        {
            existing.Dispose();
            _fonts[key] = newTypeface;
        }
        else
        {
            _fonts.Add(key, newTypeface);
        }
    }
 
    private void ThrowIfDisposed()
    {
        if (_disposed)
            throw new ObjectDisposedException(nameof(FontManager));
    }

    public void Dispose()
    {
        if (_disposed)
            return;
 
        Clear();
        _disposed = true;
    }
}