/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package libcore.io;

import static android.annotation.SystemApi.Client.MODULE_LIBRARIES;

import android.compat.annotation.UnsupportedAppUsage;
import android.annotation.SystemApi;

import java.nio.ByteOrder;

import dalvik.annotation.optimization.FastNative;

import libcore.util.NonNull;

/**
 * Unsafe access to memory.
 *
 * @hide
 */
@SystemApi(client = MODULE_LIBRARIES)
public final class Memory {
    private Memory() { }

    /**
     * Used to optimize nio heap buffer bulk get operations. 'dst' must be a primitive array.
     * 'dstOffset' is measured in units of 'sizeofElements' bytes.
     *
     * @hide
     */
    public static native void unsafeBulkGet(Object dst, int dstOffset, int byteCount,
            byte[] src, int srcOffset, int sizeofElements, boolean swap);

    /**
     * Used to optimize nio heap buffer bulk put operations. 'src' must be a primitive array.
     * 'srcOffset' is measured in units of 'sizeofElements' bytes.
     * @hide
     */
    public static native void unsafeBulkPut(byte[] dst, int dstOffset, int byteCount,
            Object src, int srcOffset, int sizeofElements, boolean swap);

    /**
     * Gets int value from a byte buffer {@code src} at offset {@code offset} using
     * {@code order} byte order.
     *
     * @param src    source byte buffer
     * @param offset offset in {@code src} to get bytes from
     * @param order  byte order
     * @return int value
     *
     * @hide
     */
    @SystemApi(client = MODULE_LIBRARIES)
    public static int peekInt(@NonNull byte[] src, int offset, @NonNull ByteOrder order) {
        if (order == ByteOrder.BIG_ENDIAN) {
            return (((src[offset++] & 0xff) << 24) |
                    ((src[offset++] & 0xff) << 16) |
                    ((src[offset++] & 0xff) <<  8) |
                    ((src[offset  ] & 0xff) <<  0));
        } else {
            return (((src[offset++] & 0xff) <<  0) |
                    ((src[offset++] & 0xff) <<  8) |
                    ((src[offset++] & 0xff) << 16) |
                    ((src[offset  ] & 0xff) << 24));
        }
    }

    /**
     * @hide
     */
    public static long peekLong(byte[] src, int offset, ByteOrder order) {
        if (order == ByteOrder.BIG_ENDIAN) {
            int h = ((src[offset++] & 0xff) << 24) |
                    ((src[offset++] & 0xff) << 16) |
                    ((src[offset++] & 0xff) <<  8) |
                    ((src[offset++] & 0xff) <<  0);
            int l = ((src[offset++] & 0xff) << 24) |
                    ((src[offset++] & 0xff) << 16) |
                    ((src[offset++] & 0xff) <<  8) |
                    ((src[offset  ] & 0xff) <<  0);
            return (((long) h) << 32L) | ((long) l) & 0xffffffffL;
        } else {
            int l = ((src[offset++] & 0xff) <<  0) |
                    ((src[offset++] & 0xff) <<  8) |
                    ((src[offset++] & 0xff) << 16) |
                    ((src[offset++] & 0xff) << 24);
            int h = ((src[offset++] & 0xff) <<  0) |
                    ((src[offset++] & 0xff) <<  8) |
                    ((src[offset++] & 0xff) << 16) |
                    ((src[offset  ] & 0xff) << 24);
            return (((long) h) << 32L) | ((long) l) & 0xffffffffL;
        }
    }

    /**
     * Gets short value from a byte buffer {@code src} at offset {@code offset} using
     * {@code order} byte order.
     *
     * @param src    source byte buffer
     * @param offset offset in {@code src} to get bytes from
     * @param order  byte order
     * @return short value
     *
     * @hide
     */
    @SystemApi(client = MODULE_LIBRARIES)
    public static short peekShort(@NonNull byte[] src, int offset, @NonNull ByteOrder order) {
        if (order == ByteOrder.BIG_ENDIAN) {
            return (short) ((src[offset] << 8) | (src[offset + 1] & 0xff));
        } else {
            return (short) ((src[offset + 1] << 8) | (src[offset] & 0xff));
        }
    }

