using Lattice.Core.Docking.Engine;
using Lattice.Core.Docking.Services;
using Lattice.UI.Docking.Abstractions;
using Lattice.UI.Docking.Factories;

namespace Lattice.UI.Docking;

/// <summary>
/// Предоставляет статический API для инициализации и управления UI-фреймворком Lattice.
/// </summary>
public static class LatticeUIFramework
{
    private static bool _isInitialized;
    private static LatticeBuilder? _currentBuilder;

    /// <summary>
    /// Получает значение, указывающее, инициализирован ли фреймворк.
    /// </summary>
    public static bool IsInitialized => _isInitialized;

    /// <summary>
    /// Получает текущий строитель конфигурации фреймворка.
    /// </summary>
    public static LatticeBuilder CurrentBuilder
    {
        get
        {
            if (!_isInitialized)
                throw new InvalidOperationException("Lattice framework is not initialized. Call Initialize() first.");
            return _currentBuilder!;
        }
    }

    /// <summary>
    /// Получает менеджер макета из текущего строителя.
    /// </summary>
    public static LayoutManager? LayoutManager => _currentBuilder?.LayoutManager;

    /// <summary>
    /// Получает реестр контента из текущего строителя.
    /// </summary>
    public static ContentRegistry? ContentRegistry => _currentBuilder?.ContentRegistry;

    /// <summary>
    /// Получает фабрику контролов из текущего строителя.
    /// </summary>
    public static IDockControlFactory? ControlFactory => _currentBuilder?.ControlFactory;

    /// <summary>
    /// Получает менеджер контекстных меню из текущего строителя.
    /// </summary>
    public static IDockContextManager? ContextManager => _currentBuilder?.ContextManager;

    /// <summary>
    /// Получает UI-сервис из текущего строителя.
    /// </summary>
    public static IDockUIService? UIService => _currentBuilder?.UIService;

    /// <summary>
    /// Инициализирует фреймворк Lattice с указанными параметрами.
    /// </summary>
    public static LatticeBuilder Initialize(LatticeOptions? options = null)
    {
        if (_isInitialized)
            throw new InvalidOperationException("Lattice framework is already initialized");

        options ??= new LatticeOptions();

        var layoutManager = new LayoutManager();
        var contentRegistry = new ContentRegistry();

        _currentBuilder = new LatticeBuilder(layoutManager, contentRegistry, options);
        _isInitialized = true;

        return _currentBuilder;
    }

    /// <summary>
    /// Сбрасывает состояние фреймворка к неинициализированному.
    /// </summary>
    public static void Reset()
    {
        _isInitialized = false;
        _currentBuilder = null;
    }
}

/// <summary>
/// Представляет настройки инициализации фреймворка Lattice.
/// </summary>
public class LatticeOptions
{
    /// <summary>
    /// Получает или задает значение, указывающее, следует ли автоматически
    /// регистрировать стандартные команды.
    /// </summary>
    public bool RegisterDefaultCommands { get; set; } = true;

    /// <summary>
    /// Получает или задает значение, указывающее, следует ли автоматически
    /// создавать сервисы при их первом запросе.
    /// </summary>
    public bool AutoCreateServices { get; set; } = true;

    /// <summary>
    /// Получает или задает идентификатор приложения.
    /// </summary>
    public string? ApplicationId { get; set; }

    /// <summary>
    /// Получает или задает значение, указывающее, следует ли включить
    /// расширенное логирование операций системы.
    /// </summary>
    public bool EnableVerboseLogging { get; set; } = false;
}

/// <summary>
/// Предоставляет fluent-интерфейс для конфигурации фреймворка Lattice.
/// </summary>
public sealed class LatticeBuilder
{
    private readonly LayoutManager _layoutManager;
    private readonly ContentRegistry _contentRegistry;
    private readonly LatticeOptions _options;
    private IDockControlFactory? _controlFactory;
    private IDockContextManager? _contextManager;
    private IDockUIService? _uiService;
    private bool _isBuilt;

    /// <summary>
    /// Получает менеджер макета.
    /// </summary>
    public LayoutManager LayoutManager => _layoutManager;

    /// <summary>
    /// Получает реестр контента.
    /// </summary>
    public ContentRegistry ContentRegistry => _contentRegistry;

    /// <summary>
    /// Получает фабрику контролов.
    /// </summary>
    public IDockControlFactory? ControlFactory => _controlFactory;

