/*

 * 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 static jdk.nashorn.internal.runtime.arrays.ArrayIndex.getArrayIndexNoThrow;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.text.Collator;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.LinkedList;

import java.util.List;

import jdk.internal.dynalink.CallSiteDescriptor;

import jdk.internal.dynalink.linker.GuardedInvocation;

import jdk.internal.dynalink.linker.LinkRequest;

import jdk.nashorn.internal.lookup.MethodHandleFactory;

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.SpecializedConstructor;

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

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

import jdk.nashorn.internal.runtime.ConsString;

import jdk.nashorn.internal.runtime.JSType;

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 {

    private final CharSequence value;

    static final MethodHandle WRAPFILTER = findWrapFilter();

    NativeString(final CharSequence value) {

        this(value, Global.instance().getStringPrototype());

    }

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

        assert value instanceof String || value instanceof ConsString;

        this.value = value;

        this.setProto(proto);

    }

    @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();

        if (returnType == Object.class && (self instanceof String || self instanceof ConsString)) {

            try {

                MethodHandle mh = MethodHandles.lookup().findStatic(NativeString.class, "get", desc.getMethodType());

                return new GuardedInvocation(mh, NashornGuards.getInstanceOf2Guard(String.class, ConsString.class));

            } catch (final NoSuchMethodException | IllegalAccessException e) {

                // 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 int index = getArrayIndexNoThrow(key);

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

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

        }

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

    }

    @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 int index = getArrayIndexNoThrow(key);

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

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

        }

        return super.get(key);

    }

    @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) {

        return JSType.toInt32(get(key));

    }

    @Override

    public int getInt(final double key) {

        return JSType.toInt32(get(key));

    }

    @Override

    public int getInt(final long key) {

        return JSType.toInt32(get(key));

    }

    @Override

    public int getInt(final int key) {

        return JSType.toInt32(get(key));

    }

    @Override

    public long getLong(final Object key) {

        return JSType.toUint32(get(key));

    }

    @Override

    public long getLong(final double key) {

        return JSType.toUint32(get(key));

    }

    @Override

    public long getLong(final long key) {

        return JSType.toUint32(get(key));

    }

    @Override

    public long getLong(final int key) {

        return JSType.toUint32(get(key));

    }

    @Override

    public double getDouble(final Object key) {

        return JSType.toNumber(get(key));

    }

    @Override

    public double getDouble(final double key) {

        return JSType.toNumber(get(key));

    }

    @Override

    public double getDouble(final long key) {

        return JSType.toNumber(get(key));

    }

    @Override

    public double getDouble(final int key) {

        return JSType.toNumber(get(key));

    }

    @Override

    public boolean has(final Object key) {

        final int index = getArrayIndexNoThrow(key);

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

    }

    @Override

    public boolean has(final int key) {

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

    }

    @Override

    public boolean has(final long key) {

        final int index = getArrayIndexNoThrow(key);

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

    }

    @Override

    public boolean has(final double key) {

        final int index = getArrayIndexNoThrow(key);

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

    }

    @Override

    public boolean hasOwnProperty(final Object key) {

        final int index = getArrayIndexNoThrow(key);

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

    }

    @Override

    public boolean hasOwnProperty(final int key) {

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

    }

    @Override

    public boolean hasOwnProperty(final long key) {

        final int index = getArrayIndexNoThrow(key);

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

    }

    @Override

    public boolean hasOwnProperty(final double key) {

        final int index = getArrayIndexNoThrow(key);

        return isValid(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 = getArrayIndexNoThrow(key);

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

    }

    @Override

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

        final int index = getArrayIndexNoThrow(key);

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

    }

    @Override

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

        final int index = getArrayIndexNoThrow(key);

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

    }

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

        if (isValid(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.getArrayIndexNoThrow(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.

     * @return Array of keys.

     */

    @Override

    public String[] getOwnKeys(final boolean all) {

        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)));

        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 Object 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) {

        try {

            return "" + (char)JSType.toUint16(((Number)value).doubleValue());

        } catch (final ClassCastException e) {

            return fromCharCode(self, new Object[] { 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 Object fromCharCode(final Object self, final int value) {

        return "" + (char)(value & 0xffff);

    }

    /**

     * ECMA 15.5.3.2 - specialization for one char of long type

     * @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 long value) {

        return "" + (char)((int)value & 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

     * @return string with one charcode

     */

    @SpecializedFunction

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

        return "" + (char)JSType.toUint16(value);

    }

    /**

     * ECMA 15.5.4.2 String.prototype.toString ( )

     * @param self self reference

     * @return self as string

     */

    @Function(attributes = Attribute.NOT_ENUMERABLE)

    public static Object toString(final Object self) {

        return getString(self);

    }

    /**

     * ECMA 15.5.4.3 String.prototype.valueOf ( )

     * @param self self reference

     * @return self as string

     */

    @Function(attributes = Attribute.NOT_ENUMERABLE)

    public static Object valueOf(final Object self) {

        return getString(self);

    }

    /**

     * ECMA 15.5.4.4 String.prototype.charAt (pos)

     * @param self self reference

     * @param pos  position in string

     * @return string representing the char at the given position

     */

    @Function(attributes = Attribute.NOT_ENUMERABLE)

    public static Object charAt(final Object self, final Object pos) {

        return charAt(self, JSType.toInteger(pos));

    }

    /**

     * ECMA 15.5.4.4 String.prototype.charAt (pos) - specialized version for double position

     * @param self self reference

     * @param pos  position in string

     * @return string representing the char at the given position

     */

    @SpecializedFunction

    public static String charAt(final Object self, final double pos) {

        return charAt(self, (int)pos);

    }

    /**

     * ECMA 15.5.4.4 String.prototype.charAt (pos) - specialized version for int position

     * @param self self reference

     * @param pos  position in string

     * @return string representing the char at the given position

     */

    @SpecializedFunction

    public static String charAt(final Object self, final int pos) {

        final String str = checkObjectToString(self);

        return (pos < 0 || pos >= str.length()) ? "" : String.valueOf(str.charAt(pos));

    }