    /**
     * Writes given int value {@code value} to a byte buffer {@code dst} using
     * {@code order} byte order.
     *
     * @param dst    byte buffer where to write {@code value}
     * @param offset offset in {@code dst} to put value to
     * @param value  int value to write
     * @param order  byte order
     *
     * @hide
     */
    @SystemApi(client = MODULE_LIBRARIES)
    public static void pokeInt(@NonNull byte[] dst, int offset, int value, @NonNull ByteOrder order) {
        if (order == ByteOrder.BIG_ENDIAN) {
            dst[offset++] = (byte) ((value >> 24) & 0xff);
            dst[offset++] = (byte) ((value >> 16) & 0xff);
            dst[offset++] = (byte) ((value >>  8) & 0xff);
            dst[offset  ] = (byte) ((value >>  0) & 0xff);
        } else {
            dst[offset++] = (byte) ((value >>  0) & 0xff);
            dst[offset++] = (byte) ((value >>  8) & 0xff);
            dst[offset++] = (byte) ((value >> 16) & 0xff);
            dst[offset  ] = (byte) ((value >> 24) & 0xff);
        }
    }

    /**
     * Writes given long value {@code value} to a byte buffer {@code dst} using
     * {@code order} byte order.
     *
     * @param dst    byte buffer where to write {@code value}
     * @param offset offset in {@code dst} to put value to
     * @param value  long value to write
     * @param order  byte order
     *
     * @hide
     */
    @SystemApi(client = MODULE_LIBRARIES)
    public static void pokeLong(@NonNull byte[] dst, int offset, long value, @NonNull ByteOrder order) {
        if (order == ByteOrder.BIG_ENDIAN) {
            int i = (int) (value >> 32);
            dst[offset++] = (byte) ((i >> 24) & 0xff);
            dst[offset++] = (byte) ((i >> 16) & 0xff);
            dst[offset++] = (byte) ((i >>  8) & 0xff);
            dst[offset++] = (byte) ((i >>  0) & 0xff);
            i = (int) value;
            dst[offset++] = (byte) ((i >> 24) & 0xff);
            dst[offset++] = (byte) ((i >> 16) & 0xff);
            dst[offset++] = (byte) ((i >>  8) & 0xff);
            dst[offset  ] = (byte) ((i >>  0) & 0xff);
        } else {
            int i = (int) value;
            dst[offset++] = (byte) ((i >>  0) & 0xff);
            dst[offset++] = (byte) ((i >>  8) & 0xff);
            dst[offset++] = (byte) ((i >> 16) & 0xff);
            dst[offset++] = (byte) ((i >> 24) & 0xff);
            i = (int) (value >> 32);
            dst[offset++] = (byte) ((i >>  0) & 0xff);
            dst[offset++] = (byte) ((i >>  8) & 0xff);
            dst[offset++] = (byte) ((i >> 16) & 0xff);
            dst[offset  ] = (byte) ((i >> 24) & 0xff);
        }
    }

    /**
     * Writes given short value {@code value} to a byte buffer {@code dst} using
     * {@code order} byte order.
     *
     * @param dst    byte buffer where to write {@code value}
     * @param offset offset in {@code dst} to put value to
     * @param value  short value to write
     * @param order  byte order
     *
     * @hide
     */
    @SystemApi(client = MODULE_LIBRARIES)
    public static void pokeShort(@NonNull byte[] dst, int offset, short value, @NonNull ByteOrder order) {
        if (order == ByteOrder.BIG_ENDIAN) {
            dst[offset++] = (byte) ((value >> 8) & 0xff);
            dst[offset  ] = (byte) ((value >> 0) & 0xff);
        } else {
            dst[offset++] = (byte) ((value >> 0) & 0xff);
            dst[offset  ] = (byte) ((value >> 8) & 0xff);
        }
    }

    /**
     * Copies {@code byteCount} bytes from the source {@code srcObject} to the
     * destination {@code dstObject}. The objects are either instances of
     * {@code DirectByteBuffer} or {@code byte[]}. The offsets in the {@code byte[]}
     * case must include the {@link Buffer#arrayOffset()} if the array came from a
     * {@link Buffer#array()} call.
     *
     * <p>We could make this private and provide the four type-safe variants, but then
     * {@link ByteBuffer#put(ByteBuffer)} would need to work out which to call based on
     * whether the source and destination buffers are direct or not.
     *
     * @param dstObject destination buffer
     * @param dstOffset offset in the destination buffer
     * @param srcObject source buffer
     * @param srcOffset offset in the source buffer
     * @param byteCount number of bytes to copy
     *
     * @hide make type-safe before making public?
     */
    @SystemApi(client = MODULE_LIBRARIES)
    public static native void memmove(@NonNull Object dstObject, int dstOffset, @NonNull Object srcObject, int srcOffset, long byteCount);

