<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" />
    <PackageReference Include="xunit" />
    <PackageReference Include="xunit.runner.visualstudio">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
    <PackageReference Include="FluentAssertions" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\Kds.Ai.AnomalyDetector\Kds.Ai.AnomalyDetector.csproj" />
    <ProjectReference Include="..\Kds.Ai.Data\Kds.Ai.Data.csproj" />
  </ItemGroup>
</Project>

<ItemGroup>
  <InternalsVisibleTo Include="Kds.Ai.AnomalyDetector.Tests" />
</ItemGroup>

<ItemGroup>
  <InternalsVisibleTo Include="Kds.Ai.AnomalyDetector.Tests" />
</ItemGroup>

using FluentAssertions;
using Kds.Ai.AnomalyDetector.Agents;
using Kds.Ai.AnomalyDetector.Alerts;
using Kds.Ai.AnomalyDetector.Mcp;
using Kds.Ai.AnomalyDetector.Orchestration;
using Kds.Ai.AnomalyDetector.Repositories;
using Kds.Ai.AnomalyDetector.Seeding;
using Kds.Ai.AnomalyDetector.Tests.Fakes;
using Kds.Ai.Data;
using Kds.Ai.Data.Entities;
using Kds.Ai.Data.Enums;
using Kds.Ai.Data.Repositories;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Xunit;

namespace Kds.Ai.AnomalyDetector.Tests.IntegrationTests;

public sealed class OrchestratorIntegrationTests : IAsyncLifetime
{
    private ServiceProvider _serviceProvider = null!;
    private KdsAiDbContext _dbContext = null!;
    
    public async Task InitializeAsync()
    {
        var services = new ServiceCollection();
        
        // In-memory database
        services.AddDbContext<KdsAiDbContext>(options =>
            options.UseInMemoryDatabase($"TestDb_{Guid.NewGuid()}"));
        
        // Logging
        services.AddLogging(b => b.AddProvider(NullLoggerProvider.Instance));
        
        // Repositories
        services.AddScoped<IMonitorSpecRepository, EfMonitorSpecRepository>();
        services.AddScoped<IMonitorRunRepository, EfMonitorRunRepository>();
        
        // Alert emitter
        services.AddScoped<IAlertEmitter, AlertEmitter>();
        
        // Seeder
        services.AddScoped<MonitorSpecSeeder>();
        
        _serviceProvider = services.BuildServiceProvider();
        _dbContext = _serviceProvider.GetRequiredService<KdsAiDbContext>();
        await _dbContext.Database.EnsureCreatedAsync();
    }
    
    public async Task DisposeAsync()
    {
        await _dbContext.DisposeAsync();
        await _serviceProvider.DisposeAsync();
    }
    
    [Fact]
    public async Task FullFlow_NoAnomaly_CreatesCompletedRun()
    {
        // Arrange
        var (tools, chat) = ScriptedAgentScenarios.NoAnomaly();
        var orchestrator = CreateOrchestrator(chat, tools);
        
        var spec = await CreateTestSpec("No Anomaly Test");
        
        // Act
        var run = await orchestrator.ExecuteAsync(spec.Id);
        
        // Assert
        run.Status.Should().Be(MonitorRunStatus.Completed);
        run.AnomaliesDetected.Should().Be(0);
        run.AlertEvents.Should().BeEmpty();
        run.CompletedAt.Should().NotBeNull();
    }
    
    [Fact]
    public async Task FullFlow_WithAnomaly_CreatesAlertAndRun()
    {
        // Arrange
        var (tools, chat) = ScriptedAgentScenarios.SingleAnomaly(EventSeverity.High);
        var orchestrator = CreateOrchestrator(chat, tools);
        
        var spec = await CreateTestSpec("Anomaly Detection Test");
        
        // Act
        var run = await orchestrator.ExecuteAsync(spec.Id);
        
        // Assert
        run.Status.Should().Be(MonitorRunStatus.Completed);
        run.AnomaliesDetected.Should().BeGreaterThan(0);
        run.AlertEvents.Should().NotBeEmpty();
        
        // Verify alert was created in the database
        var alert = run.AlertEvents.First();
        alert.Id.Should().NotBe(Guid.Empty);
        alert.Severity.Should().Be(EventSeverity.High);
        alert.Type.Should().Be(EventType.AiAnomaly);
    }
    
