Lattice/Lattice.Core.Docking/Engine/LayoutManager.cs

using Lattice.Core.Docking.Abstractions;
using Lattice.Core.Docking.Models;
using System.Collections.ObjectModel;
using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("Lattice.Serialization.Docking")]

namespace Lattice.Core.Docking.Engine;

/// <summary>
/// Центральный менеджер макета, управляющий всей структурой док-системы.
/// Координирует дерево компоновки, плавающие окна, автоскрываемые панели
/// и предоставляет API для манипуляции макетом.
/// </summary>
/// <remarks>
/// Этот класс является основным координатором док-системы. Он управляет:
/// <list type="bullet">
/// <item>Деревом компоновки главного окна</item>
/// <item>Коллекцией плавающих окон</item>
/// <item>Коллекцией автоскрываемых панелей</item>
/// <item>Реестром типов контента</item>
/// </list>
/// Все изменения в структуре макета должны выполняться через методы этого класса.
/// </remarks>
public class LayoutManager
{
    private readonly ObservableCollection<AutoHidePanel> _autoHidePanels = new();
    private IDockElement? _root;

    /// <summary>
    /// Получает или задает корневой элемент дерева компоновки главного окна.
    /// </summary>
    /// <value>
    /// Корневой элемент или null, если макет пуст.
    /// </value>
    /// <remarks>
    /// При изменении этого свойства генерируется событие <see cref="LayoutUpdated"/>.
    /// </remarks>
    public IDockElement? Root
    {
        get => _root;
        internal set
        {
            if (_root != value)
            {
                _root = value;
                LayoutUpdated?.Invoke();
            }
        }
    }

    /// <summary>
    /// Получает список активных плавающих окон.
    /// </summary>
    /// <value>
    /// Коллекция объектов <see cref="DockWindow"/>, представляющих плавающие окна.
    /// </value>
    public List<DockWindow> FloatingWindows { get; } = new();

    /// <summary>
    /// Получает коллекцию автоскрываемых панелей.
    /// </summary>
    /// <value>
    /// Доступная только для чтения коллекция объектов <see cref="AutoHidePanel"/>.
    /// </value>
    public ReadOnlyObservableCollection<AutoHidePanel> AutoHidePanels { get; }

    /// <summary>
    /// Получает или задает реестр типов контента.
    /// </summary>
    /// <value>
    /// Реестр типов контента или null, если реестр не установлен.
    /// </value>
    public Services.ContentRegistry? ContentRegistry { get; set; }

    /// <summary>
    /// Происходит при изменении структуры дерева компоновки.
    /// </summary>
    /// <remarks>
    /// Событие генерируется при любых изменениях в дереве компоновки,
    /// включая добавление, удаление или перемещение элементов.
    /// </remarks>
    public event Action? LayoutUpdated;

    /// <summary>
    /// Происходит при изменении коллекции автоскрываемых панелей.
    /// </summary>
    public event EventHandler? AutoHidePanelsChanged;

    /// <summary>
    /// Инициализирует новый экземпляр класса <see cref="LayoutManager"/>.
    /// </summary>
    public LayoutManager()
    {
        AutoHidePanels = new ReadOnlyObservableCollection<AutoHidePanel>(_autoHidePanels);
    }

    /// <summary>
    /// Добавляет автоскрываемую панель с указанным содержимым к заданной стороне окна.
    /// </summary>
    /// <param name="content">Содержимое панели.</param>
    /// <param name="side">Сторона окна для прикрепления панели.</param>
    /// <returns>
    /// Созданная автоскрываемая панель.
    /// </returns>
    /// <exception cref="ArgumentNullException">
    /// Выбрасывается, когда <paramref name="content"/> равен null.
    /// </exception>
    public AutoHidePanel AddAutoHidePanel(IDockContent content, DockSide side)
    {
        if (content == null) throw new ArgumentNullException(nameof(content));

        var panel = new AutoHidePanel(content, side);
        _autoHidePanels.Add(panel);
        AutoHidePanelsChanged?.Invoke(this, EventArgs.Empty);
        return panel;
    }

