// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using Aspire.Cli.Configuration;
using Aspire.Cli.Tests.Utils;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging.Abstractions;
 
namespace Aspire.Cli.Tests.Configuration;
 
public class ConfigurationServiceTests(ITestOutputHelper outputHelper)
{
    private static (ConfigurationService Service, string SettingsFilePath) CreateService(
        TemporaryWorkspace workspace,
        string? existingContent = null)
    {
        var globalSettingsDir = workspace.CreateDirectory(".aspire-global");
        var globalSettingsFile = new FileInfo(Path.Combine(globalSettingsDir.FullName, AspireConfigFile.FileName));
 
        var settingsFilePath = Path.Combine(workspace.WorkspaceRoot.FullName, AspireConfigFile.FileName);
        if (existingContent is not null)
        {
            File.WriteAllText(settingsFilePath, existingContent);
        }
 
        var logsDir = new DirectoryInfo(Path.Combine(workspace.WorkspaceRoot.FullName, "logs"));
        var executionContext = new CliExecutionContext(
            workspace.WorkspaceRoot,
            new DirectoryInfo(Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire", "hives")),
            new DirectoryInfo(Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire", "cache")),
            new DirectoryInfo(Path.Combine(Path.GetTempPath(), "aspire-test-runtimes")),
            logsDir,
            "test.log");
 
        var configBuilder = new ConfigurationBuilder();
        var configuration = configBuilder.Build();
 
        var logger = NullLogger<ConfigurationService>.Instance;
        var service = new ConfigurationService(configuration, executionContext, globalSettingsFile, logger);
 
        return (service, settingsFilePath);
    }
 
    [Fact]
    public async Task SetConfigurationAsync_WorksWithJsonComments()
    {
        using var workspace = TemporaryWorkspace.Create(outputHelper);
 
        var contentWithComments = """
            {
              // This is a comment about the apphost
              "appHost": {
                "path": "MyApp.csproj" // path to the project
              }
            }
            """;
 
        var (service, settingsFilePath) = CreateService(workspace, contentWithComments);
 
        await service.SetConfigurationAsync("channel", "daily", isGlobal: false);
 
        var result = File.ReadAllText(settingsFilePath);
        Assert.Contains("daily", result);
        Assert.Contains("appHost", result);
    }
 
    [Fact]
    public async Task SetConfigurationAsync_WorksWithTrailingCommas()
    {
        using var workspace = TemporaryWorkspace.Create(outputHelper);
 
        var contentWithTrailingCommas = """
            {
              "appHost": {
                "path": "MyApp.csproj",
              },
              "channel": "stable",
            }
            """;
 
        var (service, settingsFilePath) = CreateService(workspace, contentWithTrailingCommas);
 
        await service.SetConfigurationAsync("features.polyglotSupportEnabled", "true", isGlobal: false);
 
        var result = File.ReadAllText(settingsFilePath);
        Assert.Contains("polyglotSupportEnabled", result);
    }
 
    [Fact]
    public async Task SetConfigurationAsync_WorksWithCommentsAndTrailingCommas()
    {
        using var workspace = TemporaryWorkspace.Create(outputHelper);
 
        var content = """
            {
              // Comment
              "appHost": {
                "path": "MyApp.csproj", // trailing comma
              },
            }
            """;
 
        var (service, settingsFilePath) = CreateService(workspace, content);
 
        await service.SetConfigurationAsync("channel", "daily", isGlobal: false);
 
        var result = File.ReadAllText(settingsFilePath);
        Assert.Contains("daily", result);
    }
 
    [Fact]
    public async Task SetConfigurationAsync_CreatesNewFile_WhenNoneExists()
    {
        using var workspace = TemporaryWorkspace.Create(outputHelper);
 
        // Delete the sentinel .aspire/settings.json so there is truly no settings file
        var sentinelPath = Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire", "settings.json");
        if (File.Exists(sentinelPath))
        {
            File.Delete(sentinelPath);
        }
 
        var (service, settingsFilePath) = CreateService(workspace);
 
        await service.SetConfigurationAsync("channel", "staging", isGlobal: false);
 
        Assert.True(File.Exists(settingsFilePath));
        var result = File.ReadAllText(settingsFilePath);
        Assert.Contains("staging", result);
    }
 
    [Fact]
    public async Task SetConfigurationAsync_HandlesEmptyFile()
    {
        using var workspace = TemporaryWorkspace.Create(outputHelper);
 
        var (service, settingsFilePath) = CreateService(workspace, "");
 
        await service.SetConfigurationAsync("channel", "daily", isGlobal: false);
 
        var result = File.ReadAllText(settingsFilePath);
        Assert.Contains("daily", result);
    }
 
    [Fact]
    public async Task DeleteConfigurationAsync_WorksWithJsonComments()
    {
        using var workspace = TemporaryWorkspace.Create(outputHelper);
 
        var contentWithComments = """
            {
              // Comment
              "channel": "daily",
              "appHost": { "path": "MyApp.csproj" }
            }
            """;
 
        var (service, settingsFilePath) = CreateService(workspace, contentWithComments);
 
        var deleted = await service.DeleteConfigurationAsync("channel", isGlobal: false);
 
        Assert.True(deleted);
        var result = File.ReadAllText(settingsFilePath);
        Assert.DoesNotContain("daily", result);
        Assert.Contains("appHost", result);
    }
 
    [Fact]
    public async Task DeleteConfigurationAsync_ReturnsFalse_WhenFileDoesNotExist()
    {
        using var workspace = TemporaryWorkspace.Create(outputHelper);
 
        var (service, _) = CreateService(workspace);
 
        var deleted = await service.DeleteConfigurationAsync("channel", isGlobal: false);
 
        Assert.False(deleted);
    }
 
    [Fact]
    public async Task DeleteConfigurationAsync_ReturnsFalse_WhenFileIsEmpty()
    {
        using var workspace = TemporaryWorkspace.Create(outputHelper);
 
        var (service, _) = CreateService(workspace, "");
 
        var deleted = await service.DeleteConfigurationAsync("channel", isGlobal: false);
 
        Assert.False(deleted);
    }
 
    [Fact]
    public async Task GetAllConfigurationAsync_ParsesCommentsCorrectly()
    {
        using var workspace = TemporaryWorkspace.Create(outputHelper);
 
        var contentWithComments = """
            {
              // This config has comments
              "channel": "daily",
              "features": {
                "polyglotSupportEnabled": true // enabled for testing
              }
            }
            """;
 
        var (service, _) = CreateService(workspace, contentWithComments);
 
        var config = await service.GetAllConfigurationAsync();
 
        Assert.Contains("channel", config.Keys);
        Assert.Equal("daily", config["channel"]);
    }
 
    [Fact]
    public async Task SetConfigurationAsync_SetsNestedValues()
    {
        using var workspace = TemporaryWorkspace.Create(outputHelper);
 
        var (service, settingsFilePath) = CreateService(workspace, "{}");
 
        await service.SetConfigurationAsync("appHost.path", "MyApp/MyApp.csproj", isGlobal: false);
 
        var result = File.ReadAllText(settingsFilePath);
        Assert.Contains("appHost", result);
        Assert.Contains("MyApp/MyApp.csproj", result);
    }
}