DirectComposite.cs

using System.Collections.ObjectModel;
using System.Drawing;
using System.Numerics;
using Gondwana.Physics.Movement;
using Gondwana.Rendering;
using Gondwana.Rendering.Backbuffers;
using Gondwana.Rendering.Views;
using Gondwana.Scenes;
using Gondwana.Timers;
 
namespace Gondwana.Drawing.Direct;

public class DirectComposite : IDirectCompositeChild, IDirectCompositeContainer
{
    private static readonly object _parentSyncRoot = new();
 
    private static readonly Dictionary<IDirectCompositeChild, DirectComposite> _parents =
        new(ReferenceEqualityComparer.Instance);
 
    private readonly List<IDirectCompositeChild> _children = [];
    private readonly Dictionary<IDirectCompositeChild, Vector2> _localOffsetPx =
        new(ReferenceEqualityComparer.Instance);
 
    private readonly ReadOnlyCollection<IDirectCompositeChild> _readOnlyChildren;
 
    private PointF _anchor;
    private long _lastTick = HighResTimer.GetCurrentTick();
    private bool _disposed;
 
    #region events

    public event EventHandler<IDirectDrawable>? Disposing;
 
    #endregion events
 
    #region constructors

    public DirectComposite(RenderSurfaceHostBase renderSurfaceHost,
                           DirectDrawingMode mode,
                           PointF anchor = default,
                           string? nickname = null)
    {
        RenderSurfaceHost = renderSurfaceHost ?? throw new ArgumentNullException(nameof(renderSurfaceHost));
 
        Mode = mode;
        _anchor = anchor;
        Nickname = nickname ?? Id.ToString();
 
        _readOnlyChildren = new ReadOnlyCollection<IDirectCompositeChild>(_children);
 
        Movement = new MovementController(this, MovementState.ForPixel());
 
        DirectDrawingManager.Instance.AddOrReplace(this);
    }
 
    #endregion constructors
 
    #region public properties

    public Guid Id { get; } = Guid.NewGuid();

    public string? Nickname { get; private set; }

    public RenderSurfaceHostBase RenderSurfaceHost { get; }

    public DirectDrawingMode Mode { get; }

    public SceneLayer? SceneLayer { get; private set; }

    public View? View { get; private set; }

    public ReadOnlyCollection<IDirectCompositeChild> Children => _readOnlyChildren;

    public MovementController Movement { get; }

    public MovementSpace PositionSpace => MovementSpace.Pixel;

    public bool Visible
    {
        get => _children.Any(static child => child.Visible);
        set
        {
            foreach (IDirectCompositeChild child in _children)
                child.SetIsVisible(value);
        }
    }

    public int ZOrder => 0;

    public Rectangle ScreenBounds => GetBounds(static child => child.ScreenBounds);

    public Rectangle WorldBounds => GetBounds(static child => child.WorldBounds);
 
    #endregion public properties
 
    #region public methods

    public Vector2 GetPosition() => new(_anchor.X, _anchor.Y);

    public void SetPosition(Vector2 position)
    {
        SetPosition(position.X, position.Y);
    }

    public DirectComposite SetPosition(float x, float y)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
 
        _anchor = new PointF(x, y);
        var anchor = new Vector2(x, y);
 
        foreach (IDirectCompositeChild child in _children)
        {
            Vector2 offset = _localOffsetPx.TryGetValue(child, out Vector2 value) ? value : Vector2.Zero;
            child.SetPosition(anchor + offset);
        }
 
