/*
 * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
 * Copyright (C) 2011, 2013-2016 The JavaParser Team.
 *
 * This file is part of JavaParser.
 *
 * JavaParser can be used either under the terms of
 * a) the GNU Lesser General Public License as published by
 *     the Free Software Foundation, either version 3 of the License, or
 *     (at your option) any later version.
 * b) the terms of the Apache License
 *
 * You should have received a copy of both licenses in LICENCE.LGPL and
 * LICENCE.APACHE. Please refer to those files for details.
 *
 * JavaParser is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 */
package com.github.javaparser;

import java.util.List;
import java.util.Optional;
import static com.github.javaparser.utils.CodeGenerationUtils.f;
import static com.github.javaparser.utils.Utils.EOL;
import static com.github.javaparser.utils.Utils.assertNotNull;
import javax.annotation.Generated;

/**
 * A token from a parsed source file.
 * (Awkwardly named "Java"Token since JavaCC already generates an internal class Token.)
 * It is a node in a double linked list called token list.
 */
public class JavaToken {

    public static final JavaToken INVALID = new JavaToken();

    private Range range;

    private int kind;

    private String text;

    private JavaToken previousToken = null;

    private JavaToken nextToken = null;

    private JavaToken() {
        this(null, 0, "INVALID", null, null);
    }

    public JavaToken(int kind, String text) {
        this(null, kind, text, null, null);
    }

    JavaToken(Token token, List<JavaToken> tokens) {
        // You could be puzzled by the following lines
        // 
        // The reason why these lines are necessary is the fact that Java is ambiguous. There are cases where the
        // sequence of characters ">>>" and ">>" should be recognized as the single tokens ">>>" and ">>". In other
        // cases however we want to split those characters in single GT tokens (">").
        // 
        // For example, in expressions ">>" and ">>>" are valid, while when defining types we could have this:
        // 
        // List<List<Set<String>>>>
        // 
        // You can see that the sequence ">>>>" should be interpreted as four consecutive ">" tokens closing a type
        // parameter list.
        // 
        // The JavaCC handle this case by first recognizing always the longest token, and then depending on the context
        // putting back the unused chars in the stream. However in those cases the token provided is invalid: it has an
        // image corresponding to the text originally recognized, without considering that after some characters could
        // have been put back into the stream.
        // 
        // So in the case of:
        // 
        // List<List<Set<String>>>>
        // ___   -> recognized as ">>>", then ">>" put back in the stream but Token(type=GT, image=">>>") passed to this class
        // ___  -> recognized as ">>>", then ">>" put back in the stream but Token(type=GT, image=">>>") passed to this class
        // __  -> recognized as ">>", then ">" put back in the stream but Token(type=GT, image=">>") passed to this class
        // _  -> Token(type=GT, image=">") good!
        // 
        // So given the image could be wrong but the type is correct, we look at the type of the token and we fix
        // the image. Everybody is happy and we can keep this horrible thing as our little secret.
        Range range = Range.range(token.beginLine, token.beginColumn, token.endLine, token.endColumn);
        String text = token.image;
        if (token.kind == GeneratedJavaParserConstants.GT) {
            range = Range.range(token.beginLine, token.beginColumn, token.endLine, token.beginColumn);
            text = ">";
        } else if (token.kind == GeneratedJavaParserConstants.RSIGNEDSHIFT) {
            range = Range.range(token.beginLine, token.beginColumn, token.endLine, token.beginColumn + 1);
            text = ">>";
        }
        this.range = range;
        this.kind = token.kind;
        this.text = text;
        if (!tokens.isEmpty()) {
            final JavaToken previousToken = tokens.get(tokens.size() - 1);
            this.previousToken = previousToken;
            previousToken.nextToken = this;
        } else {
            previousToken = null;
        }
    }

    /**
     * Create a token of a certain kind.
     */
    public JavaToken(int kind) {
        String content = GeneratedJavaParserConstants.tokenImage[kind];
        if (content.startsWith("\"")) {
            content = content.substring(1, content.length() - 1);
        }
        if (TokenTypes.isEndOfLineToken(kind)) {
            content = EOL;
        } else if (TokenTypes.isWhitespace(kind)) {
            content = " ";
        }
        this.kind = kind;
        this.text = content;
    }

