using Microsoft.Extensions.Logging;
using StellaOps.Scanner.Surface.Models;

namespace StellaOps.Scanner.Surface.Discovery;

/// <summary>
/// Registry for surface entry and entry point collectors.
/// </summary>
public interface ISurfaceEntryRegistry
{
    /// <summary>Registers a surface entry collector.</summary>
    void RegisterCollector(ISurfaceEntryCollector collector);

    /// <summary>Registers an entry point collector.</summary>
    void RegisterEntryPointCollector(IEntryPointCollector collector);

    /// <summary>Gets all registered surface entry collectors.</summary>
    IReadOnlyList<ISurfaceEntryCollector> GetCollectors();

    /// <summary>Gets all registered entry point collectors.</summary>
    IReadOnlyList<IEntryPointCollector> GetEntryPointCollectors();

    /// <summary>Gets collectors that support the specified surface type.</summary>
    IReadOnlyList<ISurfaceEntryCollector> GetCollectorsForType(SurfaceType type);

    /// <summary>Gets entry point collectors that support the specified language.</summary>
    IReadOnlyList<IEntryPointCollector> GetEntryPointCollectorsForLanguage(string language);
}

/// <summary>
/// Default implementation of surface entry registry.
/// </summary>
public sealed class SurfaceEntryRegistry : ISurfaceEntryRegistry
{
    private readonly List<ISurfaceEntryCollector> _collectors = [];
    private readonly List<IEntryPointCollector> _entryPointCollectors = [];
    private readonly ILogger<SurfaceEntryRegistry> _logger;
    private readonly object _lock = new();

    public SurfaceEntryRegistry(ILogger<SurfaceEntryRegistry> logger)
    {
        _logger = logger;
    }

    public void RegisterCollector(ISurfaceEntryCollector collector)
    {
        ArgumentNullException.ThrowIfNull(collector);
        lock (_lock)
        {
            if (_collectors.Any(c => c.CollectorId == collector.CollectorId))
            {
                _logger.LogWarning("Collector {CollectorId} already registered, skipping", collector.CollectorId);
                return;
            }
            _collectors.Add(collector);
            _logger.LogDebug("Registered surface collector: {CollectorId}", collector.CollectorId);
        }
    }

    public void RegisterEntryPointCollector(IEntryPointCollector collector)
    {
        ArgumentNullException.ThrowIfNull(collector);
        lock (_lock)
        {
            if (_entryPointCollectors.Any(c => c.CollectorId == collector.CollectorId))
            {
                _logger.LogWarning("Entry point collector {CollectorId} already registered, skipping", collector.CollectorId);
                return;
            }
            _entryPointCollectors.Add(collector);
            _logger.LogDebug("Registered entry point collector: {CollectorId}", collector.CollectorId);
        }
    }

    public IReadOnlyList<ISurfaceEntryCollector> GetCollectors()
    {
        lock (_lock) return [.. _collectors];
    }

    public IReadOnlyList<IEntryPointCollector> GetEntryPointCollectors()
    {
        lock (_lock) return [.. _entryPointCollectors];
    }

    public IReadOnlyList<ISurfaceEntryCollector> GetCollectorsForType(SurfaceType type)
    {
        lock (_lock)
        {
            return [.. _collectors.Where(c => c.SupportedTypes.Contains(type))];
        }
    }

    public IReadOnlyList<IEntryPointCollector> GetEntryPointCollectorsForLanguage(string language)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(language);
        lock (_lock)
        {
            return [.. _entryPointCollectors.Where(c => 
                c.SupportedLanguages.Contains(language, StringComparer.OrdinalIgnoreCase))];
        }
    }
}