using System.Reflection;
using Microsoft.Extensions.DependencyInjection;
using StellaOps.Router.Common.Models;

namespace StellaOps.Microservice;

/// <summary>
/// Discovers endpoints using runtime reflection.
/// </summary>
public sealed class ReflectionEndpointDiscoveryProvider : IEndpointDiscoveryProvider
{
    private readonly StellaMicroserviceOptions _options;
    private readonly IEnumerable<Assembly> _assemblies;
    private readonly IServiceProviderIsService? _serviceProviderIsService;

    /// <summary>
    /// Initializes a new instance of the <see cref="ReflectionEndpointDiscoveryProvider"/> class.
    /// </summary>
    /// <param name="options">The microservice options.</param>
    /// <param name="assemblies">The assemblies to scan for endpoints.</param>
    public ReflectionEndpointDiscoveryProvider(
        StellaMicroserviceOptions options,
        IEnumerable<Assembly>? assemblies = null,
        IServiceProviderIsService? serviceProviderIsService = null)
    {
        _options = options;
        _assemblies = assemblies ?? AppDomain.CurrentDomain.GetAssemblies();
        _serviceProviderIsService = serviceProviderIsService;
    }

    /// <inheritdoc />
    public IReadOnlyList<EndpointDescriptor> DiscoverEndpoints()
    {
        var endpoints = new List<EndpointDescriptor>();

        foreach (var assembly in _assemblies)
        {
            try
            {
                foreach (var type in assembly.GetTypes())
                {
                    var attribute = type.GetCustomAttribute<StellaEndpointAttribute>();
                    if (attribute is null) continue;

                    if (!typeof(IStellaEndpoint).IsAssignableFrom(type))
                    {
                        throw new InvalidOperationException(
                            $"Type {type.FullName} has [StellaEndpoint] but does not implement IStellaEndpoint.");
                    }

                    if (_serviceProviderIsService is not null && !_serviceProviderIsService.IsService(type))
                    {
                        continue;
                    }

                    var claims = attribute.RequiredClaims
                        .Select(c => new ClaimRequirement { Type = c })
                        .ToList();

                    var descriptor = new EndpointDescriptor
                    {
                        ServiceName = _options.ServiceName,
                        Version = _options.Version,
                        Method = attribute.Method,
                        Path = attribute.Path,
                        DefaultTimeout = TimeSpan.FromSeconds(attribute.TimeoutSeconds),
                        SupportsStreaming = attribute.SupportsStreaming,
                        RequiringClaims = claims,
                        HandlerType = type
                    };

                    endpoints.Add(descriptor);
                }
            }
            catch (ReflectionTypeLoadException)
            {
                // Skip assemblies that cannot be loaded
            }
        }

        return endpoints;
    }
}