namespace Geekeey.Extensions.Result.Tests;

[TestFixture]
internal sealed class ResultMatchingTests
{
	[Test]
	public void I_can_match_and_it_calls_success_func_for_success()
	{
		var result = Success(2);
		var match = result.Match(
			v => v,
			_ => throw new InvalidOperationException());

		Assert.That(match, Is.EqualTo(2));
	}

	[Test]
	public void I_can_match_and_it_calls_failure_func_for_failure()
	{
		var result = Failure<int>("error");
		var match = result.Match(
			_ => throw new InvalidOperationException(),
			e => e);

		Assert.That(match.Message, Is.EqualTo("error"));
	}

	[Test]
	public void I_can_switch_and_it_calls_success_action_for_success()
	{
		var called = false;

		var result = Success(2);
		result.Switch(
			v =>
			{
				Assert.That(v, Is.EqualTo(2));
				called = true;
			},
			_ => throw new InvalidOperationException()
		);

		Assert.That(called, Is.True);
	}

	[Test]
	public void I_can_switch_and_it_calls_failure_action_for_failure()
	{
		var called = false;

		var result = Failure<int>("error");
		result.Switch(
			_ => throw new InvalidOperationException(),
			e =>
			{
				called = true;
				Assert.That(e.Message, Is.EqualTo("error"));
			}
		);

		Assert.That(called, Is.True);
	}

	[Test]
	public async Task I_can_match_async_and_it_calls_success_func_for_success()
	{
		var result = Success(2);
		var match = await result.MatchAsync(
			Task.FromResult,
			_ => throw new InvalidOperationException());

		Assert.That(match, Is.EqualTo(2));
	}

	[Test]
	public async Task I_can_match_async_and_it_calls_failure_func_for_failure()
	{
		var result = Failure<int>("error");
		var match = await result.MatchAsync(
			_ => throw new InvalidOperationException(),
			Task.FromResult);

		Assert.That(match.Message, Is.EqualTo("error"));
	}

	[Test]
	public async Task I_can_switch_async_and_it_calls_success_action_for_success()
	{
		var called = false;

		var result = Success(2);
		await result.SwitchAsync(
			v =>
			{
				Assert.That(v, Is.EqualTo(2));
				called = true;
				return Task.CompletedTask;
			},
			_ => throw new InvalidOperationException()
		);

		Assert.That(called, Is.True);
	}

	[Test]
	public async Task I_can_switch_async_and_it_calls_failure_action_for_failure()
	{
		var called = false;

		var result = Failure<int>("error");
		await result.SwitchAsync(
			_ => throw new InvalidOperationException(),
			e =>
			{
				called = true;
				Assert.That(e.Message, Is.EqualTo("error"));
				return Task.CompletedTask;
			}
		);

		Assert.That(called, Is.True);
	}

	[Test]
	public async Task I_can_match_and_it_calls_success_func_for_success_ValueTask()
	{
		var result = Success(2);
		var match = await result.MatchAsync(
			ValueTask.FromResult,
			_ => throw new InvalidOperationException());

		Assert.That(match, Is.EqualTo(2));
	}

	[Test]
	public async Task I_can_match_async_and_it_calls_failure_func_for_failure_ValueTask()
	{
		var result = Failure<int>("error");
		var match = await result.MatchAsync(
			_ => throw new InvalidOperationException(),
			ValueTask.FromResult);

		Assert.That(match.Message, Is.EqualTo("error"));
	}

	[Test]
	public async Task I_can_switch_async_and_it_calls_success_action_for_success_ValueTask()
	{
		var called = false;

		var result = Success(2);
		await result.SwitchAsync(
			v =>
			{
				Assert.That(v, Is.EqualTo(2));
				called = true;
				return ValueTask.CompletedTask;
			},
			_ => throw new InvalidOperationException()
		);

		Assert.That(called, Is.True);
	}

	[Test]
	public async Task I_can_switch_async_and_it_calls_failure_action_for_failure_ValueTask()
	{
		var called = false;

		var result = Failure<int>("error");
		await result.SwitchAsync(
			_ => throw new InvalidOperationException(),
			e =>
			{
				called = true;
				Assert.That(e.Message, Is.EqualTo("error"));
				return ValueTask.CompletedTask;
			}
		);

		Assert.That(called, Is.True);
	}
}