using System.Diagnostics.CodeAnalysis;

namespace NubLang;

public static class Optional
{
    public static Optional<TValue> Empty<TValue>() => new();

    /// <summary>
    /// Alias for creating an Optional which allows for implicit types
    /// </summary>
    public static Optional<TValue> OfNullable<TValue>(TValue? value)
    {
        return value ?? Optional<TValue>.Empty();
    }

    /// <summary>
    /// Converts a nullable type to an Optional
    /// </summary>
    public static Optional<TValue> ToOptional<TValue>(this TValue? value)
    {
        return OfNullable(value);
    }
}

public readonly struct Optional<TValue>
{
    public static Optional<TValue> Empty() => new();

    public static Optional<TValue> OfNullable(TValue? value)
    {
        return value ?? Empty();
    }

    public Optional()
    {
        Value = default;
        HasValue = false;
    }

    public Optional(TValue value)
    {
        Value = value;
        HasValue = true;
    }

    public TValue? Value { get; }

    [MemberNotNullWhen(true, nameof(Value))]
    public bool HasValue { get; }


    [MemberNotNullWhen(true, nameof(Value))]
    public bool TryGetValue([NotNullWhen(true)] out TValue? value)
    {
        if (HasValue)
        {
            value = Value;
            return true;
        }

        value = default;
        return false;
    }

    public TValue GetValue()
    {
        return Value ?? throw new InvalidOperationException("Value is not set");
    }

    public static implicit operator Optional<TValue>(TValue value) => new(value);

    public TValue Or(TValue other)
    {
        if (HasValue)
        {
            return Value;
        }

        return other;
    }
}