/*

 * 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.objects;

import static jdk.nashorn.internal.lookup.Lookup.MH;

import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;

import static jdk.nashorn.internal.runtime.JSType.isRepresentableAsInt;

import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import java.text.Collator;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.LinkedList;

import java.util.List;

import java.util.Locale;

import java.util.Set;

import jdk.internal.dynalink.CallSiteDescriptor;

import jdk.internal.dynalink.linker.GuardedInvocation;

import jdk.internal.dynalink.linker.LinkRequest;

import jdk.nashorn.internal.lookup.MethodHandleFactory.LookupException;

import jdk.nashorn.internal.objects.annotations.Attribute;

import jdk.nashorn.internal.objects.annotations.Constructor;

import jdk.nashorn.internal.objects.annotations.Function;

import jdk.nashorn.internal.objects.annotations.Getter;

import jdk.nashorn.internal.objects.annotations.ScriptClass;

import jdk.nashorn.internal.objects.annotations.SpecializedFunction;

import jdk.nashorn.internal.objects.annotations.SpecializedFunction.LinkLogic;

import jdk.nashorn.internal.objects.annotations.Where;

import jdk.nashorn.internal.runtime.ConsString;

import jdk.nashorn.internal.runtime.JSType;

import jdk.nashorn.internal.runtime.OptimisticBuiltins;

import jdk.nashorn.internal.runtime.PropertyMap;

import jdk.nashorn.internal.runtime.ScriptFunction;

import jdk.nashorn.internal.runtime.ScriptObject;

import jdk.nashorn.internal.runtime.ScriptRuntime;

import jdk.nashorn.internal.runtime.arrays.ArrayIndex;

import jdk.nashorn.internal.runtime.linker.NashornGuards;

import jdk.nashorn.internal.runtime.linker.PrimitiveLookup;

/**

 * ECMA 15.5 String Objects.

 */

@ScriptClass("String")

public final class NativeString extends ScriptObject implements OptimisticBuiltins {

    private final CharSequence value;

    /** Method handle to create an object wrapper for a primitive string */

    static final MethodHandle WRAPFILTER = findOwnMH("wrapFilter", MH.type(NativeString.class, Object.class));

    /** Method handle to retrieve the String prototype object */

    private static final MethodHandle PROTOFILTER = findOwnMH("protoFilter", MH.type(Object.class, Object.class));

    // initialized by nasgen

    private static PropertyMap $nasgenmap$;

    private NativeString(final CharSequence value) {

        this(value, Global.instance());

    }

    NativeString(final CharSequence value, final Global global) {

        this(value, global.getStringPrototype(), $nasgenmap$);

    }

    private NativeString(final CharSequence value, final ScriptObject proto, final PropertyMap map) {

        super(proto, map);

        this.value = value;

    }

    @Override

    public String safeToString() {

        return "[String " + toString() + "]";

    }

    @Override

    public String toString() {

        return getStringValue();

    }

    @Override

    public boolean equals(final Object other) {

        if (other instanceof NativeString) {

            return getStringValue().equals(((NativeString) other).getStringValue());

        }

        return false;

    }

    @Override

    public int hashCode() {

        return getStringValue().hashCode();

    }

    private String getStringValue() {

        return value instanceof String ? (String) value : value.toString();

    }

    private CharSequence getValue() {

        return value;

    }

    @Override

    public String getClassName() {

        return "String";

    }

    @Override

    public Object getLength() {

        return value.length();

    }

    // This is to support length as method call as well.

    @Override

    protected GuardedInvocation findGetMethod(final CallSiteDescriptor desc, final LinkRequest request, final String operator) {

        final String name = desc.getNameToken(2);

        // if str.length(), then let the bean linker handle it

        if ("length".equals(name) && "getMethod".equals(operator)) {

            return null;

        }

        return super.findGetMethod(desc, request, operator);

    }

    // This is to provide array-like access to string characters without creating a NativeString wrapper.

    @Override

