module cucumber.reflection;

import cucumber.ctutils;
import cucumber.keywords;
import std.traits;
import std.typetuple;
import std.regex;
import std.conv;

import gherkin.docstring : DocString;
import gherkin.datatable : DataTable;

private template isMatchStruct(alias T)
{
    static if (__traits(compiles, typeof(T)))
    {
        enum isMatchStruct = is(typeof(T) : Match);
    }
    else
    {
        enum isMatchStruct = false;
    }
}

unittest
{
    const Match match;
    static assert(isMatchStruct!match);
}

private template hasMatchUDA(alias T)
{
    alias attrs = Filter!(isMatchStruct, __traits(getAttributes, T));
    static assert(attrs.length < 2, "Only one Match UDA per function");
    enum hasMatchUDA = attrs.length == 1;
}

private auto getRegex(alias T)()
{
    static assert(hasMatchUDA!T, "Can only get regexp from Match structure");
    return Filter!(isMatchStruct, __traits(getAttributes, T))[0].reg;
}

unittest
{
    @Match(`^foo reg`)
    void foo()
    {
        static assert(hasMatchUDA!foo);
        static assert(getRegex!foo == `^foo reg`);
    }
}

auto getLineNumber(alias T)()
{
    static assert(hasMatchUDA!T, "Can only get line number from Match structure");
    return Filter!(isMatchStruct, __traits(getAttributes, T))[0].line;
}

unittest
{
    @Match("foo", 4) void foo()
    {
    }

    static assert(getLineNumber!foo == 4);

    @Match("bar", 3) void bar()
    {
    }

    static assert(getLineNumber!bar == 3);
}

alias CucumberStepFunction = void function(in string[] = []);
alias CucumberStepFunctionWithDocString = void function(in string[] = [], DocString = DocString());
alias CucumberStepFunctionWithDataTable = void function(in string[] = [], DataTable = DataTable());

///
struct CucumberStep
{
    ///
    this(in CucumberStepFunction func, in string reg, int id, in string source)
    {
        this(func, std.regex.regex(reg), id, source);
        this.regexString = reg;
    }

    ///
    this(in CucumberStepFunctionWithDocString func, in string reg, int id, in string source)
    {
        this(func, std.regex.regex(reg), id, source);
        this.regexString = reg;
    }

    ///
    this(in CucumberStepFunctionWithDataTable func, in string reg, int id, in string source)
    {
        this(func, std.regex.regex(reg), id, source);
        this.regexString = reg;
    }

    ///
    this(T)(in T func, Regex!char reg, int id, in string source)
    {
        static if (is(T == CucumberStepFunction))
        {
            this.func = func;
        }
        else static if (is(T == CucumberStepFunctionWithDataTable))
        {
            this.funcWithDataTable = func;
        }
        else static if (is(T == CucumberStepFunctionWithDocString))
        {
            this.funcWithDocString = func;
        }
        this.regex = reg;
        this.id = id;
        this.source = source;
    }

    ///
    CucumberStepFunction func;
    ///
    CucumberStepFunctionWithDocString funcWithDocString;
    ///
    CucumberStepFunctionWithDataTable funcWithDataTable;
    ///
    Regex!char regex;
    ///
    string regexString;
    /// automatically generated id
    int id;
    ///
    string source;
}

/**
 * Finds all steps in all modules. Modules are passed in as strings.
 * Steps are found by using compile-time reflection to register
 * all functions with the Match UDA attached to it and extracting
 * the relevant regex from the Match UDA itself.
 */