    [Fact]
    public async Task DryRun_DoesNotPersist()
    {
        // Arrange
        var (tools, chat) = ScriptedAgentScenarios.SingleAnomaly();
        var spec = await CreateTestSpec("Dry Run Test");
        var orchestrator = CreateOrchestrator(chat, tools);
        
        // Act
        var run = await orchestrator.ExecuteAsync(
            spec, 
            options: new RunOptions { DryRun = true });
        
        // Assert
        run.Status.Should().Be(MonitorRunStatus.Completed);
        
        // Verify nothing was persisted
        var runCount = await _dbContext.MonitorRuns.CountAsync();
        var alertCount = await _dbContext.Events.CountAsync();
        
        runCount.Should().Be(0);
        alertCount.Should().Be(0);
    }
    
    [Fact]
    public async Task SuppressAlerts_NoAlertEmitted()
    {
        // Arrange
        var (tools, chat) = ScriptedAgentScenarios.SingleAnomaly();
        var spec = await CreateTestSpec("Suppress Alert Test");
        var orchestrator = CreateOrchestrator(chat, tools);
        
        // Act
        var run = await orchestrator.ExecuteAsync(
            spec.Id, 
            options: new RunOptions { SuppressAlerts = true });
        
        // Assert
        run.AlertEvents.Should().BeEmpty();
        
        var alertCount = await _dbContext.Events.CountAsync();
        alertCount.Should().Be(0);
    }
    
    [Fact]
    public async Task SpecNotFound_ThrowsException()
    {
        // Arrange
        var (tools, chat) = ScriptedAgentScenarios.NoAnomaly();
        var orchestrator = CreateOrchestrator(chat, tools);
        
        // Act & Assert
        var act = () => orchestrator.ExecuteAsync(Guid.NewGuid());
        await act.Should().ThrowAsync<InvalidOperationException>()
            .WithMessage("*not found*");
    }
    
    [Fact]
    public async Task ExecuteAllActive_RunsOnlyActiveMonitors()
    {
        // Arrange
        var (tools, chat) = ScriptedAgentScenarios.NoAnomaly();
        var orchestrator = CreateOrchestrator(chat, tools);
        
        var specRepo = _serviceProvider.GetRequiredService<IMonitorSpecRepository>();
        
        // Create 3 specs: 2 active, 1 paused
        await CreateTestSpec("Active Monitor 1", MonitorState.Active);
        await CreateTestSpec("Active Monitor 2", MonitorState.Active);
        await CreateTestSpec("Paused Monitor", MonitorState.Paused);
        
        // Act
        var runs = await orchestrator.ExecuteAllActiveAsync();
        
        // Assert
        runs.Should().HaveCount(2);
        runs.Should().OnlyContain(r => r.Status == MonitorRunStatus.Completed);
    }
    
    [Fact]
    public async Task ExecuteAllActive_SkipsDraftAndArchivedMonitors()
    {
        // Arrange
        var (tools, chat) = ScriptedAgentScenarios.NoAnomaly();
        var orchestrator = CreateOrchestrator(chat, tools);
        
        // Create monitors in each state
        await CreateTestSpec("Draft Monitor", MonitorState.Draft);
        await CreateTestSpec("Active Monitor", MonitorState.Active);
        await CreateTestSpec("Paused Monitor", MonitorState.Paused);
        await CreateTestSpec("Archived Monitor", MonitorState.Archived);
        
        // Act
        var runs = await orchestrator.ExecuteAllActiveAsync();
        
        // Assert - only the Active monitor should run
        runs.Should().HaveCount(1);
    }
    
