/*
 * [The "BSD license"]
 *  Copyright (c) 2016 Terence Parr
 *  Copyright (c) 2016 Sam Harwell
 *  Copyright (c) 2017 Egbert Voigt
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

module antlr.v4.runtime.VocabularyImpl;

import std.conv;
import std.ascii;
import std.algorithm.comparison;
import antlr.v4.runtime.Vocabulary;
import antlr.v4.runtime.Token;
import antlr.v4.runtime.TokenConstantDefinition;

/**
 * This class provides a default implementation of the {@link Vocabulary}
 * interface.
 */
class VocabularyImpl : Vocabulary
{

    public string[] EMPTY_NAMES;

    public string[] literalNames;

    public string[] symbolicNames;

    public string[] displayNames;

    /**
     * @uml
     * @final
     */
    private int maxTokenType;

    /**
     * Constructs a new instance of {@link VocabularyImpl} from the specified
     * literal and symbolic token names.
     *
     *  @param literalNames The literal names assigned to tokens, or {@code null}
     *  if no literal names are assigned.
     *  @param symbolicNames The symbolic names assigned to tokens, or
     *  {@code null} if no symbolic names are assigned.
     *
     *  @see #getLiteralName(int)
     *  @see #getSymbolicName(int)
     */
    public this(const string[] literalNames, const string[] symbolicNames)
    {
        this(literalNames, symbolicNames, null);
    }

    /**
     * @uml
     * Constructs a new instance of {@link VocabularyImpl} from the specified
     * literal, symbolic, and display token names.
     *
     *  @param literalNames The literal names assigned to tokens, or {@code null}
     * if no literal names are assigned.
     *  @param symbolicNames The symbolic names assigned to tokens, or
     *  {@code null} if no symbolic names are assigned.
     *  @param displayNames The display names assigned to tokens, or {@code null}
     * to use the values in {@code literalNames} and {@code symbolicNames} as
     * the source of display names, as described in
     *  {@link #getDisplayName(int)}.
     *
     *  @see #getLiteralName(int)
     *  @see #getSymbolicName(int)
     *  @see #getDisplayName(int)
     */
    public this(const string[] literalNames, const string[] symbolicNames, string[] displayNames)
    {
        this.literalNames = literalNames !is null ? to!(string[])(literalNames) : to!(string[])(EMPTY_NAMES);
        this.symbolicNames = symbolicNames !is null ? to!(string[])(symbolicNames) : to!(string[])(EMPTY_NAMES);
        this.displayNames = displayNames !is null ? displayNames : to!(string[])(EMPTY_NAMES);
        // See note here on -1 part: https://github.com/antlr/antlr4/pull/1146
        this.maxTokenType =
            max(to!int(this.displayNames.length),
                max(to!int(this.literalNames.length), to!int(this.symbolicNames.length))) - 1;
    }

    /**
     * @uml
     * Returns a {@link VocabularyImpl} instance from the specified set of token
     * names. This method acts as a compatibility layer for the single
     * {@code tokenNames} array generated by previous releases of ANTLR.
     *
     * <p>The resulting vocabulary instance returns {@code null} for
     * {@link #getLiteralName(int)} and {@link #getSymbolicName(int)}, and the
     * value from {@code tokenNames} for the display names.</p>
     *
     *  @param tokenNames The token names, or {@code null} if no token names are
     * available.
     *  @return A {@link Vocabulary} instance which uses {@code tokenNames} for
     * the display names of tokens.
     */
    public static Vocabulary fromTokenNames(string[] tokenNames)
    {
        if (tokenNames is null || tokenNames.length == 0) {
            // return EMPTY_VOCABULARY;
            return new VocabularyImpl(null, null, null);
        }

        string[] literalNames = tokenNames.dup;
        string[] symbolicNames = tokenNames.dup;
        for (int i = 0; i < tokenNames.length; i++) {
            string tokenName = tokenNames[i];
            if (tokenName == null) {
                continue;
            }

            if (tokenName.length > 0) {
                char firstChar = tokenName[0];
                if (firstChar == '\'') {
                    symbolicNames[i] = null;
                    continue;
                }
                else if (isUpper(firstChar)) {
                    literalNames[i] = null;
                    continue;
                }
            }

            // wasn't a literal or symbolic name
            literalNames[i] = null;
            symbolicNames[i] = null;
        }

        return new VocabularyImpl(literalNames, symbolicNames, tokenNames);
    }

    public string getSymbolicName(int tokenType)
    {
        if (tokenType >= 0 && tokenType < symbolicNames.length) {
            return symbolicNames[tokenType];
        }

        if (tokenType == TokenConstantDefinition.EOF) {
            return "EOF";
        }

        return null;
    }

    public int getMaxTokenType()
    {
        return maxTokenType;
    }

    public string getDisplayName(int tokenType)
    {
        if (tokenType >= 0 && tokenType < displayNames.length) {
            string displayName = displayNames[tokenType];
            if (displayName !is null) {
                return displayName;
            }
        }

        string literalName = getLiteralName(tokenType);
        if (literalName !is null) {
            return literalName;
        }

        string symbolicName = getSymbolicName(tokenType);
        if (symbolicName != null) {
            return symbolicName;
        }

        return to!string(tokenType);
    }

    public string getLiteralName(int tokenType)
    {
        if (tokenType >= 0 && tokenType < literalNames.length) {
            return literalNames[tokenType];
        }
        return null;
    }

}