    protected GuardedInvocation findGetIndexMethod(final CallSiteDescriptor desc, final LinkRequest request) {

        final Object self = request.getReceiver();

        final Class<?> returnType = desc.getMethodType().returnType();

            try {

                return new GuardedInvocation(MH.findStatic(MethodHandles.lookup(), NativeString.class, "get", desc.getMethodType()), NashornGuards.getInstanceOf2Guard(String.class, ConsString.class));

            } catch (final LookupException e) {

                //empty. Shouldn't happen. Fall back to super

            }

        }

        return super.findGetIndexMethod(desc, request);

    }

    @SuppressWarnings("unused")

    private static Object get(final Object self, final Object key) {

        final CharSequence cs = JSType.toCharSequence(self);

        final Object primitiveKey = JSType.toPrimitive(key, String.class);

        final int index = ArrayIndex.getArrayIndex(primitiveKey);

        if (index >= 0 && index < cs.length()) {

            return String.valueOf(cs.charAt(index));

        }

        return ((ScriptObject) Global.toObject(self)).get(primitiveKey);

    }

    @SuppressWarnings("unused")

    private static Object get(final Object self, final double key) {

        if (isRepresentableAsInt(key)) {

            return get(self, (int)key);

        }

        return ((ScriptObject) Global.toObject(self)).get(key);

    }

    @SuppressWarnings("unused")

    private static Object get(final Object self, final long key) {

        final CharSequence cs = JSType.toCharSequence(self);

        if (key >= 0 && key < cs.length()) {

            return String.valueOf(cs.charAt((int)key));

        }

        return ((ScriptObject) Global.toObject(self)).get(key);

    }

    private static Object get(final Object self, final int key) {

        final CharSequence cs = JSType.toCharSequence(self);

        if (key >= 0 && key < cs.length()) {

            return String.valueOf(cs.charAt(key));

        }

        return ((ScriptObject) Global.toObject(self)).get(key);

    }

    // String characters can be accessed with array-like indexing..

    @Override

    public Object get(final Object key) {

        final Object primitiveKey = JSType.toPrimitive(key, String.class);

        final int index = ArrayIndex.getArrayIndex(primitiveKey);

        if (index >= 0 && index < value.length()) {

            return String.valueOf(value.charAt(index));

        }

        return super.get(primitiveKey);

    }

    @Override

    public Object get(final double key) {

        if (isRepresentableAsInt(key)) {

            return get((int)key);

        }

        return super.get(key);

    }

    @Override

    public Object get(final long key) {

        if (key >= 0 && key < value.length()) {

            return String.valueOf(value.charAt((int)key));

        }

        return super.get(key);

    }

    @Override

    public Object get(final int key) {

        if (key >= 0 && key < value.length()) {

            return String.valueOf(value.charAt(key));

        }

        return super.get(key);

    }

    @Override

    public int getInt(final Object key, final int programPoint) {

        return JSType.toInt32MaybeOptimistic(get(key), programPoint);

    }

    @Override

    public int getInt(final double key, final int programPoint) {

        return JSType.toInt32MaybeOptimistic(get(key), programPoint);

    }

    @Override

    public int getInt(final long key, final int programPoint) {

        return JSType.toInt32MaybeOptimistic(get(key), programPoint);

    }

    @Override

    public int getInt(final int key, final int programPoint) {

        return JSType.toInt32MaybeOptimistic(get(key), programPoint);

    }

    @Override

    public long getLong(final Object key, final int programPoint) {

        return JSType.toLongMaybeOptimistic(get(key), programPoint);

    }

    @Override

    public long getLong(final double key, final int programPoint) {

        return JSType.toLongMaybeOptimistic(get(key), programPoint);

    }

    @Override

    public long getLong(final long key, final int programPoint) {

        return JSType.toLongMaybeOptimistic(get(key), programPoint);

    }

    @Override

    public long getLong(final int key, final int programPoint) {

        return JSType.toLongMaybeOptimistic(get(key), programPoint);

    }

    @Override

    public double getDouble(final Object key, final int programPoint) {

        return JSType.toNumberMaybeOptimistic(get(key), programPoint);

    }

    @Override

    public double getDouble(final double key, final int programPoint) {

        return JSType.toNumberMaybeOptimistic(get(key), programPoint);

    }

    @Override

    public double getDouble(final long key, final int programPoint) {

        return JSType.toNumberMaybeOptimistic(get(key), programPoint);

    }

    @Override

    public double getDouble(final int key, final int programPoint) {

        return JSType.toNumberMaybeOptimistic(get(key), programPoint);

    }

    @Override

    public boolean has(final Object key) {

        final Object primitiveKey = JSType.toPrimitive(key, String.class);

        final int index = ArrayIndex.getArrayIndex(primitiveKey);

        return isValidStringIndex(index) || super.has(primitiveKey);

    }

    @Override

    public boolean has(final int key) {

        return isValidStringIndex(key) || super.has(key);

    }

    @Override

    public boolean has(final long key) {

        final int index = ArrayIndex.getArrayIndex(key);

        return isValidStringIndex(index) || super.has(key);

    }

    @Override

    public boolean has(final double key) {

        final int index = ArrayIndex.getArrayIndex(key);

        return isValidStringIndex(index) || super.has(key);

    }

    @Override

    public boolean hasOwnProperty(final Object key) {

        final Object primitiveKey = JSType.toPrimitive(key, String.class);

        final int index = ArrayIndex.getArrayIndex(primitiveKey);

        return isValidStringIndex(index) || super.hasOwnProperty(primitiveKey);

    }

    @Override

    public boolean hasOwnProperty(final int key) {

        return isValidStringIndex(key) || super.hasOwnProperty(key);

    }

    @Override

    public boolean hasOwnProperty(final long key) {

        final int index = ArrayIndex.getArrayIndex(key);

        return isValidStringIndex(index) || super.hasOwnProperty(key);

    }

    @Override

    public boolean hasOwnProperty(final double key) {

        final int index = ArrayIndex.getArrayIndex(key);

        return isValidStringIndex(index) || super.hasOwnProperty(key);

    }

    @Override

    public boolean delete(final int key, final boolean strict) {

        return checkDeleteIndex(key, strict)? false : super.delete(key, strict);

    }

    @Override

    public boolean delete(final long key, final boolean strict) {

        final int index = ArrayIndex.getArrayIndex(key);

        return checkDeleteIndex(index, strict)? false : super.delete(key, strict);

    }

    @Override

    public boolean delete(final double key, final boolean strict) {

        final int index = ArrayIndex.getArrayIndex(key);

        return checkDeleteIndex(index, strict)? false : super.delete(key, strict);

    }

    @Override

    public boolean delete(final Object key, final boolean strict) {

        final Object primitiveKey = JSType.toPrimitive(key, String.class);

        final int index = ArrayIndex.getArrayIndex(primitiveKey);

        return checkDeleteIndex(index, strict)? false : super.delete(primitiveKey, strict);

    }

    private boolean checkDeleteIndex(final int index, final boolean strict) {

        if (isValidStringIndex(index)) {

            if (strict) {

                throw typeError("cant.delete.property", Integer.toString(index), ScriptRuntime.safeToString(this));

            }

            return true;

        }

        return false;

    }

    @Override

    public Object getOwnPropertyDescriptor(final String key) {

        final int index = ArrayIndex.getArrayIndex(key);

        if (index >= 0 && index < value.length()) {

            final Global global = Global.instance();

            return global.newDataDescriptor(String.valueOf(value.charAt(index)), false, true, false);

        }

        return super.getOwnPropertyDescriptor(key);

    }

    /**

     * return a List of own keys associated with the object.

     * @param all True if to include non-enumerable keys.

     * @param nonEnumerable set of non-enumerable properties seen already.Used

     * to filter out shadowed, but enumerable properties from proto children.

     * @return Array of keys.

     */

    @Override

    protected String[] getOwnKeys(final boolean all, final Set<String> nonEnumerable) {

        final List<Object> keys = new ArrayList<>();

        // add string index keys

        for (int i = 0; i < value.length(); i++) {

            keys.add(JSType.toString(i));

        }

        // add super class properties

        keys.addAll(Arrays.asList(super.getOwnKeys(all, nonEnumerable)));

        return keys.toArray(new String[keys.size()]);

    }

    /**

     * ECMA 15.5.3 String.length

     * @param self self reference

     * @return     value of length property for string

     */

    @Getter(attributes = Attribute.NOT_ENUMERABLE | Attribute.NOT_WRITABLE | Attribute.NOT_CONFIGURABLE)

    public static Object length(final Object self) {

        return getCharSequence(self).length();

    }

    /**

     * ECMA 15.5.3.2 String.fromCharCode ( [ char0 [ , char1 [ , ... ] ] ] )

     * @param self  self reference

     * @param args  array of arguments to be interpreted as char

     * @return string with arguments translated to charcodes

     */

    @Function(attributes = Attribute.NOT_ENUMERABLE, arity = 1, where = Where.CONSTRUCTOR)

    public static String fromCharCode(final Object self, final Object... args) {

        final char[] buf = new char[args.length];

        int index = 0;

        for (final Object arg : args) {

            buf[index++] = (char)JSType.toUint16(arg);

        }

        return new String(buf);

    }

    /**

     * ECMA 15.5.3.2 - specialization for one char

     * @param self  self reference

     * @param value one argument to be interpreted as char

     * @return string with one charcode

     */

    @SpecializedFunction

    public static Object fromCharCode(final Object self, final Object value) {

        if (value instanceof Integer) {

            return fromCharCode(self, (int)value);

        }

        return Character.toString((char)JSType.toUint16(value));

    }

    /**

     * ECMA 15.5.3.2 - specialization for one char of int type

     * @param self  self reference

     * @param value one argument to be interpreted as char

     * @return string with one charcode

     */

    @SpecializedFunction

    public static String fromCharCode(final Object self, final int value) {

        return Character.toString((char)(value & 0xffff));

    }

    /**

     * ECMA 15.5.3.2 - specialization for two chars of int type

     * @param self  self reference

     * @param ch1 first char

     * @param ch2 second char

     * @return string with one charcode

     */

    @SpecializedFunction

    public static Object fromCharCode(final Object self, final int ch1, final int ch2) {

        return Character.toString((char)(ch1 & 0xffff)) + Character.toString((char)(ch2 & 0xffff));

    }

    /**

     * ECMA 15.5.3.2 - specialization for three chars of int type

     * @param self  self reference

     * @param ch1 first char

     * @param ch2 second char

     * @param ch3 third char

     * @return string with one charcode

     */

    @SpecializedFunction

    public static Object fromCharCode(final Object self, final int ch1, final int ch2, final int ch3) {

        return Character.toString((char)(ch1 & 0xffff)) + Character.toString((char)(ch2 & 0xffff)) + Character.toString((char)(ch3 & 0xffff));

    }

    /**

     * ECMA 15.5.3.2 - specialization for four chars of int type

     * @param self  self reference

     * @param ch1 first char

     * @param ch2 second char

     * @param ch3 third char

     * @param ch4 fourth char

     * @return string with one charcode

     */

    @SpecializedFunction

    public static String fromCharCode(final Object self, final int ch1, final int ch2, final int ch3, final int ch4) {

        return Character.toString((char)(ch1 & 0xffff)) + Character.toString((char)(ch2 & 0xffff)) + Character.toString((char)(ch3 & 0xffff)) + Character.toString((char)(ch4 & 0xffff));

    }

    /**

     * ECMA 15.5.3.2 - specialization for one char of double type

     * @param self  self reference

     * @param value one argument to be interpreted as char