    [Fact]
    public async Task AgentError_RunMarkedAsFailed()
    {
        // Arrange
        var (tools, chat) = ScriptedAgentScenarios.DataError();
        var spec = await CreateTestSpec("Error Handling Test");
        var orchestrator = CreateOrchestrator(chat, tools);
        
        // Act
        var run = await orchestrator.ExecuteAsync(spec.Id);
        
        // Assert
        run.Status.Should().Be(MonitorRunStatus.Failed);
        run.ErrorMessage.Should().NotBeNullOrEmpty();
        run.CompletedAt.Should().NotBeNull();
    }
    
    [Fact]
    public async Task Run_RecordsDuration()
    {
        // Arrange
        var (tools, chat) = ScriptedAgentScenarios.NoAnomaly();
        var spec = await CreateTestSpec("Duration Test");
        var orchestrator = CreateOrchestrator(chat, tools);
        
        // Act
        var run = await orchestrator.ExecuteAsync(spec.Id);
        
        // Assert
        run.DurationMs.Should().BeGreaterOrEqualTo(0);
    }
    
    // === Helper Methods ===
    
    private async Task<MonitorSpec> CreateTestSpec(
        string name, 
        MonitorState state = MonitorState.Active)
    {
        var seeder = _serviceProvider.GetRequiredService<MonitorSpecSeeder>();
        return await seeder.EnsureAsync(
            name, 
            "Test system prompt: Analyze data and detect anomalies.",
            initialState: state);
    }
    
    private IMonitorRunOrchestrator CreateOrchestrator(
        FakeChatClient chat,
        FakeMcpToolProvider tools)
    {
        // Create agent with fakes (single generic agent, no factory)
        var agent = new AnomalyDetectorAgent(
            chat,
            tools,
            NullLogger<AnomalyDetectorAgent>.Instance);
        
        return new MonitorRunOrchestrator(
            _serviceProvider.GetRequiredService<IMonitorSpecRepository>(),
            _serviceProvider.GetRequiredService<IMonitorRunRepository>(),
            agent,
            _serviceProvider.GetRequiredService<IAlertEmitter>(),
            NullLogger<MonitorRunOrchestrator>.Instance);
    }
}

using FluentAssertions;
using Kds.Ai.AnomalyDetector.Agents;
using Kds.Ai.AnomalyDetector.Alerts;
using Kds.Ai.Data;
using Kds.Ai.Data.Entities;
using Kds.Ai.Data.Enums;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Xunit;

namespace Kds.Ai.AnomalyDetector.Tests.UnitTests;

public sealed class AlertEmitterTests : IAsyncLifetime
{
    private KdsAiDbContext _dbContext = null!;
    private AlertEmitter _emitter = null!;
    
    public async Task InitializeAsync()
    {
        var options = new DbContextOptionsBuilder<KdsAiDbContext>()
            .UseInMemoryDatabase($"AlertTest_{Guid.NewGuid()}")
            .Options;
        
        _dbContext = new KdsAiDbContext(options);
        _emitter = new AlertEmitter(_dbContext, NullLogger<AlertEmitter>.Instance);
        
        await _dbContext.Database.EnsureCreatedAsync();
    }
    
    public async Task DisposeAsync()
    {
        await _dbContext.DisposeAsync();
    }
    
