using MaybeError;
using MaybeError.Errors;

namespace MaybeErrorTests;

public class ValueMaybeTests
{
	[Test]
	public void HasValue()
	{
		ValueMaybe<int> value = 1;
		if(value.HasValue)
			Assert.That(value.Value, Is.EqualTo(1));
		else
			Assert.Fail();
		Assert.That(value.Error, Is.Null);
	}

	[Test]
	public void HasError()
	{
		ValueMaybe<int> value = new InvalidOperationException();
		if (value.HasError)
			Assert.That(value.Error, Is.Not.Null);
		else
			Assert.Fail();
		Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
	}

	[Test]
	public void ImplicitValue()
	{
		ValueMaybe<int> value = 1;
		Assert.Multiple(() =>
		{
			Assert.That(value.HasValue);
			Assert.That(value == 1, Is.True);
		});
	}

	[Test]
	public void ImplicitError()
	{
		ValueMaybe<int> value = new InvalidOperationException();
		Assert.That(value.HasError);
		Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
	}

	[Test]
	public void ExplicitError()
	{
		ValueMaybe<int, ExceptionError> value = new ExceptionError(new InvalidOperationException());
		Assert.That(value.HasError);
		Assert.Throws<InvalidOperationException>(() => value.Value.ToString());
	}

	[Test]
	public void Error()
	{
		ValueMaybe<int> value = new Error("Test Error");
		Assert.Throws<Exception>(() => value.Value.ToString());
		Assert.Multiple(() =>
		{
			Assert.That(value.HasError);
			Assert.That(value.Error?.Message, Is.EqualTo("Test Error"));
		});
	}

	[Test]
	public void ValueOrDefault()
	{
		ValueMaybe<int> value = 1;
		Assert.That(value.ValueOrDefault(), Is.EqualTo(1));

		value = new InvalidOperationException();
		Assert.That(value.ValueOrDefault(), Is.Null);
	}

	[Test]
	public void ValueOrDefaultWithDefault()
	{
		ValueMaybe<int> value = 1;
		Assert.That(value.ValueOrDefault(3), Is.EqualTo(1));

		value = new InvalidOperationException();
		Assert.That(value.ValueOrDefault(3), Is.EqualTo(3));
	}

	[Test]
	public void As()
	{
		ValueMaybe<int> value = 1;
		Assert.That(value.As(v => v.ToString()), Is.EqualTo("1"));

		value = new InvalidOperationException();
		Assert.Throws<InvalidOperationException>(() => value.As(v => v.ToString()));
	}

	[Test]
	public void AsOrDefault()
	{
		ValueMaybe<int> value = 1;
		Assert.That(value.AsOrDefault(v => v.ToString()), Is.EqualTo("1"));

		value = new InvalidOperationException();
		Assert.That(value.AsOrDefault(v => v.ToString()), Is.Null);
	}

	[Test]
	public void AsOrDefaultWithValue()
	{
		ValueMaybe<int> value = 1;
		Assert.That(value.AsOrDefault(v => v.ToString(), "err"), Is.EqualTo("1"));

		value = new InvalidOperationException();
		Assert.That(value.AsOrDefault(v => v.ToString(), "err"), Is.EqualTo("err"));
	}

	[Test]
	public void MapTest()
	{
		ValueMaybe<int> value = 1;
		var valueMapped = value.Map(v => v + 1);
		Assert.That(valueMapped.HasValue, Is.True);
		Assert.That(valueMapped.Value, Is.EqualTo(2));
	}

	[Test]
	public void MapTestError()
	{
		ValueMaybe<int> value = new Error("Err");
		var valueMapped = value.Map(v => v + 1);
		Assert.That(valueMapped.HasError, Is.True);
	}


	[Test]
	public void MapErrorTest()
	{
		Maybe<int> value = 1;
		var valueMapped = value.MapError(v => new Error($"A{v}"));
		Assert.That(valueMapped.HasValue, Is.True);
		Assert.That(valueMapped.Value, Is.EqualTo(1));
	}

	[Test]
	public void MapErrorTestError()
	{
		ValueMaybe<int> value = new Error("Err");
		var valueMapped = value.MapError(v => new Error($"A{v.Message}"));
		Assert.That(valueMapped.HasError, Is.True);
		Assert.That(valueMapped.Error!.Message, Is.EqualTo("AErr"));
	}
}