using System;

namespace ScreenConnect;

public struct Result<TResult, TError>(Union<TResult, TError> union)
{
	private Union<TResult, TError> inner = union;

	public static implicit operator Result<TResult, TError>(Union<TResult, TError> union)
	{
		return new Result<TResult, TError>(union);
	}

	public static implicit operator Result<TResult, TError>(TResult result)
	{
		return new Result<TResult, TError>(result);
	}

	public static implicit operator Result<TResult, TError>(TError error)
	{
		return new Result<TResult, TError>(error);
	}

	public bool TryGetValue(out TResult result)
	{
		return inner.IsFirst(out result);
	}

	public bool TryGetError(out TError error)
	{
		return inner.IsSecond(out error);
	}

	public bool Deconstruct(out TResult result, out TError error)
	{
		error = inner.Second;
		return inner.IsFirst(out result);
	}

	public bool IsOk()
	{
		TResult value;
		return inner.IsFirst(out value);
	}

	public bool IsError()
	{
		TError value;
		return inner.IsSecond(out value);
	}

	public Result<T, TError> Map<T>(Func<TResult, T> func)
	{
		return inner.MatchFirst(func);
	}

	public T MapOr<T>(T defaultValue, Func<TResult, T> resultFunc)
	{
		return inner.Match(resultFunc, (TError _) => defaultValue);
	}

	public T MapOrElse<T>(Func<TError, T> defaultFunc, Func<TResult, T> resultFunc)
	{
		return inner.Match(resultFunc, defaultFunc);
	}

	public Result<TResult, T> MapError<T>(Func<TError, T> func)
	{
		return inner.MatchSecond(func);
	}

	public TResult UnwrapOr(TResult defaultValue)
	{
		return MapOr(defaultValue, (TResult it) => it);
	}

	public TResult UnwrapOrElse(Func<TError, TResult> defaultFunc)
	{
		return MapOrElse(defaultFunc, (TResult it) => it);
	}

	public TError UnwrapError()
	{
		return inner.Match<TError>(delegate
		{
			throw new InvalidCastException();
		}, (TError it) => it);
	}

	public override string ToString()
	{
		return inner.Match((TResult it) => it.SafeToString(), (TError it) => it.SafeToString());
	}
}