    [Fact]
    public async Task EmitAsync_CreatesAlertWithCorrectFormat()
    {
        // Arrange
        var spec = CreateTestSpec("Prep Time Monitor - Downtown");
        var result = new AnomalyDetectionResult
        {
            AnomalyDetected = true,
            Severity = EventSeverity.High,
            Summary = "Prep times elevated during lunch",
            DetailedAnalysis = "Detailed markdown analysis...",
            Findings =
            [
                new AnomalyFinding
                { 
                    Description = "60% increase during 12:00-13:00",
                    Severity = EventSeverity.High,
                    AffectedPeriod = "2025-01-15 12:00-13:00",
                    Evidence = "Average 450s vs baseline 280s"
                }
            ]
        };
        
        // Act
        var alert = await _emitter.EmitAsync(spec, result);
        
        // Assert
        alert.Id.Should().NotBe(Guid.Empty);
        alert.Type.Should().Be(EventType.AiAnomaly);
        alert.Severity.Should().Be(EventSeverity.High);
        alert.Name.Should().Contain("[Prep Time Monitor - Downtown]");
        alert.Content.Should().Contain("## Findings");
        alert.Content.Should().Contain("60% increase during 12:00-13:00");
        alert.Content.Should().Contain("Evidence");
    }
    
    [Fact]
    public async Task EmitAsync_ThrowsForNonAnomaly()
    {
        // Arrange
        var spec = CreateTestSpec("Test Monitor");
        var result = AnomalyDetectionResult.NoAnomaly();
        
        // Act & Assert
        var act = () => _emitter.EmitAsync(spec, result);
        await act.Should().ThrowAsync<InvalidOperationException>();
    }
    
    [Fact]
    public async Task EmitAsync_MultipleFindings_AllIncludedInContent()
    {
        // Arrange
        var spec = CreateTestSpec("Multi-Finding Monitor");
        var result = new AnomalyDetectionResult
        {
            AnomalyDetected = true,
            Severity = EventSeverity.Medium,
            Summary = "Multiple anomalies detected",
            Findings =
            [
                new AnomalyFinding
                {
                    Description = "First anomaly",
                    Severity = EventSeverity.Medium,
                    AffectedPeriod = "12:00-13:00",
                    Evidence = "Evidence for first"
                },
                new AnomalyFinding
                {
                    Description = "Second anomaly",
                    Severity = EventSeverity.Low,
                    AffectedPeriod = "14:00-15:00",
                    Evidence = "Evidence for second"
                }
            ]
        };
        
        // Act
        var alert = await _emitter.EmitAsync(spec, result);
        
        // Assert
        alert.Content.Should().Contain("First anomaly");
        alert.Content.Should().Contain("Second anomaly");
        alert.Content.Should().Contain("Evidence for first");
        alert.Content.Should().Contain("Evidence for second");
    }
    
    [Fact]
    public async Task ShouldSuppressAsync_SuppressesDuplicateWithinWindow()
    {
        // Arrange
        var spec = CreateTestSpec("Dedup Monitor");
        var result = new AnomalyDetectionResult
        {
            AnomalyDetected = true,
            Severity = EventSeverity.Medium,
            Summary = "Test anomaly"
        };
        
        // Emit first alert
        await _emitter.EmitAsync(spec, result);
        
        // Act - check if second emission should be suppressed
        var shouldSuppress = await _emitter.ShouldSuppressAsync(spec, result);
        
        // Assert
        shouldSuppress.Should().BeTrue();
    }
    
    [Fact]
    public async Task ShouldSuppressAsync_DoesNotSuppressDifferentMonitors()
    {
        // Arrange
        var spec1 = CreateTestSpec("Monitor A");
        var spec2 = CreateTestSpec("Monitor B");
        var result = new AnomalyDetectionResult
        {
            AnomalyDetected = true,
            Severity = EventSeverity.Medium,
            Summary = "Test anomaly"
        };
        
        // Emit alert for monitor A
        await _emitter.EmitAsync(spec1, result);
        
        // Act - check if monitor B should be suppressed
        var shouldSuppress = await _emitter.ShouldSuppressAsync(spec2, result);
        
        // Assert
        shouldSuppress.Should().BeFalse();
    }
    
    // === Helper ===
    
    private static MonitorSpec CreateTestSpec(string name) => new()
    {
        Id = Guid.NewGuid(),
        Name = name,
        SystemPrompt = "Test system prompt",
        State = MonitorState.Active,
        CreatedAt = DateTimeOffset.UtcNow
    };
}