    /**
     * @hide
     */
    @UnsupportedAppUsage
    @FastNative
    public static native byte peekByte(long address);

    /**
     * @hide
     */
    @UnsupportedAppUsage
    public static int peekInt(long address, boolean swap) {
        int result = peekIntNative(address);
        if (swap) {
            result = Integer.reverseBytes(result);
        }
        return result;
    }
    @FastNative
    private static native int peekIntNative(long address);

    /**
     * @hide
     */
    @UnsupportedAppUsage
    public static long peekLong(long address, boolean swap) {
        long result = peekLongNative(address);
        if (swap) {
            result = Long.reverseBytes(result);
        }
        return result;
    }
    @FastNative
    private static native long peekLongNative(long address);

    /**
     * @hide
     */
    public static short peekShort(long address, boolean swap) {
        short result = peekShortNative(address);
        if (swap) {
            result = Short.reverseBytes(result);
        }
        return result;
    }
    @FastNative
    private static native short peekShortNative(long address);

    /**
     * @hide
     */
    @UnsupportedAppUsage
    @FastNative
    public static native void peekByteArray(long address, byte[] dst, int dstOffset, int byteCount);

    /**
     * @hide
     */
    @FastNative
    public static native void peekCharArray(long address, char[] dst, int dstOffset, int charCount, boolean swap);

    /**
     * @hide
     */
    @FastNative
    public static native void peekDoubleArray(long address, double[] dst, int dstOffset, int doubleCount, boolean swap);

    /**
     * @hide
     */
    @FastNative
    public static native void peekFloatArray(long address, float[] dst, int dstOffset, int floatCount, boolean swap);

    /**
     * @hide
     */
    @FastNative
    public static native void peekIntArray(long address, int[] dst, int dstOffset, int intCount, boolean swap);

    /**
     * @hide
     */
    @FastNative
    public static native void peekLongArray(long address, long[] dst, int dstOffset, int longCount, boolean swap);

    /**
     * @hide
     */
    @FastNative
    public static native void peekShortArray(long address, short[] dst, int dstOffset, int shortCount, boolean swap);

    /**
     * @hide
     */
    @UnsupportedAppUsage
    @FastNative
    public static native void pokeByte(long address, byte value);

    /**
     * @hide
     */
    @UnsupportedAppUsage
    public static void pokeInt(long address, int value, boolean swap) {
        if (swap) {
            value = Integer.reverseBytes(value);
        }
        pokeIntNative(address, value);
    }
    @FastNative
    private static native void pokeIntNative(long address, int value);

    /**
     * @hide
     */
    @UnsupportedAppUsage
    public static void pokeLong(long address, long value, boolean swap) {
        if (swap) {
            value = Long.reverseBytes(value);
        }
        pokeLongNative(address, value);
    }
    @FastNative
    private static native void pokeLongNative(long address, long value);

    /**
     * @hide
     */
    public static void pokeShort(long address, short value, boolean swap) {
        if (swap) {
            value = Short.reverseBytes(value);
        }
        pokeShortNative(address, value);
    }
    @FastNative
    private static native void pokeShortNative(long address, short value);

    /**
     * @hide
     */
    @UnsupportedAppUsage
    public static native void pokeByteArray(long address, byte[] src, int offset, int count);

    /**
     * @hide
     */
    public static native void pokeCharArray(long address, char[] src, int offset, int count, boolean swap);

    /**
     * @hide
     */
    public static native void pokeDoubleArray(long address, double[] src, int offset, int count, boolean swap);

    /**
     * @hide
     */
    public static native void pokeFloatArray(long address, float[] src, int offset, int count, boolean swap);

    /**
     * @hide
     */
    public static native void pokeIntArray(long address, int[] src, int offset, int count, boolean swap);

    /**
     * @hide
     */
    public static native void pokeLongArray(long address, long[] src, int offset, int count, boolean swap);

    /**
     * @hide
     */
    public static native void pokeShortArray(long address, short[] src, int offset, int count, boolean swap);
}