    public JavaToken(Range range, int kind, String text, JavaToken previousToken, JavaToken nextToken) {
        assertNotNull(text);
        this.range = range;
        this.kind = kind;
        this.text = text;
        this.previousToken = previousToken;
        this.nextToken = nextToken;
    }

    public Optional<Range> getRange() {
        return Optional.ofNullable(range);
    }

    public int getKind() {
        return kind;
    }

    void setKind(int kind) {
        this.kind = kind;
    }

    public String getText() {
        return text;
    }

    public Optional<JavaToken> getNextToken() {
        return Optional.ofNullable(nextToken);
    }

    public Optional<JavaToken> getPreviousToken() {
        return Optional.ofNullable(previousToken);
    }

    public void setRange(Range range) {
        this.range = range;
    }

    public void setText(String text) {
        this.text = text;
    }

    public String asString() {
        return text;
    }

    /**
     * @return the token range that goes from the beginning to the end of the token list this token is a part of.
     */
    public TokenRange toTokenRange() {
        return new TokenRange(findFirstToken(), findLastToken());
    }

    @Override
    public String toString() {
        String text = getText().replace("\n", "\\n").replace("\r", "\\r").replace("\r\n", "\\r\\n").replace("\t", "\\t");
        return f("\"%s\"   <%s>   %s", text, getKind(), getRange().map(Range::toString).orElse("(?)-(?)"));
    }

    /**
     * Used by the parser while constructing nodes. No tokens should be invalid when the parser is done.
     */
    public boolean valid() {
        return !invalid();
    }

    /**
     * Used by the parser while constructing nodes. No tokens should be invalid when the parser is done.
     */
    public boolean invalid() {
        return this == INVALID;
    }

    public enum Category {

        WHITESPACE_NO_EOL,
        EOL,
        COMMENT,
        IDENTIFIER,
        KEYWORD,
        LITERAL,
        SEPARATOR,
        OPERATOR;

        public boolean isWhitespaceOrComment() {
            return isWhitespace() || this == COMMENT;
        }

        public boolean isWhitespace() {
            return this == WHITESPACE_NO_EOL || this == EOL;
        }

        public boolean isEndOfLine() {
            return this == EOL;
        }

        public boolean isComment() {
            return this == COMMENT;
        }

        public boolean isWhitespaceButNotEndOfLine() {
            return this == WHITESPACE_NO_EOL;
        }

        public boolean isIdentifier() {
            return this == IDENTIFIER;
        }

        public boolean isKeyword() {
            return this == KEYWORD;
        }

        public boolean isLiteral() {
            return this == LITERAL;
        }

        public boolean isSeparator() {
            return this == SEPARATOR;
        }

        public boolean isOperator() {
            return this == OPERATOR;
        }
    }

    @Generated("com.github.javaparser.generator.core.other.TokenKindGenerator")
    public enum Kind {

