/*

 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code 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 General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package jdk.nashorn.internal.ir;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import jdk.nashorn.internal.codegen.CompileUnit;

import jdk.nashorn.internal.codegen.types.ArrayType;

import jdk.nashorn.internal.codegen.types.Type;

import jdk.nashorn.internal.ir.annotations.Immutable;

import jdk.nashorn.internal.ir.visitor.NodeVisitor;

import jdk.nashorn.internal.objects.NativeArray;

import jdk.nashorn.internal.parser.Lexer.LexerToken;

import jdk.nashorn.internal.parser.Token;

import jdk.nashorn.internal.parser.TokenType;

import jdk.nashorn.internal.runtime.JSType;

import jdk.nashorn.internal.runtime.ScriptRuntime;

import jdk.nashorn.internal.runtime.Undefined;

/**

 * Literal nodes represent JavaScript values.

 *

 * @param <T> the literal type

 */

@Immutable

public abstract class LiteralNode<T> extends Expression implements PropertyKey {

    /** Literal value */

    protected final T value;

    /** Marker for values that must be computed at runtime */

    public static final Object POSTSET_MARKER = new Object();

    /**

     * Constructor

     *

     * @param token   token

     * @param finish  finish

     * @param value   the value of the literal

     */

    protected LiteralNode(final long token, final int finish, final T value) {

        super(token, finish);

        this.value = value;

    }

    /**

     * Copy constructor

     *

     * @param literalNode source node

     */

    protected LiteralNode(final LiteralNode<T> literalNode) {

        this(literalNode, literalNode.value);

    }

    /**

     * A copy constructor with value change.

     * @param literalNode the original literal node

     * @param newValue new value for this node

     */

    protected LiteralNode(final LiteralNode<T> literalNode, final T newValue) {

        super(literalNode);

        this.value = newValue;

    }

    @Override

    public boolean isAtom() {

        return true;

    }

    /**

     * Check if the literal value is null

     * @return true if literal value is null

     */

    public boolean isNull() {

        return value == null;

    }

    @Override

    public Type getType() {

        return Type.typeFor(value.getClass());

    }

    @Override

    public String getPropertyName() {

        return JSType.toString(getObject());

    }

    /**

     * Fetch boolean value of node.

     *

     * @return boolean value of node.

     */

    public boolean getBoolean() {

        return JSType.toBoolean(value);

    }

    /**

     * Fetch int32 value of node.

     *

     * @return Int32 value of node.

     */

    public int getInt32() {

        return JSType.toInt32(value);

    }

    /**

     * Fetch uint32 value of node.

     *

     * @return uint32 value of node.

     */

    public long getUint32() {

        return JSType.toUint32(value);

    }

    /**

     * Fetch long value of node

     *

     * @return long value of node

     */

    public long getLong() {

        return JSType.toLong(value);

    }

    /**

     * Fetch double value of node.

     *

     * @return double value of node.

     */

    public double getNumber() {

        return JSType.toNumber(value);

    }

    /**

     * Get the array value of the node

     *

     * @return the array value

     */

    public Node[] getArray() {

        assert false : "not an array node";

        return null;

    }

    /**

     * Fetch String value of node.

     *

     * @return String value of node.

     */

    public String getString() {

        return JSType.toString(value);

    }

    /**

     * Fetch Object value of node.

     *

     * @return Object value of node.

     */

    public Object getObject() {

        return value;

    }

    /**

     * Test if the value is a string.

     *

     * @return True if value is a string.

     */

    public boolean isString() {

        return value instanceof String;

    }

    /**

     * Test if tha value is a number

     *

     * @return True if value is a number

     */

    public boolean isNumeric() {

        return value instanceof Number;

    }

    /**

     * Assist in IR navigation.

     *

     * @param visitor IR navigating visitor.

     */

    @Override

    public Node accept(final NodeVisitor<? extends LexicalContext> visitor) {

        if (visitor.enterLiteralNode(this)) {

            return visitor.leaveLiteralNode(this);

        }

        return this;

    }

    @Override

    public void toString(final StringBuilder sb) {

        if (value == null) {

            sb.append("null");

        } else {

            sb.append(value.toString());

        }

    }

    /**

     * Get the literal node value

     * @return the value

     */

    public T getValue() {

        return value;

    }

    /**

     * Create a new null literal

     *

     * @param token   token

     * @param finish  finish

     *

     * @return the new literal node

     */

    public static LiteralNode<Object> newInstance(final long token, final int finish) {

        return new NullLiteralNode(token, finish);

    }

    /**

     * Create a new null literal based on a parent node (source, token, finish)

     *

     * @param parent parent node

     *

     * @return the new literal node

     */

    public static LiteralNode<Object> newInstance(final Node parent) {

        return new NullLiteralNode(parent.getToken(), parent.getFinish());

    }

    /**

     * Super class for primitive (side-effect free) literals.

     *

     * @param <T> the literal type

     */

    public static class PrimitiveLiteralNode<T> extends LiteralNode<T> {

        private PrimitiveLiteralNode(final long token, final int finish, final T value) {

            super(token, finish, value);

        }

        private PrimitiveLiteralNode(final PrimitiveLiteralNode<T> literalNode) {

            super(literalNode);

        }

        /**

         * Check if the literal value is boolean true

         * @return true if literal value is boolean true

         */

        public boolean isTrue() {

            return JSType.toBoolean(value);

        }

    }

    @Immutable

    private static final class BooleanLiteralNode extends PrimitiveLiteralNode<Boolean> {