    /// <summary>
    /// Получает менеджер контекстных меню.
    /// </summary>
    public IDockContextManager? ContextManager => _contextManager;

    /// <summary>
    /// Получает UI-сервис.
    /// </summary>
    public IDockUIService? UIService => _uiService;

    /// <summary>
    /// Инициализирует новый экземпляр класса <see cref="LatticeBuilder"/>.
    /// </summary>
    internal LatticeBuilder(LayoutManager layoutManager, ContentRegistry contentRegistry, LatticeOptions options)
    {
        _layoutManager = layoutManager ?? throw new ArgumentNullException(nameof(layoutManager));
        _contentRegistry = contentRegistry ?? throw new ArgumentNullException(nameof(contentRegistry));
        _options = options ?? throw new ArgumentNullException(nameof(options));

        _layoutManager.ContentRegistry = contentRegistry;
    }

    /// <summary>
    /// Регистрирует фабрику контролов для создания UI-элементов.
    /// </summary>
    public LatticeBuilder WithControlFactory(IDockControlFactory factory)
    {
        _controlFactory = factory ?? throw new ArgumentNullException(nameof(factory));
        return this;
    }

    /// <summary>
    /// Регистрирует менеджер контекстных меню для управления контекстными действиями.
    /// </summary>
    public LatticeBuilder WithContextManager(IDockContextManager manager)
    {
        _contextManager = manager ?? throw new ArgumentNullException(nameof(manager));
        return this;
    }

    /// <summary>
    /// Регистрирует UI-сервис для выполнения платформенно-зависимых операций.
    /// </summary>
    public LatticeBuilder WithUIService(IDockUIService service)
    {
        _uiService = service ?? throw new ArgumentNullException(nameof(service));
        return this;
    }

    /// <summary>
    /// Регистрирует тип контента в реестре.
    /// </summary>
    public LatticeBuilder RegisterContentType<T>(string contentTypeId, Func<T> factory, ContentMetadata? metadata = null)
        where T : Core.Docking.Abstractions.IDockContent
    {
        if (string.IsNullOrWhiteSpace(contentTypeId))
            throw new ArgumentNullException(nameof(contentTypeId));

        _contentRegistry.Register(contentTypeId, factory, metadata);
        return this;
    }

    /// <summary>
    /// Завершает конфигурацию фреймворка.
    /// </summary>
    public ILatticeFramework Build()
    {
        if (_isBuilt)
            throw new InvalidOperationException("Framework has already been built.");

        _isBuilt = true;
        return new LatticeFramework(this);
    }
}

/// <summary>
/// Предоставляет интерфейс для доступа к компонентам фреймворка Lattice.
/// </summary>
public interface ILatticeFramework
{
    /// <summary>
    /// Получает менеджер макета.
    /// </summary>
    LayoutManager LayoutManager { get; }

    /// <summary>
    /// Получает реестр контента.
    /// </summary>
    ContentRegistry ContentRegistry { get; }

    /// <summary>
    /// Получает фабрику контролов.
    /// </summary>
    IDockControlFactory? ControlFactory { get; }

    /// <summary>
    /// Получает менеджер контекстных меню.
    /// </summary>
    IDockContextManager? ContextManager { get; }

    /// <summary>
    /// Получает UI-сервис.
    /// </summary>
    IDockUIService? UIService { get; }
}

/// <summary>
/// Реализация интерфейса <see cref="ILatticeFramework"/>.
/// </summary>
internal class LatticeFramework : ILatticeFramework
{
    private readonly LatticeBuilder _builder;

    /// <summary>
    /// Инициализирует новый экземпляр класса <see cref="LatticeFramework"/>.
    /// </summary>
    public LatticeFramework(LatticeBuilder builder)
    {
        _builder = builder ?? throw new ArgumentNullException(nameof(builder));
    }

    /// <inheritdoc/>
    public LayoutManager LayoutManager => _builder.LayoutManager;

    /// <inheritdoc/>
    public ContentRegistry ContentRegistry => _builder.ContentRegistry;

    /// <inheritdoc/>
    public IDockControlFactory? ControlFactory => _builder.ControlFactory;

    /// <inheritdoc/>
    public IDockContextManager? ContextManager => _builder.ContextManager;

    /// <inheritdoc/>
    public IDockUIService? UIService => _builder.UIService;
}