using FluentAssertions;
using Kds.Ai.AnomalyDetector.Agents;
using Kds.Ai.AnomalyDetector.Tests.Fakes;
using Kds.Ai.Data.Entities;
using Kds.Ai.Data.Enums;
using Microsoft.Extensions.Logging.Abstractions;
using Xunit;

namespace Kds.Ai.AnomalyDetector.Tests.UnitTests;

/// <summary>
/// Tests for the AnomalyDetectorAgent using FakeChatClient and FakeMcpToolProvider.
/// These exercise the agent's tool-calling loop without real LLM or MCP calls.
/// </summary>
public sealed class AgentDetectionTests
{
    [Fact]
    public async Task RunDetection_NoAnomaly_ReturnsNoAnomalyResult()
    {
        // Arrange
        var (tools, chat) = ScriptedAgentScenarios.NoAnomaly();
        var agent = CreateAgent(chat, tools);
        var spec = CreateTestSpec("No Anomaly Monitor");
        
        // Act
        var result = await agent.RunDetectionAsync(spec, DateTimeOffset.UtcNow);
        
        // Assert
        result.AnomalyDetected.Should().BeFalse();
        result.Findings.Should().BeEmpty();
    }
    
    [Fact]
    public async Task RunDetection_SingleAnomaly_ReturnsFindings()
    {
        // Arrange
        var (tools, chat) = ScriptedAgentScenarios.SingleAnomaly(EventSeverity.High);
        var agent = CreateAgent(chat, tools);
        var spec = CreateTestSpec("Anomaly Monitor");
        
        // Act
        var result = await agent.RunDetectionAsync(spec, DateTimeOffset.UtcNow);
        
        // Assert
        result.AnomalyDetected.Should().BeTrue();
        result.Severity.Should().Be(EventSeverity.High);
        result.Summary.Should().NotBeNullOrEmpty();
        result.Findings.Should().NotBeEmpty();
        result.Findings[0].AffectedPeriod.Should().Contain("12:00");
        result.Findings[0].Evidence.Should().NotBeNullOrEmpty();
    }
    
    [Fact]
    public async Task RunDetection_DataError_HandlesGracefully()
    {
        // Arrange
        var (tools, chat) = ScriptedAgentScenarios.DataError();
        var agent = CreateAgent(chat, tools);
        var spec = CreateTestSpec("Error Monitor");
        
        // Act & Assert
        // The agent should either return a Failed result or throw,
        // depending on implementation. Either is acceptable.
        var act = async () => await agent.RunDetectionAsync(spec, DateTimeOffset.UtcNow);
        
        // DataError scenario throws during MCP tool execution,
        // so agent should handle it or let it propagate
        await act.Should().ThrowAsync<Exception>();
    }
    
    [Fact]
    public async Task RunDetection_UsesSpecSystemPrompt()
    {
        // Arrange - custom tools that record the query
        var tools = new FakeMcpToolProvider()
            .OnQuery("SELECT", "[]");
        
        var chat = new FakeChatClient()
            .EnqueueFunctionCall("emit_conclusion", """
            {
                "anomalyDetected": false,
                "summary": "No data found",
                "findings": []
            }
            """);
        
        var agent = CreateAgent(chat, tools);
        var spec = CreateTestSpec("Custom Prompt Monitor");
        spec.SystemPrompt = "You are a special-purpose analyzer. Always check the widgets table.";
        
        // Act
        var result = await agent.RunDetectionAsync(spec, DateTimeOffset.UtcNow);
        
        // Assert - the agent processed without error using the custom prompt
        result.Should().NotBeNull();
        result.AnomalyDetected.Should().BeFalse();
    }
    
    // === Helpers ===
    
    private static IAnomalyDetectorAgent CreateAgent(
        FakeChatClient chat,
        FakeMcpToolProvider tools)
    {
        return new AnomalyDetectorAgent(
            chat,
            tools,
            NullLogger<AnomalyDetectorAgent>.Instance);
    }
    
