/*

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

 *

 * 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.vm.ci.hotspot;

import java.util.Objects;

import jdk.vm.ci.common.JVMCIError;

import jdk.vm.ci.meta.Constant;

import jdk.vm.ci.meta.ConstantReflectionProvider;

import jdk.vm.ci.meta.JavaConstant;

import jdk.vm.ci.meta.JavaKind;

import jdk.vm.ci.meta.MemoryAccessProvider;

import jdk.vm.ci.meta.MethodHandleAccessProvider;

import jdk.vm.ci.meta.ResolvedJavaField;

import jdk.vm.ci.meta.ResolvedJavaType;

/**

 * HotSpot implementation of {@link ConstantReflectionProvider}.

 */

public class HotSpotConstantReflectionProvider implements ConstantReflectionProvider {

    protected final HotSpotJVMCIRuntime runtime;

    protected final HotSpotMethodHandleAccessProvider methodHandleAccess;

    private final HotSpotMemoryAccessProviderImpl memoryAccess;

    public HotSpotConstantReflectionProvider(HotSpotJVMCIRuntime runtime) {

        this.runtime = runtime;

        this.methodHandleAccess = new HotSpotMethodHandleAccessProvider(this);

        this.memoryAccess = new HotSpotMemoryAccessProviderImpl(runtime);

    }

    @Override

    public MethodHandleAccessProvider getMethodHandleAccess() {

        return methodHandleAccess;

    }

    @Override

    public MemoryAccessProvider getMemoryAccessProvider() {

        return memoryAccess;

    }

    @Override

    public Boolean constantEquals(Constant x, Constant y) {

        if (x == y) {

            return true;

        } else if (x instanceof HotSpotObjectConstantImpl) {

        } else {

            return Objects.equals(x, y);

        }

    }

    @Override

    public Integer readArrayLength(JavaConstant array) {

        if (array == null || array.getJavaKind() != JavaKind.Object || array.isNull()) {

            return null;

        }

    }

    @Override

    public JavaConstant readArrayElement(JavaConstant array, int index) {

        if (array == null || array.getJavaKind() != JavaKind.Object || array.isNull()) {

            return null;

        }

    }

    /**

     * Check if the constant is a boxed value that is guaranteed to be cached by the platform.

     * Otherwise the generated code might be the only reference to the boxed value and since object

     * references from nmethods are weak this can cause GC problems.

     *

     * @return true if the box is cached

     */

    private static boolean isBoxCached(JavaConstant source) {

        switch (source.getJavaKind()) {

            case Boolean:

                return true;

            case Char:

                return source.asInt() <= 127;

            case Byte:

            case Short:

            case Int:

                return source.asInt() >= -128 && source.asInt() <= 127;

            case Long:

                return source.asLong() >= -128 && source.asLong() <= 127;

            case Float:

            case Double:

                return false;

            default:

                throw new IllegalArgumentException("unexpected kind " + source.getJavaKind());

        }

    }

    @Override

    public JavaConstant boxPrimitive(JavaConstant source) {

        if (source == null || !source.getJavaKind().isPrimitive() || !isBoxCached(source)) {

            return null;

        }

    }

    @Override

    public JavaConstant unboxPrimitive(JavaConstant source) {

        if (source == null || !source.getJavaKind().isObject()) {

            return null;

        }

        if (source.isNull()) {

            return null;

        }

    }

    @Override

    public JavaConstant forString(String value) {

    }

    public JavaConstant forObject(Object value) {

    }

    @Override

    public ResolvedJavaType asJavaType(Constant constant) {

        }

        if (constant instanceof HotSpotMetaspaceConstant) {

            if (obj instanceof HotSpotResolvedObjectTypeImpl) {

                return (ResolvedJavaType) obj;

            }

        }

        return null;

    }

    @Override

    public JavaConstant readFieldValue(ResolvedJavaField field, JavaConstant receiver) {

        HotSpotResolvedJavaField hotspotField = (HotSpotResolvedJavaField) field;

        if (hotspotField.isStatic()) {

            if (holder.isInitialized()) {

            }

        } else {

                if (hotspotField.isInObject(receiver)) {

                }

            }

        }

        return null;

    }

    @Override

    public JavaConstant asJavaClass(ResolvedJavaType type) {

    }

    @Override

    public Constant asObjectHub(ResolvedJavaType type) {

        if (type instanceof HotSpotResolvedObjectType) {

            return ((HotSpotResolvedObjectType) type).klass();

        } else {

            throw JVMCIError.unimplemented();

        }

    }

}