        return this;
    }

    public virtual DirectComposite Add(IDirectCompositeChild child,
                                       bool keepCurrentOffset = true,
                                       Vector2? explicitLocalOffsetPx = null)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
        ArgumentNullException.ThrowIfNull(child);
 
        if (_children.Contains(child))
            return this;
 
        ValidateChildIdentity(child);
        ValidateParentRelationship(child);
        ValidateAndAssignTarget(child);
 
        Vector2 offset = keepCurrentOffset ? child.GetPosition() - new Vector2(_anchor.X, _anchor.Y) : explicitLocalOffsetPx ?? Vector2.Zero;
 
        RegisterParent(child);
 
        try
        {
            _children.Add(child);
            _localOffsetPx[child] = offset;
            child.Disposing += OnChildDisposing;
 
            child.SetPosition(new Vector2(_anchor.X, _anchor.Y) + offset);
 
            OnChildAdded(child);
        }
        catch
        {
            child.Disposing -= OnChildDisposing;
            _children.Remove(child);
            _localOffsetPx.Remove(child);
            UnregisterParent(child);
            ResetTargetWhenEmpty();
            throw;
        }
 
        return this;
    }

    public virtual DirectComposite Remove(IDirectCompositeChild child)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
        ArgumentNullException.ThrowIfNull(child);
 
        if (!_children.Remove(child))
            return this;
 
        child.Disposing -= OnChildDisposing;
        _localOffsetPx.Remove(child);
        UnregisterParent(child);
        ResetTargetWhenEmpty();
 
        OnChildRemoved(child);
 
        return this;
    }

    public virtual DirectComposite Clear()
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
 
        IDirectCompositeChild[] children = [.. _children];
 
        foreach (IDirectCompositeChild child in children)
        {
            child.Disposing -= OnChildDisposing;
            UnregisterParent(child);
        }
 
        _children.Clear();
        _localOffsetPx.Clear();
        ResetTargetWhenEmpty();
 
        foreach (IDirectCompositeChild child in children)
            OnChildRemoved(child);
 
        return this;
    }

    public DirectComposite SetLocalOffset(IDirectCompositeChild child,
                                          Vector2 newLocalOffsetPx)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
        ArgumentNullException.ThrowIfNull(child);
 
        if (!_children.Contains(child))
            return this;
 
        _localOffsetPx[child] = newLocalOffsetPx;
 
        child.SetPosition(new Vector2(_anchor.X, _anchor.Y) + newLocalOffsetPx);
 
        return this;
    }

    public DirectComposite SetZOrder(int zOrder)
    {
        foreach (IDirectCompositeChild child in _children)
            child.SetZOrder(zOrder);
 
        return this;
    }

    public DirectComposite SetOpacity(float opacity)
    {
        foreach (IDirectCompositeChild child in _children)
            child.SetOpacity(opacity);
 
        return this;
    }

    public DirectComposite SetIsVisible(bool visible)
    {
        Visible = visible;
        return this;
    }

    public DirectComposite FadeTo(float targetOpacity, float durationSec)
    {
        foreach (IDirectCompositeChild child in _children)
            child.FadeTo(targetOpacity, durationSec);
 
        return this;
    }

    public DirectComposite FadeIn(float durationSec) => FadeTo(1f, durationSec);

    public DirectComposite FadeOut(float durationSec) => FadeTo(0f, durationSec);

    public RectangleF GetDrawLocationScreen(View view)
    {
        ArgumentNullException.ThrowIfNull(view);
 
        if (Mode == DirectDrawingMode.View && !ReferenceEquals(View, view))
        {
            return RectangleF.Empty;
        }
 
        float minX = float.MaxValue;
        float minY = float.MaxValue;
        float maxX = float.MinValue;
        float maxY = float.MinValue;
 
        foreach (IDirectCompositeChild child in _children)
        {
            if (!child.Visible)
                continue;
 
            RectangleF bounds = child.GetDrawLocationScreen(view);
 
            if (bounds.IsEmpty)
                continue;
 
            minX = Math.Min(minX, bounds.Left);
            minY = Math.Min(minY, bounds.Top);
            maxX = Math.Max(maxX, bounds.Right);
            maxY = Math.Max(maxY, bounds.Bottom);
        }
 
        if (minX == float.MaxValue)
            return RectangleF.Empty;
 
        return RectangleF.FromLTRB(
            (float)Math.Floor(minX),
            (float)Math.Floor(minY),
            (float)Math.Ceiling(maxX),
            (float)Math.Ceiling(maxY));
    }

    public void Draw(BackbufferBase backbuffer, RectangleF destRectScreen) { }

    public virtual void Update(long tick)
    {
        if (_disposed || tick <= _lastTick)
            return;
 
        Movement.AdvanceMovement(
            HighResTimer.GetDuration(_lastTick, tick));
 
        _lastTick = tick;
    }

    public virtual void Dispose()
    {
        if (_disposed)
            return;
 
        _disposed = true;
 
        Disposing?.Invoke(this, this);
 
        IDirectCompositeChild[] children = [.. _children];
 
        foreach (IDirectCompositeChild child in children)
            child.Dispose();
 
        foreach (IDirectCompositeChild child in _children)
        {
            child.Disposing -= OnChildDisposing;
            UnregisterParent(child);
        }
 
        _children.Clear();
        _localOffsetPx.Clear();
        ResetTargetWhenEmpty();
        Disposing = null;
 
        GC.SuppressFinalize(this);
    }
 
    #endregion public methods
 
    #region IDirectCompositeChild explicit interface implementations
 
    void IDirectCompositeChild.SetIsVisible(bool visible) => SetIsVisible(visible);
 
    void IDirectCompositeChild.SetZOrder(int zOrder) => SetZOrder(zOrder);
 
    void IDirectCompositeChild.SetOpacity(float opacity) => SetOpacity(opacity);
 
    void IDirectCompositeChild.FadeTo(float targetOpacity, float durationSec) => FadeTo(targetOpacity, durationSec);
 
    #endregion IDirectCompositeChild explicit interface implementations
 
    #region IDirectCompositeContainer explicit interface implementations
 
    IReadOnlyCollection<IDirectCompositeChild> IDirectCompositeContainer.Children => Children;
 
    IDirectCompositeContainer IDirectCompositeContainer.Add(IDirectCompositeChild child, bool keepCurrentOffset, Vector2? explicitLocalOffsetPx)
    {
        return Add(child, keepCurrentOffset, explicitLocalOffsetPx);
    }
 
    IDirectCompositeContainer IDirectCompositeContainer.Remove(IDirectCompositeChild child)
    {
        return Remove(child);
    }
 
    IDirectCompositeContainer IDirectCompositeContainer.Clear()
    {
        return Clear();
    }
 
    #endregion IDirectCompositeContainer explicit interface implementations
 
    #region protected hooks

    protected virtual void OnChildAdded(IDirectCompositeChild child)
    {
    }

    protected virtual void OnChildRemoved(IDirectCompositeChild child)
    {
    }
 
    #endregion protected hooks
 
    #region private methods
 
    private Rectangle GetBounds(Func<IDirectCompositeChild, Rectangle> selector)
    {
        float minX = float.MaxValue;
        float minY = float.MaxValue;
        float maxX = float.MinValue;
        float maxY = float.MinValue;
 
        foreach (IDirectCompositeChild child in _children)
        {
            if (!child.Visible)
                continue;
 
            Rectangle bounds = selector(child);
 
            if (bounds.IsEmpty)
                continue;
 
            minX = Math.Min(minX, bounds.Left);
            minY = Math.Min(minY, bounds.Top);
            maxX = Math.Max(maxX, bounds.Right);
            maxY = Math.Max(maxY, bounds.Bottom);
        }
 
        if (minX == float.MaxValue)
            return Rectangle.Empty;
 
        return Rectangle.FromLTRB(
            (int)Math.Floor(minX),
            (int)Math.Floor(minY),
            (int)Math.Ceiling(maxX),
            (int)Math.Ceiling(maxY));
    }
 
    private void ValidateChildIdentity(IDirectCompositeChild child)
    {
        if (!ReferenceEquals(child.RenderSurfaceHost, RenderSurfaceHost))
        {
            throw new ArgumentException("The child must belong to the same RenderSurfaceHost as the composite.", nameof(child));
        }
 
        if (child.Mode != Mode)
        {
            throw new ArgumentException($"The child drawing mode '{child.Mode}' does not match the composite drawing mode '{Mode}'.", nameof(child));
        }
    }
 
    private void ValidateAndAssignTarget(IDirectCompositeChild child)
    {
        if (Mode == DirectDrawingMode.SceneLayer)
        {
            SceneLayer childLayer = child.SceneLayer ?? throw new ArgumentException("A scene-layer child must reference a SceneLayer.", nameof(child));
 
            if (SceneLayer is null)
            {
                SceneLayer = childLayer;
            }
            else if (!ReferenceEquals(SceneLayer, childLayer))
            {
                throw new ArgumentException("All scene-layer children in a composite must reference the same SceneLayer.", nameof(child));
            }
 
            return;
        }
 
        if (child.View is null)
        {
            if (child is DirectComposite compositeChild &&
                compositeChild.Children.Count == 0)
            {
                throw new ArgumentException(
                    "An empty composite cannot be added in view mode because it has no View yet. Add at least one descendant first.",
                    nameof(child));
            }
 
            throw new ArgumentException("A view child must reference a View.", nameof(child));
        }
 
        View childView = child.View;
        if (View is null)
        {
            View = childView;
        }
        else if (!ReferenceEquals(View, childView))
        {
            throw new ArgumentException("All view children in a composite must reference the same View.", nameof(child));
        }
    }
 
    private void ValidateParentRelationship(IDirectCompositeChild child)
    {
        lock (_parentSyncRoot)
        {
            if (_parents.TryGetValue(child, out DirectComposite? existingParent))
            {
                throw new InvalidOperationException($"The child already belongs to composite '{existingParent.Nickname}'.");
            }
 
            if (child is not DirectComposite childComposite)
                return;
 
            DirectComposite? ancestor = this;
 
            while (ancestor is not null)
            {
                if (ReferenceEquals(ancestor, childComposite))
                {
                    throw new InvalidOperationException("Adding the child would create a recursive composite cycle.");
                }
 
                _parents.TryGetValue(ancestor, out ancestor);
            }
        }
    }
 
    private void RegisterParent(IDirectCompositeChild child)
    {
        lock (_parentSyncRoot)
            _parents.Add(child, this);
    }
 
    private void UnregisterParent(IDirectCompositeChild child)
    {
        lock (_parentSyncRoot)
        {
            if (_parents.TryGetValue(child, out DirectComposite? parent) &&
                ReferenceEquals(parent, this))
            {
                _parents.Remove(child);
            }
        }
    }
 
    private void ResetTargetWhenEmpty()
    {
        if (_children.Count != 0)
            return;
 
        SceneLayer = null;
        View = null;
    }
 
    private void OnChildDisposing(object? sender, IDirectDrawable drawing)
    {
        if (drawing is not IDirectCompositeChild child)
            return;
 
        child.Disposing -= OnChildDisposing;
 
        if (!_children.Remove(child))
            return;
 
        _localOffsetPx.Remove(child);
        UnregisterParent(child);
        ResetTargetWhenEmpty();
 
        OnChildRemoved(child);
    }
 
    #endregion private methods
}