        EOF(0),
        SPACE(1),
        WINDOWS_EOL(2),
        UNIX_EOL(3),
        OLD_MAC_EOL(4),
        SINGLE_LINE_COMMENT(5),
        ENTER_JAVADOC_COMMENT(6),
        ENTER_MULTILINE_COMMENT(7),
        JAVADOC_COMMENT(8),
        MULTI_LINE_COMMENT(9),
        COMMENT_CONTENT(10),
        ABSTRACT(11),
        ASSERT(12),
        BOOLEAN(13),
        BREAK(14),
        BYTE(15),
        CASE(16),
        CATCH(17),
        CHAR(18),
        CLASS(19),
        CONST(20),
        CONTINUE(21),
        _DEFAULT(22),
        DO(23),
        DOUBLE(24),
        ELSE(25),
        ENUM(26),
        EXTENDS(27),
        FALSE(28),
        FINAL(29),
        FINALLY(30),
        FLOAT(31),
        FOR(32),
        GOTO(33),
        IF(34),
        IMPLEMENTS(35),
        IMPORT(36),
        INSTANCEOF(37),
        INT(38),
        INTERFACE(39),
        LONG(40),
        NATIVE(41),
        NEW(42),
        NULL(43),
        PACKAGE(44),
        PRIVATE(45),
        PROTECTED(46),
        PUBLIC(47),
        RETURN(48),
        SHORT(49),
        STATIC(50),
        STRICTFP(51),
        SUPER(52),
        SWITCH(53),
        SYNCHRONIZED(54),
        THIS(55),
        THROW(56),
        THROWS(57),
        TRANSIENT(58),
        TRUE(59),
        TRY(60),
        VOID(61),
        VOLATILE(62),
        WHILE(63),
        REQUIRES(64),
        TO(65),
        WITH(66),
        OPEN(67),
        OPENS(68),
        USES(69),
        MODULE(70),
        EXPORTS(71),
        PROVIDES(72),
        TRANSITIVE(73),
        LONG_LITERAL(74),
        INTEGER_LITERAL(75),
        DECIMAL_LITERAL(76),
        HEX_LITERAL(77),
        OCTAL_LITERAL(78),
        BINARY_LITERAL(79),
        FLOATING_POINT_LITERAL(80),
        DECIMAL_FLOATING_POINT_LITERAL(81),
        DECIMAL_EXPONENT(82),
        HEXADECIMAL_FLOATING_POINT_LITERAL(83),
        HEXADECIMAL_EXPONENT(84),
        HEX_DIGITS(85),
        UNICODE_ESCAPE(86),
        CHARACTER_LITERAL(87),
        STRING_LITERAL(88),
        IDENTIFIER(89),
        LETTER(90),
        PART_LETTER(91),
        LPAREN(92),
        RPAREN(93),
        LBRACE(94),
        RBRACE(95),
        LBRACKET(96),
        RBRACKET(97),
        SEMICOLON(98),
        COMMA(99),
        DOT(100),
        AT(101),
        ASSIGN(102),
        LT(103),
        BANG(104),
        TILDE(105),
        HOOK(106),
        COLON(107),
        EQ(108),
        LE(109),
        GE(110),
        NE(111),
        SC_OR(112),
        SC_AND(113),
        INCR(114),
        DECR(115),
        PLUS(116),
        MINUS(117),
        STAR(118),
        SLASH(119),
        BIT_AND(120),
        BIT_OR(121),
        XOR(122),
        REM(123),
        LSHIFT(124),
        PLUSASSIGN(125),
        MINUSASSIGN(126),
        STARASSIGN(127),
        SLASHASSIGN(128),
        ANDASSIGN(129),
        ORASSIGN(130),
        XORASSIGN(131),
        REMASSIGN(132),
        LSHIFTASSIGN(133),
        RSIGNEDSHIFTASSIGN(134),
        RUNSIGNEDSHIFTASSIGN(135),
        ELLIPSIS(136),
        ARROW(137),
        DOUBLECOLON(138),
        RUNSIGNEDSHIFT(139),
        RSIGNEDSHIFT(140),
        GT(141),
        CTRL_Z(142);

        private final int kind;

        Kind(int kind) {
            this.kind = kind;
        }

