/** User-friendly dump.
 *
 * See_Also: https://github.com/dlang/phobos/pull/4318
 */
module nxt.dump;

import std.exception : enforce;
import std.traits : isCallable, ReturnType;
import std.range.primitives : isOutputRange, empty, put;
import std.format : formatValue, FormatSpec, FormatException;

private alias enforceFmt = enforce!FormatException;

/**
   Pretty-print variables with name and values.
   It can print will print all compile-time and runtime arguments.
   The first runtime argument can be a custom OutputRange. The following argument can
   be a custom format can be given in the $(LREF format) Syntax, where the first
   value is the name of the variable (or number for runtime arguments), the second
   it's value and the third it's type. Positional specifier can be used too.
   If no OutputRange is given, a `string` will be returned.
   Callable objects will be evaluated.
   Params:
   T = names of the variables to print
   w = The $(D OutputRange) to write to.
   fmt = The format of the data to read.
   xs = runtime arguments to print
   Returns:
   `void` if an output range was provided as first runtime argument and a `string`
   otherwise.
*/
template dump(T...)
{
    // formats compile-time parameters
    private void dumpCT(Writer, Char)(Writer w, in Char[] fmt, bool printLastSeparator)
    if (isOutputRange!(Writer, string))
    {
        alias FPfmt = void delegate(Writer wr) @safe;
        enum maxLength = 3;

        foreach (k, el; T)
        {
            auto spec = FormatSpec!Char(fmt);

            // we expose three variables: name, value and typo
            FPfmt[maxLength] funs;

            // special case for lambdas/alias functions
            static if (isCallable!el)
            {
                funs[0] = (Writer wr) { formatValue(wr, "()", spec); };
                funs[1] = (Writer wr) { formatValue(wr, el(), spec); };
                funs[2] = (Writer wr) {
                    formatValue(wr, ReturnType!(typeof(el)).stringof, spec);
                };
            }
            else
            {
                funs[0] = (Writer wr) { formatValue(wr, T[k].stringof, spec); };
                funs[1] = (Writer wr) { formatValue(wr, el, spec); };
                funs[2] = (Writer wr) {
                    formatValue(wr, typeof(el).stringof, spec);
                };
            }

            applySpecToFunctions(w, spec, funs);

            // don't print the trailing bit for the last function except we have
            // runtime arguments too
            if (k < T.length - 1 || printLastSeparator)
                w.put(spec.trailing);
        }
    }

    void dump(Writer, Char, Xs...)(Writer w, in Char[] fmt, lazy Xs xs)
    if (isOutputRange!(Writer, string))
    {
        static if (T.length > 0)
            dumpCT(w, fmt, Xs.length > 0);

        static if (Xs.length > 0)
            dumpRuntime(w, fmt, xs);
    }

    // if no writer passed, return string
    string dump(Char, Xs...)(in Char[] fmt, lazy Xs xs)
    {
        import std.array : appender;

        auto w = appender!string;
        dump(w, fmt, xs);
        return w.data;
    }
}

// formats runtime parameters
private void dumpRuntime(Writer, Char, Xs...)(Writer w, in Char[] fmt, lazy Xs xs)
if (isOutputRange!(Writer, string))
{
    import std.format : formatValue, FormatSpec;

    alias FPfmt = void delegate(Writer wr) @safe;
    enum maxLength = 3;

    foreach (k, el; xs)
    {
        auto spec = FormatSpec!Char(fmt);

        // we expose three variables: name, value and typo
        FPfmt[maxLength] funs;

        static if (isCallable!el)
        {
            funs[0] = (Writer wr) { formatValue(wr, "()", spec); };
            funs[1] = (Writer wr) { formatValue(wr, el(), spec); };
            funs[2] = (Writer wr) {
                formatValue(wr, ReturnType!(typeof(el)).stringof, spec);
            };
        }
        else
        {
            funs[0] = (Writer wr) { formatValue(wr, k, spec); };
            funs[1] = (Writer wr) { formatValue(wr, el, spec); };
            funs[2] = (Writer wr) { formatValue(wr, typeof(el).stringof, spec); };
        }

        applySpecToFunctions(w, spec, funs);

        if (k < Xs.length - 1)
            w.put(spec.trailing);
    }
}