    /// <summary>
    /// Удаляет автоскрываемую панель из коллекции.
    /// </summary>
    /// <param name="panel">Панель для удаления.</param>
    /// <returns>
    /// true, если панель была успешно удалена; в противном случае false.
    /// </returns>
    /// <exception cref="ArgumentNullException">
    /// Выбрасывается, когда <paramref name="panel"/> равен null.
    /// </exception>
    public bool RemoveAutoHidePanel(AutoHidePanel panel)
    {
        if (panel == null) throw new ArgumentNullException(nameof(panel));

        if (_autoHidePanels.Remove(panel))
        {
            AutoHidePanelsChanged?.Invoke(this, EventArgs.Empty);
            return true;
        }
        return false;
    }

    /// <summary>
    /// Создает документ указанного типа контента с заданным идентификатором.
    /// </summary>
    /// <param name="contentTypeId">Идентификатор типа контента.</param>
    /// <param name="id">Уникальный идентификатор документа.</param>
    /// <returns>
    /// Созданный контент или null, если ContentRegistry не установлен
    /// или тип контента не зарегистрирован.
    /// </returns>
    public IDockContent? CreateDocument(string contentTypeId, string id)
    {
        if (ContentRegistry == null || !ContentRegistry.IsRegistered(contentTypeId))
            return null;

        return ContentRegistry.CreateContent(contentTypeId, id);
    }

    /// <summary>
    /// Выполняет перемещение элемента в макете относительно целевого элемента.
    /// </summary>
    /// <param name="source">Перемещаемый элемент.</param>
    /// <param name="target">Целевой элемент, относительно которого выполняется перемещение.</param>
    /// <param name="position">Позиция перемещения относительно цели.</param>
    /// <param name="asDocument">
    /// Если true, контент будет добавлен как документ в центральную область.
    /// В текущей реализации этот параметр не используется.
    /// </param>
    /// <exception cref="ArgumentNullException">
    /// Выбрасывается, когда <paramref name="source"/> равен null.
    /// </exception>
    /// <remarks>
    /// Метод выполняет следующие шаги:
    /// <list type="number">
    /// <item>Удаляет источник из текущего местоположения</item>
    /// <item>Вставляет источник в новое местоположение относительно цели</item>
    /// <item>Обновляет структуру дерева компоновки</item>
    /// </list>
    /// Если <paramref name="target"/> равен null, элемент помещается в новое плавающее окно.
    /// </remarks>
    public void Move(IDockElement source, IDockElement? target,
        DockPosition position, bool asDocument = false)
    {
        if (source == null) throw new ArgumentNullException(nameof(source));
        if (source == target) return;

        // 1. Удаляем источник из текущего местоположения
        bool sourceRemoved = false;

        if (Root != null && IsDescendantOf(source, Root))
        {
            Root = DockOperations.Remove(source, Root);
            sourceRemoved = true;
        }
        else
        {
            sourceRemoved = RemoveFromFloatingWindows(source);
        }

        if (!sourceRemoved)
        {
            // Проверяем автоскрываемые панели
            var autoHidePanel = _autoHidePanels.FirstOrDefault(p => p.Content == source);
            if (autoHidePanel != null)
            {
                _autoHidePanels.Remove(autoHidePanel);
                sourceRemoved = true;
                AutoHidePanelsChanged?.Invoke(this, EventArgs.Empty);
            }
        }

        if (!sourceRemoved) return;

        // 2. Вставляем в цель
        if (target == null)
        {
            // Создаем новое плавающее окно
            FloatingWindows.Add(new DockWindow { Root = source });
        }
        else
        {
            if (Root != null && IsDescendantOf(target, Root))
            {
                Root = DockOperations.Insert(target, source, position, Root);
            }
            else
            {
                InsertIntoFloatingWindow(target, source, position);
            }
        }

        LayoutUpdated?.Invoke();
    }

    /// <summary>
    /// Удаляет элемент из всех плавающих окон.
    /// </summary>
    /// <param name="element">Элемент для удаления.</param>
    /// <returns>
    /// true, если элемент был найден и удален; в противном случае false.
    /// </returns>
    private bool RemoveFromFloatingWindows(IDockElement element)
    {
        foreach (var win in FloatingWindows.ToArray())
        {
            if (win.Root != null && IsDescendantOf(element, win.Root))
            {
                win.Root = DockOperations.Remove(element, win.Root);
                if (win.Root == null)
                    FloatingWindows.Remove(win);
                return true;
            }
        }
        return false;
    }

