/* This file is part of the 'hgen' project.
 *
 * Copyright (c) 2014-2022
 *     Economic Modeling Specialists, Intl.,
 *     the D Community.
 *
 * Main contributors:
 *     Ferdinand Majerech
 *     Ilya Yaroshenko
 *     Basile Burg
 *     Eugene Stulin
 *
 * Distributed under the Boost Software License, Version 1.0.
 *
 * You should have received a copy of the Boost Software License
 * along with this program. If not, see <http://www.boost.org/LICENSE_1_0.txt>.
 * This file is offered as-is, without any warranty.
 */

module formatter;

import dparse.ast;
import dparse.lexer;
import dparse.formatter;
import std.stdio;


/*******************************************************************************
 * Modified D formatter for Harbored.
 *
 * Currently the only modification is that multi-parameter parameter lists
 * are split into multiple lines.
 */
class HarboredFormatter(Sink) : Formatter!Sink {
    /// Nesting level for nested parameter lists (see format(const Parameters)).
    private uint level;

    /// Function to process types with for cross-referencing.
    private string delegate(string) @safe nothrow crossReference;

    /**
     * Params:
     *
     * sink        = the output range that the formatted source code
     *               is placed in
     * processCode = Function to process types with for cross-referencing.
     * useTabs     = if true, tabs are used for indent levels instead of spaces
     * style       = the brace style
     * indentWidth = the number of spaces used for indentation
     *               if useTabs is false
     */
    this(Sink sink,
         string delegate(string) @safe nothrow crossReference,
         bool useTabs = false,
         IndentStyle style = IndentStyle.otbs,
         uint indentWidth = 4
    ) {
        this.crossReference = crossReference;
        super(sink, useTabs, style, indentWidth);
    }

    alias format = Formatter!Sink.format;

    /** A modified version
     * of  dparse.formatter.Formatter.format(const Parameters)
    */
    override void format(const Parameters parameters) {
        debug(verbose) writeln("Parameters (HarboredFormatter)");

        // No need to break the list into multiple lines for a single argument
        // TODO ability to set this in "doxyfile"
        const maxParamsForSingleLineParamList = 1;
        if (parameters.parameters.length <= maxParamsForSingleLineParamList) {
            super.format(parameters);
            return;
        }
        level++;
        scope(exit) level--;
        put("(");
        bool moreThanThreeArgs = parameters.parameters.length > 3;
        auto interArgSep = moreThanThreeArgs ? "\n" : "";
        foreach (count, param; parameters.parameters) {
            if (count) {
                put(", ");
            }
            put(interArgSep);
            if (moreThanThreeArgs) {
                foreach(i; 0 .. level) {
                    put("    ");
                }
            }
            format(param);
        }
        if (parameters.hasVarargs) {
            if (parameters.parameters.length) {
                put(", ");
            }
            put(interArgSep);
            if (moreThanThreeArgs) {
                foreach(i; 0 .. level) {
                    put("    ");
                }
            }
            put("...");
        }
        if (level > 1) {
            put("\n");
            foreach(i; 0..level) {
                put("    ");
            }
        }
        put(interArgSep);
        put(")");
    }

    // Overridden for builtin type referencing.
    override void format(const Type2 type2) {
        debug(verbose) writeln("Type2 (HarboredFormatter)");

        /**
        IdType builtinType;
        Symbol symbol;
        TypeofExpression typeofExpression;
        IdentifierOrTemplateChain identifierOrTemplateChain;
        IdType typeConstructor;
        Type type;
        **/

        if (type2.typeIdentifierPart !is null) {
            format(type2.typeIdentifierPart);
        } else if (type2.typeofExpression !is null) {
            format(type2.typeofExpression);
            if (type2.typeIdentifierPart) {
                put(".");
                format(type2.typeIdentifierPart);
            }
            return;
        } else if (type2.typeConstructor != tok!"") {
            put(tokenRep(type2.typeConstructor));
            put("(");
            format(type2.type);
            put(")");
        } else {
            // Link to language reference for builtin types.
            put(`<a href="http://dlang.org/type.html#basic-data-types">`);
            put(tokenRep(type2.builtinType));
            put("</a>");
        }
    }

    // Overridden for cross-referencing.
    override void format(const Token token) {
        debug(verbose) writeln("Token (HarboredFormatter) ", tokenRep(token));
        put(crossReference(tokenRep(token)));
    }

}