    private static MonitorSpec CreateTestSpec(string name) => new()
    {
        Id = Guid.NewGuid(),
        Name = name,
        SystemPrompt = "Analyze data and detect anomalies. Use mysql_query tool to access data.",
        State = MonitorState.Active,
        CreatedAt = DateTimeOffset.UtcNow
    };
}

using FluentAssertions;
using Kds.Ai.AnomalyDetector.Seeding;
using Kds.Ai.Data;
using Kds.Ai.Data.Enums;
using Kds.Ai.Data.Repositories;
using Kds.Ai.Data.Seeding;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Xunit;

namespace Kds.Ai.AnomalyDetector.Tests.UnitTests;

public sealed class MonitorSpecSeederTests : IAsyncLifetime
{
    private KdsAiDbContext _dbContext = null!;
    private MonitorSpecSeeder _seeder = null!;
    
    public async Task InitializeAsync()
    {
        var options = new DbContextOptionsBuilder<KdsAiDbContext>()
            .UseInMemoryDatabase($"SeederTest_{Guid.NewGuid()}")
            .Options;
        
        _dbContext = new KdsAiDbContext(options);
        var repo = new EfMonitorSpecRepository(_dbContext, NullLogger<EfMonitorSpecRepository>.Instance);
        _seeder = new MonitorSpecSeeder(repo, NullLogger<MonitorSpecSeeder>.Instance);
        
        await _dbContext.Database.EnsureCreatedAsync();
    }
    
    public async Task DisposeAsync()
    {
        await _dbContext.DisposeAsync();
    }
    
    [Fact]
    public async Task EnsureAsync_CreatesNewMonitor()
    {
        // Act
        var spec = await _seeder.EnsureAsync("Test Monitor", "Test prompt");
        
        // Assert
        spec.Id.Should().NotBe(Guid.Empty);
        spec.Name.Should().Be("Test Monitor");
        spec.SystemPrompt.Should().Be("Test prompt");
        spec.State.Should().Be(MonitorState.Draft); // Default state
    }
    
    [Fact]
    public async Task EnsureAsync_ReturnsExistingByName()
    {
        // Arrange
        var first = await _seeder.EnsureAsync("Duplicate Test", "First prompt");
        
        // Act
        var second = await _seeder.EnsureAsync("Duplicate Test", "Different prompt");
        
        // Assert
        second.Id.Should().Be(first.Id);
        second.SystemPrompt.Should().Be("First prompt"); // Original preserved
    }
    
    [Fact]
    public async Task EnsureAsync_RespectsInitialState()
    {
        // Act
        var spec = await _seeder.EnsureAsync(
            "Active Monitor", 
            "Test prompt",
            initialState: MonitorState.Active);
        
        // Assert
        spec.State.Should().Be(MonitorState.Active);
    }
    
    [Fact]
    public async Task EnsureAsync_ExamplePromptIsValid()
    {
        // Act
        var spec = await _seeder.EnsureAsync(
            "Prep Time Example",
            ExamplePrompts.PrepTimeAnomaly);
        
        // Assert
        spec.SystemPrompt.Should().Contain("mysql_query");
        spec.SystemPrompt.Should().Contain("preparation_time");
        spec.SystemPrompt.Should().Contain("emit_conclusion");
    }
}

# Run all tests
dotnet test backend/Kds.Ai.AnomalyDetector.Tests

# Run with verbose output
dotnet test backend/Kds.Ai.AnomalyDetector.Tests --logger "console;verbosity=detailed"

# Run specific test class
dotnet test backend/Kds.Ai.AnomalyDetector.Tests --filter "FullyQualifiedName~OrchestratorIntegrationTests"

# Run unit tests only
dotnet test backend/Kds.Ai.AnomalyDetector.Tests --filter "FullyQualifiedName~UnitTests"