using System.Diagnostics;

namespace VoiceCat.Tests;

public class PublishServerScriptTests
{
    [Theory]
    [InlineData("clients/windows/publish-client.ps1")]
    [InlineData("scripts/publish-server.ps1")]
    public async Task PublishUsesRegeneratedIntermediateRuntimeLock(string relativePath)
    {
        string script = await File.ReadAllTextAsync(Path.Combine(FindRoot(), relativePath.Replace('/', Path.DirectorySeparatorChar)));

        Assert.Contains("NuGetLockFilePath=obj/packages.publish.", script);
        Assert.Contains("RestoreLockedMode=false", script);
        Assert.DoesNotContain("NuGetLockFilePath=packages.publish.", script);
    }

    [Fact]
    public async Task LicenseAuditIgnoresGeneratedBuildLocks()
    {
        string script = await File.ReadAllTextAsync(Path.Combine(FindRoot(), "scripts", "check-licenses.ps1"));

        Assert.Contains("(?:bin|obj)", script);
    }

    [Fact]
    public async Task MacPublishPreservesAppEntitlementsAndReplacesBrokenWorkloadBundle()
    {
        string root = FindRoot();
        string script = await File.ReadAllTextAsync(Path.Combine(root, "clients", "apple", "publish-macos.sh"));
        string entitlements = await File.ReadAllTextAsync(Path.Combine(
            root, "clients", "apple", "VoiceCat.Mac", "VoiceCat.Mac.entitlements"));

        Assert.Contains("sign_nested_code", script);
        Assert.Contains("--entitlements \"$entitlements\"", script);
        Assert.Contains("install_verified_primary_bundle", script);
        Assert.DoesNotContain("codesign --force --deep", script);
        Assert.Contains("com.apple.security.cs.allow-jit", entitlements);
    }

    [Fact]
    public async Task IosDeviceBuildUsesAnIntermediateDeviceLockAndScopesKnownTrimWarnings()
    {
        string root = FindRoot();
        string script = await File.ReadAllTextAsync(Path.Combine(root, "clients", "apple", "build-ios-device.sh"));
        string project = await File.ReadAllTextAsync(Path.Combine(
            root, "clients", "apple", "VoiceCat.iOS", "VoiceCat.iOS.csproj"));

        Assert.Contains("NuGetLockFilePath=\"$device_lock\"", script);
        Assert.Contains("RestoreLockedMode=false", script);
        Assert.Contains("<WarningsNotAsErrors>$(WarningsNotAsErrors);IL2104</WarningsNotAsErrors>", project);
        Assert.DoesNotContain("<TreatWarningsAsErrors>false</TreatWarningsAsErrors>", project);
    }

    [Fact]
    public async Task IosBroadcastExtensionPreservesSharedAppGroupAndSupportsDistributionSigning()
    {
        string root = FindRoot();
        string entitlements = await File.ReadAllTextAsync(Path.Combine(
            root, "native", "apple", "broadcast", "VoiceCatBroadcast.entitlements"));
        string script = await File.ReadAllTextAsync(Path.Combine(
            root, "clients", "apple", "VoiceCat.iOS", "build-broadcast-extension.sh"));

        Assert.Contains("com.apple.security.application-groups", entitlements);
        Assert.Contains("group.me.iamtalon.voicecat", entitlements);
        Assert.Contains("CODE_SIGN_STYLE=Manual", script);
        Assert.Contains("PROVISIONING_PROFILE_SPECIFIER=\"$VOICECAT_BROADCAST_CODESIGN_PROVISION\"", script);
        Assert.Contains("CURRENT_PROJECT_VERSION=\"$VOICECAT_BUILD_NUMBER\"", script);
        Assert.Contains("MARKETING_VERSION=\"${VOICECAT_DISPLAY_VERSION:-0.0.1}\"", script);

        string deviceScript = await File.ReadAllTextAsync(Path.Combine(
            root, "clients", "apple", "build-ios-device.sh"));
        Assert.Contains("-p:ApplicationVersion=\"$VOICECAT_BUILD_NUMBER\"", deviceScript);

        string appManifest = await File.ReadAllTextAsync(Path.Combine(
            root, "clients", "apple", "VoiceCat.iOS", "Info.plist"));
        string extensionManifest = await File.ReadAllTextAsync(Path.Combine(
            root, "native", "apple", "broadcast", "Info.plist"));
        Assert.DoesNotContain("<key>CFBundleVersion</key>", appManifest);
        Assert.Contains("<string>$(CURRENT_PROJECT_VERSION)</string>", extensionManifest);
    }

    [Fact]
    public async Task DefaultPublishTargetsWindowsAndLinuxWhileRuntimeCanSelectOne()
    {
        string script = Path.Combine(FindRoot(), "scripts", "publish-server.ps1");

        string allTargets = await RunWhatIf(script);
        Assert.Contains("win-x64", allTargets);
        Assert.Contains("linux-x64", allTargets);

        string linuxOnly = await RunWhatIf(script, "-Runtime", "linux-x64");
        Assert.Contains("linux-x64", linuxOnly);
        Assert.DoesNotContain("win-x64", linuxOnly);
    }

    private static async Task<string> RunWhatIf(string script, params string[] arguments)
    {
        string powerShell = OperatingSystem.IsWindows() ? "powershell.exe" : "pwsh";
        var start = new ProcessStartInfo(powerShell)
        {
            UseShellExecute = false,
            CreateNoWindow = true,
            RedirectStandardOutput = true,
            RedirectStandardError = true,
        };
        foreach (string argument in new[] { "-NoProfile", "-NonInteractive", "-File", script, "-WhatIf" }.Concat(arguments))
            start.ArgumentList.Add(argument);

        using Process process = Process.Start(start) ?? throw new InvalidOperationException("Could not start PowerShell.");
        Task<string> stdout = process.StandardOutput.ReadToEndAsync();
        Task<string> stderr = process.StandardError.ReadToEndAsync();
        await process.WaitForExitAsync();
        string output = await stdout + await stderr;
        Assert.True(process.ExitCode == 0, output);
        return output;
    }

    private static string FindRoot()
    {
        DirectoryInfo? directory = new(AppContext.BaseDirectory);
        while (directory is not null && !File.Exists(Path.Combine(directory.FullName, "VoiceCat.slnx")))
            directory = directory.Parent;
        return directory?.FullName ?? throw new DirectoryNotFoundException("Repository root not found.");
    }
}