        private BooleanLiteralNode(final long token, final int finish, final boolean value) {

            super(Token.recast(token, value ? TokenType.TRUE : TokenType.FALSE), finish, value);

        }

        private BooleanLiteralNode(final BooleanLiteralNode literalNode) {

            super(literalNode);

        }

        @Override

        public boolean isTrue() {

            return value;

        }

        @Override

        public Type getType() {

            return Type.BOOLEAN;

        }

        @Override

        public Type getWidestOperationType() {

            return Type.BOOLEAN;

        }

    }

    /**

     * Create a new boolean literal

     *

     * @param token   token

     * @param finish  finish

     * @param value   true or false

     *

     * @return the new literal node

     */

    public static LiteralNode<Boolean> newInstance(final long token, final int finish, final boolean value) {

        return new BooleanLiteralNode(token, finish, value);

    }

    /**

     * Create a new boolean literal based on a parent node (source, token, finish)

     *

     * @param parent parent node

     * @param value  true or false

     *

     * @return the new literal node

     */

    public static LiteralNode<?> newInstance(final Node parent, final boolean value) {

        return new BooleanLiteralNode(parent.getToken(), parent.getFinish(), value);

    }

    @Immutable

    private static final class NumberLiteralNode extends PrimitiveLiteralNode<Number> {

        private final Type type = numberGetType(value);

        private NumberLiteralNode(final long token, final int finish, final Number value) {

            super(Token.recast(token, TokenType.DECIMAL), finish, value);

        }

        private NumberLiteralNode(final NumberLiteralNode literalNode) {

            super(literalNode);

        }

        private static Type numberGetType(final Number number) {

            if (number instanceof Integer) {

                return Type.INT;

            } else if (number instanceof Long) {

                return Type.LONG;

            } else if (number instanceof Double) {

                return Type.NUMBER;

            } else {

                assert false;

            }

            return null;

        }

        @Override

        public Type getType() {

            return type;

        }

        @Override

        public Type getWidestOperationType() {

            return getType();

        }

    }

    /**

     * Create a new number literal

     *

     * @param token   token

     * @param finish  finish

     * @param value   literal value

     *

     * @return the new literal node

     */

    public static LiteralNode<Number> newInstance(final long token, final int finish, final Number value) {

        return new NumberLiteralNode(token, finish, value);

    }

    /**

     * Create a new number literal based on a parent node (source, token, finish)

     *

     * @param parent parent node

     * @param value  literal value

     *

     * @return the new literal node

     */

    public static LiteralNode<?> newInstance(final Node parent, final Number value) {

        return new NumberLiteralNode(parent.getToken(), parent.getFinish(), value);

    }

    private static class UndefinedLiteralNode extends PrimitiveLiteralNode<Undefined> {

        private UndefinedLiteralNode(final long token, final int finish) {

            super(Token.recast(token, TokenType.OBJECT), finish, ScriptRuntime.UNDEFINED);

        }

        private UndefinedLiteralNode(final UndefinedLiteralNode literalNode) {

            super(literalNode);

        }

    }

    /**

     * Create a new undefined literal

     *

     * @param token   token

     * @param finish  finish

     * @param value   undefined value, passed only for polymorphisism discrimination

     *

     * @return the new literal node

     */

    public static LiteralNode<Undefined> newInstance(final long token, final int finish, final Undefined value) {

        return new UndefinedLiteralNode(token, finish);

    }

    /**

     * Create a new null literal based on a parent node (source, token, finish)

     *

     * @param parent parent node

     * @param value  undefined value

     *

     * @return the new literal node

     */

    public static LiteralNode<?> newInstance(final Node parent, final Undefined value) {

        return new UndefinedLiteralNode(parent.getToken(), parent.getFinish());

    }

    @Immutable

    private static class StringLiteralNode extends PrimitiveLiteralNode<String> {

        private StringLiteralNode(final long token, final int finish, final String value) {

            super(Token.recast(token, TokenType.STRING), finish, value);

        }

        private StringLiteralNode(final StringLiteralNode literalNode) {

            super(literalNode);

        }

        @Override

        public void toString(final StringBuilder sb) {

            sb.append('\"');

            sb.append(value);

            sb.append('\"');

        }

    }

    /**

     * Create a new string literal

     *

     * @param token   token

     * @param finish  finish

     * @param value   string value

     *

     * @return the new literal node

     */

    public static LiteralNode<String> newInstance(final long token, final int finish, final String value) {

        return new StringLiteralNode(token, finish, value);

    }

    /**

     * Create a new String literal based on a parent node (source, token, finish)

     *

     * @param parent parent node

     * @param value  string value

     *

     * @return the new literal node

     */

    public static LiteralNode<?> newInstance(final Node parent, final String value) {

        return new StringLiteralNode(parent.getToken(), parent.getFinish(), value);

    }

    @Immutable

    private static class LexerTokenLiteralNode extends LiteralNode<LexerToken> {

        private LexerTokenLiteralNode(final long token, final int finish, final LexerToken value) {

            super(Token.recast(token, TokenType.STRING), finish, value); //TODO is string the correct token type here?

        }

        private LexerTokenLiteralNode(final LexerTokenLiteralNode literalNode) {

            super(literalNode);

        }

        @Override

        public Type getType() {

            return Type.OBJECT;

        }

        @Override

        public void toString(final StringBuilder sb) {

            sb.append(value.toString());

        }

    }

    /**

     * Create a new literal node for a lexer token

     *

     * @param token   token

     * @param finish  finish

     * @param value   lexer token value

     *

     * @return the new literal node