        public static Kind valueOf(int kind) {
            switch(kind) {
                case 142:
                    return CTRL_Z;
                case 141:
                    return GT;
                case 140:
                    return RSIGNEDSHIFT;
                case 139:
                    return RUNSIGNEDSHIFT;
                case 138:
                    return DOUBLECOLON;
                case 137:
                    return ARROW;
                case 136:
                    return ELLIPSIS;
                case 135:
                    return RUNSIGNEDSHIFTASSIGN;
                case 134:
                    return RSIGNEDSHIFTASSIGN;
                case 133:
                    return LSHIFTASSIGN;
                case 132:
                    return REMASSIGN;
                case 131:
                    return XORASSIGN;
                case 130:
                    return ORASSIGN;
                case 129:
                    return ANDASSIGN;
                case 128:
                    return SLASHASSIGN;
                case 127:
                    return STARASSIGN;
                case 126:
                    return MINUSASSIGN;
                case 125:
                    return PLUSASSIGN;
                case 124:
                    return LSHIFT;
                case 123:
                    return REM;
                case 122:
                    return XOR;
                case 121:
                    return BIT_OR;
                case 120:
                    return BIT_AND;
                case 119:
                    return SLASH;
                case 118:
                    return STAR;
                case 117:
                    return MINUS;
                case 116:
                    return PLUS;
                case 115:
                    return DECR;
                case 114:
                    return INCR;
                case 113:
                    return SC_AND;
                case 112:
                    return SC_OR;
                case 111:
                    return NE;
                case 110:
                    return GE;
                case 109:
                    return LE;
                case 108:
                    return EQ;
                case 107:
                    return COLON;
                case 106:
                    return HOOK;
                case 105:
                    return TILDE;
                case 104:
                    return BANG;
                case 103:
                    return LT;
                case 102:
                    return ASSIGN;
                case 101:
                    return AT;
                case 100:
                    return DOT;
                case 99:
                    return COMMA;
                case 98:
                    return SEMICOLON;
                case 97:
                    return RBRACKET;
                case 96:
                    return LBRACKET;
                case 95:
                    return RBRACE;
                case 94:
                    return LBRACE;
                case 93:
                    return RPAREN;
                case 92:
                    return LPAREN;
                case 91:
                    return PART_LETTER;
                case 90:
                    return LETTER;
                case 89:
                    return IDENTIFIER;
                case 88:
                    return STRING_LITERAL;
                case 87:
                    return CHARACTER_LITERAL;
                case 86:
                    return UNICODE_ESCAPE;
                case 85:
                    return HEX_DIGITS;
                case 84:
                    return HEXADECIMAL_EXPONENT;
                case 83:
                    return HEXADECIMAL_FLOATING_POINT_LITERAL;
                case 82:
                    return DECIMAL_EXPONENT;
                case 81:
                    return DECIMAL_FLOATING_POINT_LITERAL;
                case 80:
                    return FLOATING_POINT_LITERAL;
                case 79:
                    return BINARY_LITERAL;
                case 78:
                    return OCTAL_LITERAL;
                case 77:
                    return HEX_LITERAL;
                case 76:
                    return DECIMAL_LITERAL;
                case 75:
                    return INTEGER_LITERAL;
                case 74:
                    return LONG_LITERAL;
                case 73:
                    return TRANSITIVE;
                case 72:
                    return PROVIDES;
                case 71:
                    return EXPORTS;
                case 70:
                    return MODULE;
                case 69:
                    return USES;
                case 68:
                    return OPENS;
                case 67:
                    return OPEN;
                case 66:
                    return WITH;
                case 65:
                    return TO;
                case 64:
                    return REQUIRES;
                case 63:
                    return WHILE;
                case 62:
                    return VOLATILE;
                case 61:
                    return VOID;
                case 60:
                    return TRY;
                case 59:
                    return TRUE;
                case 58:
                    return TRANSIENT;
                case 57:
                    return THROWS;
                case 56:
                    return THROW;
                case 55:
                    return THIS;
                case 54:
                    return SYNCHRONIZED;
                case 53:
                    return SWITCH;
                case 52:
                    return SUPER;
                case 51:
                    return STRICTFP;
                case 50:
                    return STATIC;
                case 49:
                    return SHORT;
                case 48:
                    return RETURN;
                case 47:
                    return PUBLIC;
                case 46:
                    return PROTECTED;
                case 45:
                    return PRIVATE;
                case 44:
                    return PACKAGE;
                case 43:
                    return NULL;
                case 42:
                    return NEW;
                case 41:
                    return NATIVE;
                case 40:
                    return LONG;
                case 39:
                    return INTERFACE;
                case 38:
                    return INT;
                case 37:
                    return INSTANCEOF;
                case 36:
                    return IMPORT;
                case 35:
                    return IMPLEMENTS;
                case 34:
                    return IF;
                case 33:
                    return GOTO;
                case 32:
                    return FOR;
                case 31:
                    return FLOAT;
                case 30:
                    return FINALLY;
                case 29:
                    return FINAL;
                case 28:
                    return FALSE;
                case 27:
                    return EXTENDS;
                case 26:
                    return ENUM;
                case 25:
                    return ELSE;
                case 24:
                    return DOUBLE;
                case 23:
                    return DO;
                case 22:
                    return _DEFAULT;
                case 21:
                    return CONTINUE;
                case 20:
                    return CONST;
                case 19:
                    return CLASS;
                case 18:
                    return CHAR;
                case 17:
                    return CATCH;
                case 16:
                    return CASE;
                case 15:
                    return BYTE;
                case 14:
                    return BREAK;
                case 13:
                    return BOOLEAN;
                case 12:
                    return ASSERT;
                case 11:
                    return ABSTRACT;
                case 10:
                    return COMMENT_CONTENT;
                case 9:
                    return MULTI_LINE_COMMENT;
                case 8:
                    return JAVADOC_COMMENT;
                case 7:
                    return ENTER_MULTILINE_COMMENT;
                case 6:
                    return ENTER_JAVADOC_COMMENT;
                case 5:
                    return SINGLE_LINE_COMMENT;
                case 4:
                    return OLD_MAC_EOL;
                case 3:
                    return UNIX_EOL;
                case 2:
                    return WINDOWS_EOL;
                case 1:
                    return SPACE;
                case 0:
                    return EOF;
                default:
                    throw new IllegalArgumentException(f("Token kind %i is unknown.", kind));
            }
        }

