/**
 * Perform highlighting on code section.
 *
 * DDOC string can contains embedded code. Those code can be highlighted by
 * means of macros (keywork will be surrounded by $(DOLLAR)(D_KEYWORD),
 * comments by $(DOLLAR)(D_COMMENT), etc...
 * This module performs the highlighting.
 *
 * Copyright: © 2014 Economic Modeling Specialists, Intl.
 * Authors: Brian Schott, Mathias 'Geod24' Lang
 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
 */
module ddoc.highlight;

/**
 * Parses a string and replace embedded code (code between at least 3 '-') with
 * the relevant macros.
 *
 * Params:
 * str = A string that might contain embedded code. Only code will be modified.
 *     If the string doesn't contain any embedded code, it will be returned as is.
 *
 * Returns:
 * A (possibly new) string containing the embedded code put in the proper macros.
 */
string highlight(string str)
{
    // Note: I don't think DMD is conformant w.r.t ddoc.
    // The following file:
    // Ddoc
    // ----
    // int main(string[] args) { return 0;}
    // void test(int hello, string other);
    // ----
    //
    // Produce the following document ($(DDOC) boilerplate excluded:
    //
    // <pre class="d_code"><font color=blue>int</font> main(string[] args) { <font color=blue>return</font> 0;}
    // <font color=blue>void</font> test(<font color=blue>int</font> hello, string other);
    // </pre>

    import ddoc.lexer;
    import ddoc.macros : tokOffset;
    import std.array : appender;

    auto lex = Lexer(str, true);
    auto output = appender!string;
    size_t start;
    // We need this because there's no way to tell how many dashes precede
    // an embedded.
    size_t end;
    while (!lex.empty)
    {
        if (lex.front.type == Type.embedded)
        {
            if (start != end)
                output.put(lex.text[start .. end]);
            output.put("$(D_CODE ");
            highlightCode(lex.front.text, output);
            output.put(")");
            start = lex.offset;
        }
        else if (lex.front.type == Type.inlined)
        {
            if (start != end)
                output.put(lex.text[start .. end]);
            output.put("$(DDOC_BACKQUOTED ");
            highlightCode(lex.front.text, output);
            output.put(")");
            start = lex.offset;
        }
        end = lex.offset;
        lex.popFront();
    }
    if (start)
        output.put(lex.text[start .. end]);
    return start ? output.data : str;
}

///
unittest
{
    import ddoc.lexer;

    auto s1 = `Here is some embedded D code I'd like to show you:
$(MY_D_CODE
------
// Entry point...
void main() {
  import std.stdio : writeln;
  writeln("Hello,", " ", "world", "!");
}
------
)
Isn't it pretty ?`;
    // Embedded code is surrounded by D_CODE macro, and tokens have their own
    // macros (see: D_KEYWORD for example).
    auto r1 = highlight(s1);
    auto e1 = `Here is some embedded D code I'd like to show you:
$(MY_D_CODE
$(D_CODE $(D_COMMENT // Entry point...)
$(D_KEYWORD void) main() {
  $(D_KEYWORD import) std.stdio : writeln;
  writeln($(D_STRING "Hello,"), $(D_STRING " "), $(D_STRING "world"), $(D_STRING "!"));
})
)
Isn't it pretty ?`;
    assert(r1 == e1, r1);

    // No allocation is performed if the string doesn't contain inline code.
    auto s2 = `This is some simple string
--
It doesn't do much
--
Hope you won't allocate`;
    auto r2 = highlight(s2);
    assert(r2 is s2, r2);
}

// Test multiple embedded code.
unittest
{
    auto s1 = `----
void main() {}
----
----
int a = 42;
----
---
unittest {
    assert(42, "Life, universe, stuff");
}
---`;
    auto e1 = `$(D_CODE $(D_KEYWORD void) main() {})
$(D_CODE $(D_KEYWORD int) a = 42;)
$(D_CODE $(D_KEYWORD unittest) {
    $(D_KEYWORD assert)(42, $(D_STRING "Life, universe, stuff"));
})`;
    auto r1 = highlight(s1);
    assert(r1 == e1, r1);
}

unittest
{
    auto s = `
        ---------
        asm pure nothrow @nogc @trusted
        {
            // the compiler does not check the attributes
            ret;
        }
        ---------
`;
    auto e = `
        $(D_CODE $(D_KEYWORD asm) $(D_KEYWORD pure) $(D_KEYWORD nothrow) @nogc @trusted
{
    $(D_COMMENT // the compiler does not check the attributes)
    ret;
}
)
`;
    auto r = highlight(s);
    assert(r == e, r);
}

private:
void highlightCode(O)(string code, ref O output)
{
    import dparse.lexer;
    import std.string : representation;

    enum fName = "<embedded-code-in-documentation>";

    auto cache = StringCache(StringCache.defaultBucketCount);
    auto toks = code.representation.dup.byToken(LexerConfig(fName,
        StringBehavior.source, WhitespaceBehavior.include), &cache);
    while (!toks.empty)
    {
        if (toks.front.type.isStringLiteral)
        {
            output.put("$(D_STRING ");
            output.put(toks.front.text);
            output.put(")");
        }
        else if (toks.front == tok!"comment")
        {
            output.put("$(D_COMMENT ");
            output.put(toks.front.text);
            output.put(")");
        }
        else if (toks.front.type.isKeyword || toks.front.type.isBasicType)
        {
            output.put("$(D_KEYWORD ");
            output.put(toks.front.type.str);
            output.put(")");
        }
        else if (toks.front.text.length)
        {
            output.put(toks.front.text);
        }
        else
        {
            output.put(toks.front.type.str);
        }
        toks.popFront();
    }
}