module nxt.optional;

import nxt.nullable_traits : isNullable;

private struct None {}

struct Optional(T)
{
    import core.internal.traits : Unqual;
    private Unqual!T value;

    static if (!isNullable!T)
        private bool present;

    this(T value)
    {
        opAssign(value);
    }

    this(None) {}

    void opAssign(T value)
    {
        this.value = value;
        static if (!isNullable!T)
            present = true;
    }

    void opAssign(None)
    {
        static if (isNullable!T)
            value = null;
        else
            present = false;
    }

	static if (isNullable!T)
		bool isPresent() const => value !is null;
	else
		bool isPresent() const => present;

    T get() in(isPresent) => value;

    T or(lazy T alternativeValue) => isPresent ? value : alternativeValue;

    bool empty() const @property => !isPresent;

    T front() => get;

    void popFront()
    {
        static if (isNullable!T)
            value = null;
        else
            present = false;
    }

    size_t length() const => isPresent ? 1 : 0;

    // auto ref opDispatch(string name, Args...)(auto ref Args args)
    // {
    //     import std.traits : PointerTarget, isPointer;
    //     import dlp.core.traits : hasField, TypeOfMember, getMember;

    //     static if (isPointer!T)
    //         alias StoredType = PointerTarget!T;
    //     else
    //         alias StoredType = T;

    //     static if (is(StoredType == class) || is(StoredType == struct))
    //     {
    //         static if (hasField!(StoredType, name))
    //         {
    //             alias FieldType = TypeOfMember!(StoredType, name);

    //             if (isPresent)
    //                 return optional(value.getMember!name);
    //             else
    //                 return none!FieldType;
    //         }
    //         else
    //         {
    //             alias ReturnType = typeof(__traits(getMember, value, name)(args));

    //             if (isPresent)
    //                 return optional(__traits(getMember, value, name)(args));
    //             else
    //                 return none!ReturnType;
    //         }
    //     }
    //     else
    //     {
    //         return optional(value.getMember!name);
    //     }

    //     assert(0);
    // }

    // @safe pure nothrow @nogc unittest
    // {
    //     assert(Optional!Foo(Foo(3)).a.get == 3);
    //     assert(Optional!Foo.init.a.empty);

    //     assert(Optional!Foo(Foo()).opDispatch!"c"(4).get == 4);
    //     assert(Optional!Foo.init.c(4).empty);

    //     assert(Optional!Foo(Foo(1, new Bar(5))).b.a.get == 5);
    //     assert(Optional!Foo(Foo(1)).b.a.empty);
    // }
}

@safe pure nothrow @nogc unittest
{
    enum newVale = 4;
    Optional!int a = 3;
    a = newVale;
    assert(a.get == newVale);
}

@safe pure nothrow @nogc unittest
{
    Optional!int a = 3;
    a = none;
    assert(!a.isPresent);
}

@safe pure nothrow @nogc unittest
{
    Optional!int a = 3;
    assert(a.isPresent);

    Optional!(int*) b = null;
    assert(!b.isPresent);
}

@safe pure nothrow @nogc unittest
{
    Optional!int a = 3;
    assert(a.get == 3);
}

@safe pure /*nothrow*/ unittest
{
    Optional!int a = 3;
    assert(a.or(4) == 3);

    Optional!int b = none;
    assert(b.or(4) == 4);
}

@safe pure nothrow @nogc unittest
{
    Optional!int a = 3;
    assert(!a.empty);

    Optional!int b = none;
    assert(b.empty);
}

@safe pure nothrow @nogc unittest
{
    Optional!int a = 3;
    assert(a.get == 3);
}

/** Instantiate an `Optional` `value`. */
Optional!T optional(T)(T value) => Optional!T(value);

///
@safe pure nothrow @nogc unittest
{
    Optional!int a = 3;
    a.popFront();
    assert(!a.isPresent);
}

///
@safe pure nothrow @nogc unittest
{
    Optional!int a = 3;
    assert(a.length == 1);

    Optional!int b = none;
    assert(b.length == 0);
}

///
@safe pure nothrow @nogc unittest
{
    assert(optional(3).isPresent);
}

///
@trusted pure nothrow @nogc unittest
{
    int i;
    assert(optional(&i).isPresent);
    assert(!optional!(int*)(null).isPresent);
}

///
@safe pure nothrow @nogc unittest
{
    import std.algorithm : map;
    enum value = 3;
    assert(optional(value).map!(e => e).front == value);
}

Optional!T some(T)(T value)
in
{
    static if (isNullable!T)
        assert(value !is null);
}
do
{
    Optional!T o;
    o.value = value;
    o.present = true;

    return o;
}

///
@safe pure nothrow @nogc unittest
{
    assert(some(3).isPresent);
}

@safe pure nothrow @nogc None none()
{
    return None();
}

Optional!T none(T)() => Optional!T.init;

///
@safe pure nothrow @nogc unittest
{
    assert(!none!int.isPresent);
}

version (unittest)
{
    // Cannot put this inside the @safe pure nothrow @nogc unittest block due to
    // https://issues.dlang.org/show_bug.cgi?id=19157
    private struct Foo
    {
        int a;
        Bar* b;
        int c(int a) => a;
        Bar d(int a) => Bar(a);
    }

    private struct Bar
    {
        int a;
        int foo(int a) => a;
    }
}