// Copyright (c) StellaOps. All rights reserved.
// Licensed under AGPL-3.0-or-later. See LICENSE in the project root.

using Microsoft.Extensions.Logging;

namespace StellaOps.BinaryIndex.Disassembly;

/// <summary>
/// Default implementation of the disassembly plugin registry.
/// </summary>
public sealed class DisassemblyPluginRegistry : IDisassemblyPluginRegistry
{
    private readonly ILogger<DisassemblyPluginRegistry> _logger;
    private readonly List<IDisassemblyPlugin> _plugins;

    /// <summary>
    /// Creates a new plugin registry with the given plugins.
    /// </summary>
    /// <param name="plugins">The registered plugins.</param>
    /// <param name="logger">Logger instance.</param>
    public DisassemblyPluginRegistry(
        IEnumerable<IDisassemblyPlugin> plugins,
        ILogger<DisassemblyPluginRegistry> logger)
    {
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        _plugins = (plugins ?? throw new ArgumentNullException(nameof(plugins)))
            .OrderByDescending(p => p.Capabilities.Priority)
            .ToList();

        _logger.LogInformation(
            "Disassembly plugin registry initialized with {Count} plugins: {Plugins}",
            _plugins.Count,
            string.Join(", ", _plugins.Select(p => p.Capabilities.PluginId)));
    }

    /// <inheritdoc />
    public IReadOnlyList<IDisassemblyPlugin> Plugins => _plugins;

    /// <inheritdoc />
    public IDisassemblyPlugin? FindPlugin(CpuArchitecture architecture, BinaryFormat format)
    {
        var plugin = _plugins.FirstOrDefault(p => p.Capabilities.CanHandle(architecture, format));

        if (plugin != null)
        {
            _logger.LogDebug(
                "Selected plugin {Plugin} for architecture {Arch} and format {Format}",
                plugin.Capabilities.PluginId, architecture, format);
        }
        else
        {
            _logger.LogWarning(
                "No plugin found for architecture {Arch} and format {Format}",
                architecture, format);
        }

        return plugin;
    }

    /// <inheritdoc />
    public IEnumerable<IDisassemblyPlugin> FindPluginsForArchitecture(CpuArchitecture architecture)
    {
        return _plugins.Where(p => p.Capabilities.SupportsArchitecture(architecture));
    }

    /// <inheritdoc />
    public IEnumerable<IDisassemblyPlugin> FindPluginsForFormat(BinaryFormat format)
    {
        return _plugins.Where(p => p.Capabilities.SupportsFormat(format));
    }

    /// <inheritdoc />
    public IDisassemblyPlugin? GetPlugin(string pluginId)
    {
        return _plugins.FirstOrDefault(p =>
            p.Capabilities.PluginId.Equals(pluginId, StringComparison.OrdinalIgnoreCase));
    }
}