auto findSteps(ModuleNames...)()
        if (allSatisfy!(isSomeString, (typeof(ModuleNames))))
{
    mixin(importModulesString!ModuleNames);
    CucumberStep[] cucumberSteps;
    int id;
    foreach (mod; ModuleNames)
    {
        foreach (member; __traits(allMembers, mixin(mod)))
        {

            enum compiles = __traits(compiles, mixin(member));

            static if (compiles)
            {

                enum isFunction = isSomeFunction!(mixin(member));
                enum hasMatch = hasMatchUDA!(mixin(member));

                static if (isFunction && hasMatch)
                {
                    enum reg = rawStringMixin(getRegex!(mixin(member)));

                    enum funcArity = arity!(mixin(member));
                    enum numCaptures = countParenPairs!reg;

                    static if (is(Unconst!(Parameters!(mixin(member))[$ - 1]) == DocString)
                            || is(Unconst!(Parameters!(mixin(member))[$ - 1]) == DataTable))
                    {
                        static assert(funcArity == numCaptures + 1, text("Arity of ", member, " (", funcArity, ")",
                                " does not match the number of capturing parens (",
                                numCaptures, " + 1) in ", getRegex!(mixin(member))));

                        static if (is(Unconst!(Parameters!(mixin(member))[$ - 1]) == DocString))
                        {
                            enum arg = "docString";
                            enum type = "DocString";
                        }
                        else static if (
                            is(Unconst!(Parameters!(mixin(member))[$ - 1]) == DataTable))
                        {
                            enum arg = "dataTable";
                            enum type = "DataTable";
                        }

                        //e.g. funcCall would be "myfunc(captures[0], captures[1], arg);"
                        enum funcCall = member ~ "(" ~ argsString!(reg, mixin(member), arg) ~ ");";

                        //e.g. lambda would be "(in string[] captures, Arg arg) { myfunc(captures[0], captures[1], docString); }"
                        enum lambda = "(in string[] captures, " ~ type ~ " "
                            ~ arg ~ ") { " ~ funcCall ~ " }";
                    }
                    else
                    {
                        static assert(funcArity == numCaptures, text("Arity of ", member, " (", funcArity, ")",
                                " does not match the number of capturing parens (",
                                numCaptures, ") in ", getRegex!(mixin(member))));

                        //e.g. funcCall would be "myfunc(captures[0], captures[1]);"
                        enum funcCall = member ~ argsStringWithParens!(reg, mixin(member)) ~ ";";

                        //e.g. lambda would be "(captures) { myfunc(captures[0]); }"
                        enum lambda = "(captures) { " ~ funcCall ~ " }";

                    }

                    //e.g. mymod.myfunc:13
                    enum source = `"` ~ mod ~ "." ~ member ~ `:` ~ getLineNumber!(mixin(member))
                            .to!string ~ `"`;

                    //e.g. cucumberSteps ~= CucumberStep((in string[] cs) { myfunc(); }, r"foobar",
                    //                                   ++id, "foo.bar:3");
                    enum mixinStr = `cucumberSteps ~= CucumberStep(` ~ lambda
                        ~ `, ` ~ reg ~ `, ++id, ` ~ source ~ `);`;

                    mixin(mixinStr);
                }
            }
        }
    }

    return cucumberSteps;
}

/**
 * Normally this struct wouldn't exist and I'd use a delegate.
 * But for the wire protocol I need access to the captures
 * array so it's a struct.
 */
struct MatchResult
{
    ///
    CucumberStepFunction func;
    ///
    CucumberStepFunctionWithDocString funcWithDocString;
    ///
    CucumberStepFunctionWithDataTable funcWithDataTable;
    ///
    const(string)[] captures;
    ///
    int id;
    ///
    string regex;
    ///
    string source;

    ///
    this(in CucumberStepFunction func, in CucumberStepFunctionWithDocString funcWithDocString,
            in CucumberStepFunctionWithDataTable funcWithDataTable,
            in string[] captures, in int id, in string regex, in string source)
    {
        this.func = func;
        this.funcWithDocString = funcWithDocString;
        this.funcWithDataTable = funcWithDataTable;
        this.captures = captures;
        this.id = id;
        this.regex = regex;
        this.source = source;
    }

    ///
    void opCall(DocString docString) const
    {
        if (funcWithDocString is null)
            throw new Exception("MatchResult with null function");
        funcWithDocString(captures, docString);
    }

    ///
    void opCall(DataTable dataTable) const
    {
        if (funcWithDataTable is null)
            throw new Exception("MatchResult with null function");
        funcWithDataTable(captures, dataTable);
    }

    ///
    void opCall() const
    {
        if (func is null)
            throw new Exception("MatchResult with null function");
        func(captures);
    }

    ///
    bool opCast(T : bool)() const
    {
        return !(func is null && funcWithDocString is null && funcWithDataTable is null);
    }
}

/**
 * Finds the match to a step string. Checks all steps and loops
 * over to see which one has a matching regex. Steps are found
 * at compile-time.
 */
MatchResult findMatch(ModuleNames...)(string step_str)
{
    step_str = stripCucumberKeywords(step_str);
    enum steps = findSteps!ModuleNames;
    foreach (step; steps)
    {
        auto m = step_str.match(step.regex);
        if (m)
        {
            import std.array : array;

            return MatchResult(step.func, step.funcWithDocString, step.funcWithDataTable,
                    m.captures.array, step.id, step.regexString, step.source);
        }
    }

    return MatchResult();
}