        public int getKind() {
            return kind;
        }
    }

    public JavaToken.Category getCategory() {
        return TokenTypes.getCategory(kind);
    }

    /**
     * Inserts newToken into the token list just before this token.
     */
    public void insert(JavaToken newToken) {
        assertNotNull(newToken);
        getPreviousToken().ifPresent(p -> {
            p.nextToken = newToken;
            newToken.previousToken = p;
        });
        previousToken = newToken;
        newToken.nextToken = this;
    }

    /**
     * Inserts newToken into the token list just after this token.
     */
    public void insertAfter(JavaToken newToken) {
        assertNotNull(newToken);
        getNextToken().ifPresent(n -> {
            n.previousToken = newToken;
            newToken.nextToken = n;
        });
        nextToken = newToken;
        newToken.previousToken = this;
    }

    /**
     * Links the tokens around the current token together, making the current token disappear from the list.
     */
    public void deleteToken() {
        final Optional<JavaToken> nextToken = getNextToken();
        final Optional<JavaToken> previousToken = getPreviousToken();
        previousToken.ifPresent(p -> p.nextToken = nextToken.orElse(null));
        nextToken.ifPresent(n -> n.previousToken = previousToken.orElse(null));
    }

    /**
     * Replaces the current token with newToken.
     */
    public void replaceToken(JavaToken newToken) {
        assertNotNull(newToken);
        getPreviousToken().ifPresent(p -> {
            p.nextToken = newToken;
            newToken.previousToken = p;
        });
        getNextToken().ifPresent(n -> {
            n.previousToken = newToken;
            newToken.nextToken = n;
        });
    }

    /**
     * @return the last token in the token list.
     */
    public JavaToken findLastToken() {
        JavaToken current = this;
        while (current.getNextToken().isPresent()) {
            current = current.getNextToken().get();
        }
        return current;
    }

    /**
     * @return the first token in the token list.
     */
    public JavaToken findFirstToken() {
        JavaToken current = this;
        while (current.getPreviousToken().isPresent()) {
            current = current.getPreviousToken().get();
        }
        return current;
    }

    @Override
    public int hashCode() {
        int result = kind;
        result = 31 * result + text.hashCode();
        return result;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        JavaToken javaToken = (JavaToken) o;
        if (kind != javaToken.kind)
            return false;
        if (!text.equals(javaToken.text))
            return false;
        return true;
    }
}