using System.Diagnostics;
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;
using Morph.AiKit.Agents;
using Morph.AiKit.Observability;
using Morph.AiKit.Providers;
using Morph.AiKit.Tests.Fakes;
using Xunit;

namespace Morph.AiKit.Tests;

/// <summary>
/// Canarios da telemetria (T12). O arquivo inteiro mede <b>spans</b>, com
/// <see cref="ActivityListener"/> — nao propriedades de configuracao. Um guard contra span
/// duplicado so pode ser provado contando spans.
/// </summary>
/// <remarks>
/// Cada caso usa um <c>SourceName</c> unico, para que um teste nunca conte o span do outro.
/// </remarks>
public sealed class TelemetryTests
{
    private const string Document = """
    {
      "version": "2.0",
      "defaultAlias": "text",
      "aliases": {
        "text": {
          "provider": "openai",
          "model": "gpt-5.4-mini",
          "pricing": { "inputPerMTok": 0.25, "outputPerMTok": 2.0 }
        }
      }
    }
    """;

    private static AgentSpec Spec(AgentSpecOptions? options = null)
        => new()
        {
            Alias = "text",
            Instructions = "voce e um agente de teste",
            Name = "agente-instrumentado",
            Options = options ?? new AgentSpecOptions(),
        };

    // ---------------------------------------------------------------------------------
    // O caso normal: um span de agente, um span de chat
    // ---------------------------------------------------------------------------------

    /// <summary>
    /// A forma que as GenAI conventions descrevem: <c>invoke_agent</c> como raiz e
    /// <c>chat</c> como filho. Este teste tambem e a prova de que a escolha da T10 de montar
    /// o proprio pipeline nao custou o span de chat — ele so existe porque a T12 o coloca.
    /// </summary>
    [Fact]
    public async Task AnInstrumentedAgentEmitsOneInvokeAgentSpanAndOneChatSpan()
    {
        var source = NewSourceName();

        var spans = await CollectAsync(source, () => BuildAgent(
            new MorphTelemetryOptions { SourceName = source },
            leaf: new FakeChatClient().EnqueueText("pronto")));

        Assert.Equal(1, CountOf(spans, "invoke_agent"));
        Assert.Equal(1, CountOf(spans, "chat"));
        Assert.Null(Single(spans, "invoke_agent").Parent);
        Assert.NotNull(Single(spans, "chat").Parent);
    }

    // ---------------------------------------------------------------------------------
    // O guard — as duas metades da mesma afirmacao
    // ---------------------------------------------------------------------------------

    /// <summary>
    /// <b>O guard, no default.</b> Um pipeline que ja carrega instrumentacao (o caso real:
    /// um <c>IChatClient</c> que veio do DI ja instrumentado) continua com UM span de chat.
    /// </summary>
    [Fact]
    public async Task TheDefaultDoesNotAddASecondChatSpanOverAnAlreadyInstrumentedPipeline()
    {
        var source = NewSourceName();

        var spans = await CollectAsync(source, () => BuildAgent(
            new MorphTelemetryOptions { SourceName = source },
            leaf: AlreadyInstrumented(source)));

        Assert.Equal(1, CountOf(spans, "invoke_agent"));
        Assert.Equal(1, CountOf(spans, "chat"));
    }

    /// <summary>
    /// <b>O guard, desligado.</b> Forcar <c>InstrumentChatClient = true</c> sobre o MESMO
    /// pipeline ja instrumentado produz o par duplicado. E o canario que documenta o risco:
    /// sem o ramo automatico, este e o resultado.
    /// </summary>
    [Fact]
    public async Task ForcingInstrumentChatClientProducesTheDuplicateChatSpan()
    {
        var source = NewSourceName();

        var spans = await CollectAsync(source, () => BuildAgent(
            new MorphTelemetryOptions { SourceName = source, InstrumentChatClient = true },
            leaf: AlreadyInstrumented(source)));

        Assert.Equal(1, CountOf(spans, "invoke_agent"));
        Assert.Equal(2, CountOf(spans, "chat"));
    }

    /// <summary>
    /// O mesmo guard no nivel do agente: aplicar a telemetria duas vezes no
    /// <see cref="AIAgentBuilder"/> nao produz dois <c>invoke_agent</c>.
    /// </summary>
    [Fact]
    public async Task TheAgentGuardKeepsASingleInvokeAgentSpanWhenTelemetryIsAppliedTwice()
    {
        var source = NewSourceName();
        var telemetry = new MorphTelemetryOptions { SourceName = source };

        var spans = await CollectAsync(source, () =>
        {
            var agent = BuildAgent(telemetry, new FakeChatClient().EnqueueText("pronto"));
            return agent.AsBuilder().UseMorphTelemetry(telemetry).Build();
        });

        Assert.Equal(1, CountOf(spans, "invoke_agent"));
    }