    /// <summary>
    /// Вставляет элемент в плавающее окно, содержащее целевой элемент.
    /// </summary>
    /// <param name="target">Целевой элемент в плавающем окне.</param>
    /// <param name="source">Вставляемый элемент.</param>
    /// <param name="position">Позиция вставки.</param>
    private void InsertIntoFloatingWindow(IDockElement target, IDockElement source,
        DockPosition position)
    {
        foreach (var win in FloatingWindows)
        {
            if (win.Root != null && IsDescendantOf(target, win.Root))
            {
                win.Root = DockOperations.Insert(target, source, position, win.Root);
                return;
            }
        }
    }

    /// <summary>
    /// Определяет, является ли элемент потомком указанного предка.
    /// </summary>
    /// <param name="element">Проверяемый элемент.</param>
    /// <param name="ancestor">Предполагаемый предок.</param>
    /// <returns>
    /// true, если элемент является потомком предка; в противном случае false.
    /// </returns>
    private bool IsDescendantOf(IDockElement element, IDockElement ancestor)
    {
        if (element == ancestor) return true;
        if (ancestor is DockGroup group)
            return IsDescendantOf(element, group.First) || IsDescendantOf(element, group.Second);
        return false;
    }

    /// <summary>
    /// Находит элемент по его идентификатору во всех окнах (главном и плавающих).
    /// </summary>
    /// <param name="id">Идентификатор элемента для поиска.</param>
    /// <returns>
    /// Найденный элемент или null, если элемент с таким идентификатором не найден.
    /// </returns>
    public IDockElement? FindById(string id)
    {
        if (string.IsNullOrEmpty(id)) return null;

        var found = FindRecursive(Root, id);
        if (found != null) return found;

        foreach (var win in FloatingWindows)
        {
            found = FindRecursive(win.Root, id);
            if (found != null) return found;
        }
        return null;
    }

    /// <summary>
    /// Рекурсивно ищет элемент по идентификатору в поддереве.
    /// </summary>
    /// <param name="node">Корневой узел поддерева для поиска.</param>
    /// <param name="id">Идентификатор элемента для поиска.</param>
    /// <returns>
    /// Найденный элемент или null, если элемент не найден.
    /// </returns>
    private IDockElement? FindRecursive(IDockElement? node, string id)
    {
        if (node == null) return null;
        if (node.Id == id) return node;

        if (node is DockGroup g)
            return FindRecursive(g.First, id) ?? FindRecursive(g.Second, id);

        return null;
    }

    /// <summary>
    /// Сбрасывает макет к состоянию по умолчанию.
    /// </summary>
    /// <remarks>
    /// Метод выполняет следующие действия:
    /// <list type="bullet">
    /// <item>Очищает корневой элемент</item>
    /// <item>Закрывает все плавающие окна</item>
    /// <item>Удаляет все автоскрываемые панели</item>
    /// <item>Генерирует соответствующие события</item>
    /// </list>
    /// </remarks>
    public void Reset()
    {
        Root = null;
        FloatingWindows.Clear();
        _autoHidePanels.Clear();
        LayoutUpdated?.Invoke();
        AutoHidePanelsChanged?.Invoke(this, EventArgs.Empty);
    }

    /// <summary>
    /// Находит элемент по идентификатору в дереве компоновки.
    /// </summary>
    /// <param name="id">Идентификатор элемента для поиска.</param>
    /// <returns>
    /// Найденный элемент или null, если элемент с таким идентификатором не найден.
    /// </returns>
    public IDockElement? FindElementById(string id)
    {
        return FindElementByIdRecursive(Root, id) ??
               FloatingWindows.Select(w => FindElementByIdRecursive(w.Root, id))
                              .FirstOrDefault(result => result != null);
    }

    /// <summary>
    /// Рекурсивно ищет элемент по идентификатору в поддереве.
    /// </summary>
    /// <param name="element">Корневой элемент поддерева для поиска.</param>
    /// <param name="id">Идентификатор элемента для поиска.</param>
    /// <returns>
    /// Найденный элемент или null, если элемент не найден.
    /// </returns>
    private IDockElement? FindElementByIdRecursive(IDockElement? element, string id)
    {
        if (element == null) return null;
        if (element.Id == id) return element;

        if (element is DockGroup group)
        {
            return FindElementByIdRecursive(group.First, id) ??
                   FindElementByIdRecursive(group.Second, id);
        }

        return null;
    }
}