/**
 * Counts the number of parentheses pairs in a string known
 * at compile-time
 */
int countParenPairs(string reg)()
{
    int intCount(in string haystack, in string needle)
    {
        import std.algorithm : count;

        return cast(int) haystack.count(needle);
    }

    //no need to count matching closing parens since it won't be a valid
    //regexp and will throw an exception at runtime anyway
    return intCount(reg, "(") - intCount(reg, r"\(") - intCount(reg, r"(?:");
}

unittest
{
    static assert(countParenPairs!r"" == 0);
    static assert(countParenPairs!r"foo" == 0);
    static assert(countParenPairs!r"\(\)" == 0);
    static assert(countParenPairs!r"()" == 1);
    static assert(countParenPairs!r"()\(\)" == 1);
    static assert(countParenPairs!r"\(\)()" == 1);
    static assert(countParenPairs!r"()\(\)()" == 2);
    static assert(countParenPairs!r"(foo).+\(oh noes\).+(bar)" == 2);
    static assert(countParenPairs!r"(.+).+(?:oh noes).+" == 1);
}

/**
 * Returns an array of string mixins to convert each type
 * from a string
 */
auto conversionsFromString(Types...)()
{
    string[] convs;
    foreach (T; Types)
    {
        static if (isSomeString!T)
        {
            convs ~= "";
        }
        else
        {
            convs ~= ".to!" ~ Unqual!T.stringof;
        }
    }
    return convs;
}

unittest
{
    static assert(conversionsFromString!(int, string) == [".to!int", ""]);
    static assert(conversionsFromString!(string, double) == ["", ".to!double"]);
}

/**
 * Comma separated argument list for calls to variadic functions
 * associated with regexen. Meant to be used with mixin to
 * generate code.
 */
string argsString(string reg, alias func, string extraArg = "")()
{
    import std.string : empty;

    enum convs = conversionsFromString!(ParameterTypeTuple!func);
    enum numCaptures = countParenPairs!reg;
    static assert(convs.length == numCaptures + (extraArg.empty ? 0 : 1),
            text("Wrong length for ", convs, ", should be ", numCaptures));

    string[] args;
    foreach (i; 0 .. numCaptures)
    {
        args ~= "captures[" ~ (i + 1).to!string ~ "]" ~ convs[i];
    }
    if (!extraArg.empty)
    {
        args ~= extraArg;
    }

    import std.array : join;

    return args.join(", ");
}

///
string argsStringWithParens(string reg, alias func)()
{
    return "(" ~ argsString!(reg, func) ~ ")";
}

unittest
{
    void func()
    {
    }

    static assert(argsString!(r"", func) == "");

    void func_is(int, string)
    {
    }

    static assert(argsString!(r"(foo)...(bar)", func_is) == "captures[1].to!int, captures[2]");

    void func_cis(in int, in string)
    {
    }

    static assert(argsString!(r"(foo)...(bar)", func_cis) == "captures[1].to!int, captures[2]");

    void func_si(string, int)
    {
    }

    static assert(argsString!(r"(foo)...(bar)", func_si) == "captures[1], captures[2].to!int");

    void func_dd(double, double)
    {
    }

    static assert(argsString!(r"(foo)...(bar)",
            func_dd) == "captures[1].to!double, captures[2].to!double");

    void funcWithExtraArg(int, DataTable)
    {
    }

    static assert(argsString!(r"(foo)...", funcWithExtraArg,
            "extra") == "captures[1].to!int, extra");
}

/**
 * This function is necessary due to the extreme "metaness" of
 * this project. It returns a string that is meant to be consumed
 * by mixin to generate code. Since the strings being fed to
 * the system at compile-time are generally going to be
 * "raw" strings, they'll either be r"" or `` style D strings.
 * If the regex requires the '"' character they'll use ``, and
 * vice-versa. When generating code, I opted for r"" strings.
 * This would cause a compilation error if the regex has the
 * quote character in it. So this function returns an escaped
 * version that can be safely used.
 */
string rawStringMixin(in string str)
{
    import std.array : replace;

    return "r\"" ~ str.replace(`"`, "\" ~ `\"` ~ r\"") ~ "\"";
}

unittest
{
    static assert(rawStringMixin(
            `Sharks with "lasers" yo.`) == "r\"Sharks with \" ~ `\"` ~ r\"lasers\" ~ `\"` ~ r\" yo.\"");
    static assert(rawStringMixin(`foo bar baz`) == "r\"foo bar baz\"");
}