    /// <summary>
    /// <c>false</c> nao e o mesmo que o default. Com a <c>AgentFactory</c> — que monta o
    /// proprio pipeline — desligar a instrumentacao de chat deixa a invocacao com o span do
    /// agente e <b>nenhum</b> span de chat. O teste existe para que essa consequencia seja
    /// um fato escrito, e nao uma surpresa em producao.
    /// </summary>
    [Fact]
    public async Task TurningTheChatInstrumentationOffLeavesTheAgentSpanAndNoChatSpan()
    {
        var source = NewSourceName();

        var spans = await CollectAsync(source, () => BuildAgent(
            new MorphTelemetryOptions { SourceName = source, InstrumentChatClient = false },
            leaf: new FakeChatClient().EnqueueText("pronto")));

        Assert.Equal(1, CountOf(spans, "invoke_agent"));
        Assert.Equal(0, CountOf(spans, "chat"));
    }

    // ---------------------------------------------------------------------------------
    // Dado sensivel
    // ---------------------------------------------------------------------------------

    /// <summary>
    /// Conteudo sensivel nasce desligado nos dois niveis — o standard exige <c>false</c>
    /// fora de dev/staging, porque prompt e resposta sao PII do cliente.
    /// </summary>
    [Fact]
    public void SensitiveDataIsOffByDefaultAtBothLevels()
    {
        var agent = BuildAgent(
            new MorphTelemetryOptions { SourceName = NewSourceName() },
            new FakeChatClient());

        Assert.False(Assert.IsType<OpenTelemetryAgent>(agent).EnableSensitiveData);
        Assert.False(Assert.IsType<OpenTelemetryChatClient>(
            agent.GetService(typeof(OpenTelemetryChatClient))).EnableSensitiveData);
    }

    /// <summary>
    /// A spec pode ligar o dado sensivel para UM agente sem mexer na configuracao global —
    /// e o destino que a T7 declarou para <c>EnableSensitiveTelemetry</c>. Nulo na spec
    /// ("nao opinei") preserva o valor global; preenchido, vence.
    /// </summary>
    [Fact]
    public void TheSpecCanOverrideSensitiveDataForASingleAgent()
    {
        var telemetry = new MorphTelemetryOptions { SourceName = NewSourceName() };

        var loud = BuildAgent(
            telemetry,
            new FakeChatClient(),
            spec: Spec(new AgentSpecOptions { EnableSensitiveTelemetry = true }));

        Assert.True(Assert.IsType<OpenTelemetryAgent>(loud).EnableSensitiveData);
        Assert.True(Assert.IsType<OpenTelemetryChatClient>(
            loud.GetService(typeof(OpenTelemetryChatClient))).EnableSensitiveData);
    }

    // ---------------------------------------------------------------------------------
    // Configuracao invalida
    // ---------------------------------------------------------------------------------

    /// <summary>
    /// Source em branco e recusado na construcao: um <c>ActivitySource</c> sem nome nao pode
    /// ser registrado em <c>AddSource(...)</c>, e a telemetria sumiria em silencio.
    /// </summary>
    [Fact]
    public void ABlankSourceNameIsRefusedAtConstruction()
        => Assert.Throws<ArgumentException>(() => new MorphTelemetryOptions { SourceName = "   " });

    // ---------------------------------------------------------------------------------
    // Apoio dos testes
    // ---------------------------------------------------------------------------------

    private static string NewSourceName() => "morph.aikit.test." + Guid.CreateVersion7().ToString("N");

    /// <summary>Um pipeline que ja chega instrumentado — o caso real do cliente vindo do DI.</summary>
    private static IChatClient AlreadyInstrumented(string sourceName)
        => new FakeChatClient()
            .EnqueueText("pronto")
            .AsBuilder()
            .UseOpenTelemetry(sourceName: sourceName)
            .Build();

    private static AIAgent BuildAgent(MorphTelemetryOptions telemetry, IChatClient leaf, AgentSpec? spec = null)
    {
        using var registry = ModelRegistry.FromJson(Document, new FakeProviderClientFactory());
        var factory = new AgentFactory(
            registry,
            new AgentFactoryOptions { ChatClientSelector = (_, _) => leaf }.WithMorphTelemetry(telemetry));

        return factory.Create(spec ?? Spec());
    }

    /// <summary>
    /// Coleta os spans de UMA invocacao. O listener e registrado antes de o agente existir e
    /// removido no fim — telemetria e estado global do processo, e um listener vazado
    /// contaminaria os outros casos.
    /// </summary>
    private static async Task<IReadOnlyList<Activity>> CollectAsync(string sourceName, Func<AIAgent> build)
    {
        var spans = new List<Activity>();

        using var listener = new ActivityListener
        {
            ShouldListenTo = candidate => candidate.Name == sourceName,
            Sample = (ref ActivityCreationOptions<ActivityContext> _) => ActivitySamplingResult.AllDataAndRecorded,
            ActivityStopped = activity =>
            {
                lock (spans)
                {
                    spans.Add(activity);
                }
            },
        };

        ActivitySource.AddActivityListener(listener);

        var agent = build();
        var session = await agent.CreateSessionAsync(TestContext.Current.CancellationToken);
        _ = await agent.RunAsync("oi", session, cancellationToken: TestContext.Current.CancellationToken);

        lock (spans)
        {
            return [.. spans];
        }
    }

    private static int CountOf(IReadOnlyList<Activity> spans, string operation)
        => spans.Count(span => Equals(span.GetTagItem("gen_ai.operation.name"), operation));

    private static Activity Single(IReadOnlyList<Activity> spans, string operation)
        => spans.Single(span => Equals(span.GetTagItem("gen_ai.operation.name"), operation));
}