TilesheetRegistry.cs

using System.Collections.Immutable;
using Gondwana.Assets;
using Gondwana.Drawing.Tilesheets.GTS;
using Microsoft.Extensions.Logging;
using SkiaSharp;
 
namespace Gondwana.Drawing.Tilesheets;

public sealed class TilesheetRegistry : IDisposable
{
    private readonly object _gate = new();
    private readonly Dictionary<string, Tilesheet> _sheets = new(StringComparer.Ordinal);
 
    // --- Singleton setup ---
    private static readonly Lazy<TilesheetRegistry> _instance =
        new(() => new TilesheetRegistry());

    public static TilesheetRegistry Instance => _instance.Value;
 
    // Private ctor ensures no one else can new this up
    private TilesheetRegistry()
    { }

    internal void Register(Tilesheet sheet, bool disposeReplaced = true)
    {
        if (sheet is null)
        {
            Engine.Logger.LogError("TilesheetRegistry: Attempt to register a null Tilesheet.");
            return;
        }
 
        Tilesheet? replaced = null;
 
        lock (_gate)
        {
            if (_sheets.TryGetValue(sheet.Name, out var existing) && !ReferenceEquals(existing, sheet))
            {
                _sheets[sheet.Name] = sheet;
                replaced = existing;
            }
            else
            {
                _sheets[sheet.Name] = sheet;
            }
 
            // Avoid duplicate subscriptions if the same instance is registered again.
            sheet.Disposed -= OnTilesheetDisposed;
            sheet.Disposed += OnTilesheetDisposed;
        }
 
        if (replaced is not null)
        {
            replaced.Disposed -= OnTilesheetDisposed;
 
            if (disposeReplaced)
                replaced.Dispose();
        }
    }

    public bool TryGet(string name, out Tilesheet? sheet)
    {
        if (name is null)
        {
            Engine.Logger.LogWarning("TilesheetRegistry: Attempt to look up a null name.");
            sheet = null;
            return false;
        }
 
        lock (_gate)
            return _sheets.TryGetValue(name, out sheet!);
    }

    public Tilesheet? GetOrNull(string name)
    {
        return TryGet(name, out var s) ? s : null;
    }

    public Tilesheet this[string name]
    {
        get
        {
            if (name is null)
                throw new ArgumentNullException(nameof(name));
 
            lock (_gate)
            {
                if (_sheets.TryGetValue(name, out var sheet))
                    return sheet;
 
                throw new KeyNotFoundException($"Tilesheet with name '{name}' was not found in the registry.");
            }
        }
    }

    public bool Remove(string name, bool dispose = false)
    {
        if (name is null)
        {
            Engine.Logger.LogWarning("TilesheetRegistry: Attempt to remove a null name.");
            return false;
        }
 
        Tilesheet? removed = null;
 
        lock (_gate)
        {
            if (!_sheets.TryGetValue(name, out removed))
                return false;
 
            _sheets.Remove(name);
        }
 
        removed.Disposed -= OnTilesheetDisposed;
 
        if (dispose)
            removed.Dispose();
 
        return true;
    }

    internal bool Remove(string name, Tilesheet expected, bool dispose = false)
    {
        if (name is null)
        {
            Engine.Logger.LogWarning("TilesheetRegistry: Attempt to remove a null name.");
            return false;
        }
 
        if (expected is null)
        {
            Engine.Logger.LogWarning("TilesheetRegistry: Attempt to remove a null Tilesheet.");
            return false;
        }
 
        Tilesheet? removed = null;
 
        lock (_gate)
        {
            if (_sheets.TryGetValue(name, out var current) && ReferenceEquals(current, expected))
            {
                _sheets.Remove(name);
                removed = current;
            }
            else
            {
                return false;
            }
        }
 
        removed.Disposed -= OnTilesheetDisposed;
 
        if (dispose)
            removed.Dispose();
 
        return true;
    }

