namespace Geekeey.Extensions.Process.Tests;

[TestFixture]
internal sealed class CommandTests
{
	[Test]
	public void New_Command_Defaults()
	{
		var cmd = new Command("foo");

		Assert.Multiple(() =>
		{
			Assert.That(cmd.TargetFilePath, Is.EqualTo("foo"));
			Assert.That(cmd.Arguments, Is.Empty);
			Assert.That(cmd.WorkingDirPath, Is.EqualTo(Directory.GetCurrentDirectory()));
			Assert.That(cmd.EnvironmentVariables, Is.Empty);
			Assert.That(cmd.Validation, Is.EqualTo(CommandExitBehaviour.ZeroExitCode));
			Assert.That(cmd.StandardInputPipe, Is.EqualTo(PipeSource.Null));
			Assert.That(cmd.StandardOutputPipe, Is.EqualTo(PipeTarget.Null));
			Assert.That(cmd.StandardErrorPipe, Is.EqualTo(PipeTarget.Null));
		});
	}

	[Test]
	public void New_Command_WithTargetFile()
	{
		var cmd = new Command("foo");
		var modified = cmd.WithTargetFile("bar");

		Assert.Multiple(() =>
		{
			Assert.That(modified.TargetFilePath, Is.EqualTo("bar"));
			Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
			Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
			Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
			Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
			Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
			Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
			Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));

			Assert.That(cmd.TargetFilePath, Is.Not.EqualTo("bar"));
		});
	}

	[Test]
	public void New_Command_WithArguments()
	{
		var cmd = new Command("foo").WithArguments("xxx");
		var modified = cmd.WithArguments("abc def");

		Assert.Multiple(() =>
		{
			Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
			Assert.That(modified.Arguments, Is.EqualTo("abc def"));
			Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
			Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
			Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
			Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
			Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
			Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));

			Assert.That(cmd.Arguments, Is.Not.EqualTo("abc def"));
		});
	}

	[Test]
	public void New_Command_WithArguments_Array()
	{
		var cmd = new Command("foo").WithArguments("xxx");
		var modified = cmd.WithArguments(["abc", "def"]);

		Assert.Multiple(() =>
		{
			Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
			Assert.That(modified.Arguments, Is.EqualTo("abc def"));
			Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
			Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
			Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
			Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
			Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
			Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));

			Assert.That(cmd.Arguments, Is.Not.EqualTo("abc def"));
		});
	}

	[Test]
	public void New_Command_WithArguments_Builder()
	{
		var cmd = new Command("foo").WithArguments("xxx");
		var modified = cmd.WithArguments(args => args
			.Add("-a")
			.Add("foo bar")
			.Add("\"foo\\\\bar\"")
			.Add(3.14)
			.Add(["foo", "bar"])
			.Add([-10, 12.12]));

		Assert.Multiple(() =>
		{
			Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
			Assert.That(modified.Arguments, Is.EqualTo("-a \"foo bar\" \"\\\"foo\\\\bar\\\"\" 3.14 foo bar -10 12.12"));
			Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
			Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
			Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
			Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
			Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
			Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));

			Assert.That(cmd.Arguments, Is.Not.EqualTo("-a \"foo bar\" \"\\\"foo\\\\bar\\\"\" 3.14 foo bar -10 12.12"));
		});
	}

	[Test]
	public void New_Command_WithWorkingDirectory()
	{
		var cmd = new Command("foo").WithWorkingDirectory("xxx");
		var modified = cmd.WithWorkingDirectory("new");

		Assert.Multiple(() =>
		{
			Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
			Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
			Assert.That(modified.WorkingDirPath, Is.EqualTo("new"));
			Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
			Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
			Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
			Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
			Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));

			Assert.That(cmd.WorkingDirPath, Is.Not.EqualTo("new"));
		});
	}

	[Test]
	public void New_Command_WithEnvironmentVariables()
	{
		var cmd = new Command("foo").WithEnvironmentVariables(e => e.Set("xxx", "xxx"));
		var vars = new Dictionary<string, string?> { ["name"] = "value", ["key"] = "door" };
		var modified = cmd.WithEnvironmentVariables(vars);

		Assert.Multiple(() =>
		{
			Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
			Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
			Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
			Assert.That(modified.EnvironmentVariables, Is.EqualTo(vars));
			Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
			Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
			Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
			Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));

			Assert.That(cmd.EnvironmentVariables, Is.Not.EqualTo(vars));
		});
	}

	[Test]
	public void New_Command_WithEnvironmentVariables_Builder()
	{
		var cmd = new Command("foo").WithEnvironmentVariables(e => e.Set("xxx", "xxx"));
		var modified = cmd.WithEnvironmentVariables(env => env
			.Set("name", "value")
			.Set("key", "door")
			.Set(new Dictionary<string, string?> { ["zzz"] = "yyy", ["aaa"] = "bbb" }));

		Assert.Multiple(() =>
		{
			var vars = new Dictionary<string, string?>
			{
				["name"] = "value", ["key"] = "door", ["zzz"] = "yyy", ["aaa"] = "bbb"
			};
			Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
			Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
			Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
			Assert.That(modified.EnvironmentVariables, Is.EqualTo(vars));
			Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
			Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
			Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
			Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));

			Assert.That(cmd.EnvironmentVariables, Is.Not.EqualTo(vars));
		});
	}

	[Test]
	public void New_Command_WithValidation()
	{
		var cmd = new Command("foo").WithValidation(CommandExitBehaviour.ZeroExitCode);
		var modified = cmd.WithValidation(CommandExitBehaviour.None);

		Assert.Multiple(() =>
		{
			Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
			Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
			Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
			Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
			Assert.That(modified.Validation, Is.EqualTo(CommandExitBehaviour.None));
			Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
			Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
			Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));

			Assert.That(cmd.Validation, Is.Not.EqualTo(CommandExitBehaviour.None));
		});
	}

	[Test]
	public void New_Command_WithStandardInputPipe()
	{
		var cmd = new Command("foo").WithStandardInputPipe(PipeSource.Null);
		var pipeSource = PipeSource.FromStream(Stream.Null);
		var modified = cmd.WithStandardInputPipe(pipeSource);

		Assert.Multiple(() =>
		{
			Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
			Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
			Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
			Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
			Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
			Assert.That(modified.StandardInputPipe, Is.EqualTo(pipeSource));
			Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
			Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));

			Assert.That(cmd.StandardInputPipe, Is.Not.EqualTo(pipeSource));
		});
	}

	[Test]
	public void New_Command_WithStandardOutputPipe()
	{
		var cmd = new Command("foo").WithStandardOutputPipe(PipeTarget.Null);
		var pipeTarget = PipeTarget.ToStream(Stream.Null);
		var modified = cmd.WithStandardOutputPipe(pipeTarget);

		Assert.Multiple(() =>
		{
			Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
			Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
			Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
			Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
			Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
			Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
			Assert.That(modified.StandardOutputPipe, Is.EqualTo(pipeTarget));
			Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));

			Assert.That(cmd.StandardOutputPipe, Is.Not.EqualTo(pipeTarget));
		});
	}

	[Test]
	public void New_Command_WithStandardErrorPipe()
	{
		var cmd = new Command("foo").WithStandardErrorPipe(PipeTarget.Null);
		var pipeTarget = PipeTarget.ToStream(Stream.Null);
		var modified = cmd.WithStandardErrorPipe(pipeTarget);

		Assert.Multiple(() =>
		{
			Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
			Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
			Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
			Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
			Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
			Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
			Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
			Assert.That(modified.StandardErrorPipe, Is.EqualTo(pipeTarget));

			Assert.That(cmd.StandardErrorPipe, Is.Not.EqualTo(pipeTarget));
		});
	}
}