// apply given spec with given printing functions
private void applySpecToFunctions(Writer, Char, Fun)(Writer w, ref FormatSpec!Char spec, Fun funs)
{
    enum maxLength = 3;

    uint currentArg = 0;
    while (spec.writeUpToNextSpecWithoutEnd(w))
    {
        if (currentArg == funs.length && !spec.indexStart)
        {
            import std.conv : text;

            // Something went wrong here?
            enforceFmt(text("Orphan format specifier: %", spec.spec));
            break;
        }
        if (spec.indexStart > 0)
        {
            // positional parameters
            static if (maxLength > 0)
            {
                foreach (i; spec.indexStart - 1 .. spec.indexEnd)
                {
                    if (funs.length <= i)
                        break;
                    funs[i](w);
                }
            }
            if (currentArg < spec.indexEnd)
                currentArg = spec.indexEnd;
        }
        else
        {
            // parameters in given order
            funs[currentArg++](w);
        }
    }
}

// writes the non-spec parts of a format string except for the trailing end
private bool writeUpToNextSpecWithoutEnd(Char, OutputRange)(
        ref FormatSpec!Char spec, OutputRange writer)
{
    with (spec)
    {
        if (trailing.empty)
            return false;
        for (size_t i = 0; i < trailing.length; ++i)
        {
            if (trailing[i] != '%')
                continue;
            put(writer, trailing[0 .. i]);
            trailing = trailing[i .. $];
            enforceFmt(trailing.length >= 2, `Unterminated format specifier: "%"`);
            trailing = trailing[1 .. $];

            if (trailing[0] != '%')
            {
                // Spec found. Fill up the spec, and bailout
                // TODO: fillUp();
                return true;
            }
            // Doubled! Reset and Keep going
            i = 0;
        }
    }
    return false;
}

///
unittest
{
    int x = 5, y = 3;
    import std.stdio;

    assert(dump!(x, y)("%s = %s, ") == "x = 5, y = 3");

    // with order
    assert(dump!(x, y)("%2$s = %1$s, ") == "5 = x, 3 = y");

    // with runtime args
    assert(dump!(x, y)("%s = %s, ", () => 42) == "x = 5, y = 3, () = 42");

    // with runtime args & position-specifier
    assert(dump!(x, y)("%1$s = %2$s; ", "var1") == "x = 5; y = 3; 0 = var1");

    // with types
    assert(dump!(x, y)("(%s: %3$s) = %2$s, ") == "(x: int) = 5, (y: int) = 3");
    assert(dump!(x, y)("(%s!%3$s) = %2$s, ") == "(x!int) = 5, (y!int) = 3");

    // custom separator
    assert(dump!(x, y)("%s = %s; ") == "x = 5; y = 3");

    // all printf formatting works
    assert(dump!(x, y)("%-4s = %4s, ") == "x    =    5, y    =    3");

    // special formatting (if applicable for all types)
    auto z1 = 2.0, z2 = 4.0;
    assert(dump!(z1, z2)("%s = %.3f & ") == "z1 = 2.000 & z2 = 4.000");

    // functions
    assert(dump!(x, y, () => x + y)("%s = %s; ") == "x = 5; y = 3; () = 8");

    // runtime paramters
    auto b = (int a) => ++a;
    assert(dump!(x, y)("%s = %s, ", b(x), x - y) == "x = 5, y = 3, 0 = 6, 1 = 2");

    // validate laziness
    auto c = (ref int a) => ++a;
    assert(dump!(x, y, () => x + y)("%s = %s, ", c(x), x - y) == "x = 5, y = 3, () = 8, 0 = 6, 1 = 3");
    assert(dump!(x, y, () => x + y)("%s = %s, ", c(x), x - y) == "x = 6, y = 3, () = 9, 0 = 7, 1 = 4");
}

// test with output range
unittest
{
    import std.array : appender;

    auto x = 2;
    long y = 4;
    auto w = appender!string;
    dump!(x, y)(w, "%s = %s, ");
    assert(w.data == "x = 2, y = 4");

    import std.stdio : stdout;

    if (false)
        dump!(x, y)(stdout.lockingTextWriter(), "%s = %s, ");
}