using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Options;
using StellaOps.Scanner.EntryTrace.Diagnostics;
using StellaOps.Scanner.EntryTrace.Runtime;
using StellaOps.Scanner.EntryTrace.Semantic;
using StellaOps.Scanner.EntryTrace.Semantic.Adapters;
using StellaOps.Scanner.EntryTrace.Semantic.Analysis;

namespace StellaOps.Scanner.EntryTrace;

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddEntryTraceAnalyzer(this IServiceCollection services, Action<EntryTraceAnalyzerOptions>? configure = null)
    {
        if (services is null)
        {
            throw new ArgumentNullException(nameof(services));
        }

        services.AddOptions<EntryTraceAnalyzerOptions>()
            .BindConfiguration(EntryTraceAnalyzerOptions.SectionName);

        if (configure is not null)
        {
            services.Configure(configure);
        }

        services.TryAddSingleton<EntryTraceMetrics>();
        services.TryAddSingleton<IEntryTraceAnalyzer, EntryTraceAnalyzer>();
        services.TryAddSingleton<EntryTraceRuntimeReconciler>();
        services.TryAddSingleton<IEntryTraceResultStore, NullEntryTraceResultStore>();
        return services;
    }

    /// <summary>
    /// Adds entry trace analyzer with integrated semantic analysis.
    /// </summary>
    /// <remarks>
    /// Part of Sprint 0411 - Semantic Entrypoint Engine (Task 17).
    /// </remarks>
    public static IServiceCollection AddSemanticEntryTraceAnalyzer(
        this IServiceCollection services,
        Action<EntryTraceAnalyzerOptions>? configure = null,
        Action<SemanticAnalysisOptions>? configureSemantic = null)
    {
        if (services is null)
        {
            throw new ArgumentNullException(nameof(services));
        }

        // Add base entry trace analyzer
        services.AddEntryTraceAnalyzer(configure);

        // Add semantic analysis options
        services.AddOptions<SemanticAnalysisOptions>()
            .BindConfiguration(SemanticAnalysisOptions.SectionName);

        if (configureSemantic is not null)
        {
            services.Configure(configureSemantic);
        }

        // Register semantic analysis components
        services.TryAddSingleton<CapabilityDetector>();
        services.TryAddSingleton<ThreatVectorInferrer>();
        services.TryAddSingleton<DataBoundaryMapper>();

        // Register language adapters
        services.TryAddEnumerable(ServiceDescriptor.Singleton<ISemanticEntrypointAnalyzer, PythonSemanticAdapter>());
        services.TryAddEnumerable(ServiceDescriptor.Singleton<ISemanticEntrypointAnalyzer, JavaSemanticAdapter>());
        services.TryAddEnumerable(ServiceDescriptor.Singleton<ISemanticEntrypointAnalyzer, NodeSemanticAdapter>());
        services.TryAddEnumerable(ServiceDescriptor.Singleton<ISemanticEntrypointAnalyzer, DotNetSemanticAdapter>());
        services.TryAddEnumerable(ServiceDescriptor.Singleton<ISemanticEntrypointAnalyzer, GoSemanticAdapter>());

        // Register orchestrator
        services.TryAddSingleton<SemanticEntrypointOrchestrator>(sp =>
        {
            var adapters = sp.GetServices<ISemanticEntrypointAnalyzer>().ToList();
            var capabilityDetector = sp.GetRequiredService<CapabilityDetector>();
            var threatInferrer = sp.GetRequiredService<ThreatVectorInferrer>();
            var boundaryMapper = sp.GetRequiredService<DataBoundaryMapper>();
            return new SemanticEntrypointOrchestrator(adapters, capabilityDetector, threatInferrer, boundaryMapper);
        });

        // Register semantic entry trace analyzer
        services.TryAddSingleton<ISemanticEntryTraceAnalyzer, SemanticEntryTraceAnalyzer>();

        return services;
    }
}

/// <summary>
/// Options for semantic analysis behavior.
/// </summary>
public sealed class SemanticAnalysisOptions
{
    public const string SectionName = "Scanner:EntryTrace:Semantic";

    /// <summary>Whether semantic analysis is enabled.</summary>
    public bool Enabled { get; set; } = true;

    /// <summary>Minimum confidence threshold for threat vectors (0.0-1.0).</summary>
    public double ThreatConfidenceThreshold { get; set; } = 0.3;

    /// <summary>Maximum number of threat vectors to emit per entrypoint.</summary>
    public int MaxThreatVectors { get; set; } = 50;

    /// <summary>Whether to include low-confidence capabilities.</summary>
    public bool IncludeLowConfidenceCapabilities { get; set; } = false;

    /// <summary>Languages to include in semantic analysis (empty = all).</summary>
    public IReadOnlyList<string> EnabledLanguages { get; set; } = Array.Empty<string>();
}