    public void Clear()
    {
        List<Tilesheet> copy;
 
        lock (_gate)
        {
            copy = _sheets.Values.ToList();
            _sheets.Clear();
        }
 
        foreach (var ts in copy)
        {
            ts.Disposed -= OnTilesheetDisposed;
            ts.Dispose();
        }
    }

    public IReadOnlyList<string> Names
    {
        get
        {
            lock (_gate)
                return _sheets.Keys.ToList();
        }
    }

    public IImmutableDictionary<string, Tilesheet> GetAll()
    {
        lock (_gate)
        {
            return _sheets.ToImmutableDictionary(kv => kv.Key, kv => kv.Value, _sheets.Comparer);
        }
    }

    public int Count
    {
        get
        {
            lock (_gate)
                return _sheets.Count;
        }
    }

    internal void OnTilesheetRenamed(string oldName, string newName, Tilesheet sheet, bool disposeReplaced = true)
    {
        if (oldName is null)
            throw new ArgumentNullException(nameof(oldName));
 
        if (newName is null)
            throw new ArgumentNullException(nameof(newName));
 
        if (sheet is null)
            throw new ArgumentNullException(nameof(sheet));
 
        Tilesheet? replaced = null;
 
        lock (_gate)
        {
            // If old mapping points to this sheet, remove it.
            if (_sheets.TryGetValue(oldName, out var existingAtOld) && ReferenceEquals(existingAtOld, sheet))
                _sheets.Remove(oldName);
 
            // If something else is already at newName, warn and replace.
            if (_sheets.TryGetValue(newName, out var existingAtNew) && !ReferenceEquals(existingAtNew, sheet))
            {
                Engine.Logger.LogWarning(
                    "TilesheetRegistry: Renaming '{Old}'→'{New}' replaced a different registered Tilesheet instance.",
                    oldName, newName);
                replaced = existingAtNew;
            }
 
            _sheets[newName] = sheet;
        }
 
        if (replaced is not null)
        {
            replaced.Disposed -= OnTilesheetDisposed;
 
            if (disposeReplaced)
                replaced.Dispose();
        }
    }
 
    private void OnTilesheetDisposed(Tilesheet sheet)
    {
        if (sheet is null)
            return;
 
        Remove(sheet.Name, sheet, dispose: false);
    }

    public void Dispose()
    {
        Clear();
    }
 
    #region public shims to TilesheetFactory

    public Tilesheet LoadFromBitmap(string name, SKBitmap bitmap)
    {
        var tilesheet = TilesheetFactory.FromBitmap(name, bitmap);
        Register(tilesheet);
        return tilesheet;
    }

    public Tilesheet LoadFromStream(string name, Stream stream)
    {
        var tilesheet = TilesheetFactory.FromStream(name, stream);
        Register(tilesheet);
        return tilesheet;
    }

    public Tilesheet LoadFromImageFile(string name, string imageFilePath)
    {
        var tilesheet = TilesheetFactory.FromImageFile(name, imageFilePath);
        Register(tilesheet);
        return tilesheet;
    }

    public Tilesheet LoadFromAssetsFile(AssetsFile assetsFile, string entryName)
    {
        var tilesheet = TilesheetFactory.FromAssetsFile(assetsFile, entryName);
        Register(tilesheet);
        return tilesheet;
    }

    public Tilesheet LoadFromDefinitionFile(string gtsPath)
    {
        var tilesheet = TilesheetFactory.FromDefinitionFile(gtsPath);
        Register(tilesheet);
        return tilesheet;
    }

    public Tilesheet LoadFromDefinition(TilesheetDefinition definition, string? baseDirectory = null)
    {
        var tilesheet = TilesheetFactory.FromDefinition(definition, baseDirectory);
        Register(tilesheet);
        return tilesheet;
    }

    public Tilesheet LoadFromDefinitionAsset(AssetsFile assetsFile, string gtsEntryName)
    {
        var tilesheet = TilesheetFactory.FromDefinitionAsset(assetsFile, gtsEntryName);
        Register(tilesheet);
 
        return tilesheet;
    }
 
    #endregion public shims to TilesheetFactory
}