/*
 * Copyright 2017 Google Inc.
 *
 * Licensed 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 java.lang.reflect;

import static javaemul.internal.InternalPreconditions.checkArgument;
import static javaemul.internal.InternalPreconditions.checkNotNull;

import javaemul.internal.ArrayHelper;

/**
 * See <a
 * href="http://java.sun.com/javase/6/docs/api/java/lang/reflect/Array.html">the
 * official Java API doc</a> for details.
 */
public final class Array {

  public static Object get(Object array, int index) {
    if (array instanceof boolean[]) {
      return getBooleanImpl(array, index);
    } else if (array instanceof byte[]) {
      return getByteImpl(array, index);
    } else if (array instanceof char[]) {
      return getCharImpl(array, index);
    } else if (array instanceof double[]) {
      return getDoubleImpl(array, index);
    } else if (array instanceof float[]) {
      return getFloatImpl(array, index);
    } else if (array instanceof int[]) {
      return getIntImpl(array, index);
    } else if (array instanceof long[]) {
      return getLongImpl(array, index);
    } else if (array instanceof short[]) {
      return getShortImpl(array, index);
    } else  {
      checkArgument(array instanceof Object[]);
      Object[] typedArray = (Object[]) array;
      return typedArray[index];
    }
  }

  public static boolean getBoolean(Object array, int index) {
    checkArgument(array instanceof boolean[]);
    return getBooleanImpl(array, index);
  }

  private static boolean getBooleanImpl(Object array, int index) {
    boolean[] typedArray = (boolean[]) array;
    return typedArray[index];
  }

  public static byte getByte(Object array, int index) {
    checkArgument(array instanceof byte[]);
    return getByteImpl(array, index);
  }

  private static byte getByteImpl(Object array, int index) {
    byte[] typedArray = (byte[]) array;
    return typedArray[index];
  }

  public static char getChar(Object array, int index) {
    checkArgument(array instanceof char[]);
    return getCharImpl(array, index);
  }

  private static char getCharImpl(Object array, int index) {
    char[] typedArray = (char[]) array;
    return typedArray[index];
  }

  public static double getDouble(Object array, int index) {
    if (array instanceof double[]) {
      return getDoubleImpl(array, index);
    } else if (array instanceof byte[]) {
      return getByteImpl(array, index);
    } else if (array instanceof char[]) {
      return getCharImpl(array, index);
    } else if (array instanceof float[]) {
      return getFloatImpl(array, index);
    } else if (array instanceof int[]) {
      return getIntImpl(array, index);
    } else if (array instanceof long[]) {
      return getLongImpl(array, index);
    } else if (array instanceof short[]) {
      return getShortImpl(array, index);
    } else {
      checkArgument(false);
      return 0;
    }
  }

  private static double getDoubleImpl(Object array, int index) {
    double[] typedArray = (double[]) array;
    return typedArray[index];
  }

  public static float getFloat(Object array, int index) {
    if (array instanceof float[]) {
      return getFloatImpl(array, index);
    } else if (array instanceof byte[]) {
      return getByteImpl(array, index);
    } else if (array instanceof char[]) {
      return getCharImpl(array, index);
    } else if (array instanceof int[]) {
      return getIntImpl(array, index);
    } else if (array instanceof long[]) {
      return getLongImpl(array, index);
    } else if (array instanceof short[]) {
      return getShortImpl(array, index);
    } else {
      checkArgument(false);
      return 0;
    }
  }

  private static float getFloatImpl(Object array, int index) {
    float[] typedArray = (float[]) array;
    return typedArray[index];
  }

  public static int getInt(Object array, int index) {
    if (array instanceof int[]) {
      return getIntImpl(array, index);
    } else if (array instanceof byte[]) {
      return getByteImpl(array, index);
    } else if (array instanceof char[]) {
      return getCharImpl(array, index);
    } else if (array instanceof short[]) {
      return getShortImpl(array, index);
    } else {
      checkArgument(false);
      return 0;
    }
  }

  private static int getIntImpl(Object array, int index) {
    int[] typedArray = (int[]) array;
    return typedArray[index];
  }

  public static int getLength(Object array) {
    checkNotNull(array);
    return ArrayHelper.getLength(array);
  }

  public static long getLong(Object array, int index) {
    if (array instanceof long[]) {
      return getLongImpl(array, index);
    } else if (array instanceof byte[]) {
      return getByteImpl(array, index);
    } else if (array instanceof char[]) {
      return getCharImpl(array, index);
    } else if (array instanceof int[]) {
      return getIntImpl(array, index);
    } else if (array instanceof short[]) {
      return getShortImpl(array, index);
    } else {
      checkArgument(false);
      return 0;
    }
  }

  private static long getLongImpl(Object array, int index) {
    long[] typedArray = (long[]) array;
    return typedArray[index];
  }

  public static short getShort(Object array, int index) {
    if (array instanceof short[]) {
      return getShortImpl(array, index);
    } else if (array instanceof byte[]) {
      return getByteImpl(array, index);
    } else {
      checkArgument(false);
      return 0;
    }
  }

  private static short getShortImpl(Object array, int index) {
    short[] typedArray = (short[]) array;
    return typedArray[index];
  }

  public static void set(Object array, int index, Object value) {
    if (array instanceof Object[]) {
      Object[] typedArray = (Object[]) array;
      typedArray[index] = value;
    } else {
      if (value instanceof Boolean) {
        setBoolean(array, index, ((Boolean) value).booleanValue());
      } else if (value instanceof Byte) {
        setByte(array, index, ((Byte) value).byteValue());
      } else if (value instanceof Character) {
        setChar(array, index, ((Character) value).charValue());
      } else if (value instanceof Short) {
        setShort(array, index, ((Short) value).shortValue());
      } else if (value instanceof Integer) {
        setInt(array, index, ((Integer) value).intValue());
      } else if (value instanceof Long) {
        setLong(array, index, ((Long) value).longValue());
      } else if (value instanceof Float) {
        setFloat(array, index, ((Float) value).floatValue());
      } else if (value instanceof Double) {
        setDouble(array, index, ((Double) value).doubleValue());
      } else {
        checkArgument(false);
      }
    }
  }

  public static void setBoolean(Object array, int index, boolean value) {
    checkArgument(array instanceof boolean[]);
    setBooleanImpl(array, index, value);
  }

  private static void setBooleanImpl(Object array, int index, boolean value) {
    boolean[] typedArray = (boolean[]) array;
    typedArray[index] = value;
  }

  public static void setByte(Object array, int index, byte value) {
    if (array instanceof byte[]) {
      setByteImpl(array, index, value);
    } else if (array instanceof double[]) {
      setDoubleImpl(array, index, value);
    } else if (array instanceof float[]) {
      setFloatImpl(array, index, value);
    } else if (array instanceof int[]) {
      setIntImpl(array, index, value);
    } else if (array instanceof long[]) {
      setLongImpl(array, index, value);
    } else if (array instanceof short[]) {
      setShortImpl(array, index, value);
    } else {
      checkArgument(false);
    }
  }

  private static void setByteImpl(Object array, int index, byte value) {
    byte[] typedArray = (byte[]) array;
    typedArray[index] = value;
  }

  public static void setChar(Object array, int index, char value) {
    if (array instanceof char[]) {
      setCharImpl(array, index, value);
    } else if (array instanceof double[]) {
      setDoubleImpl(array, index, value);
    } else if (array instanceof float[]) {
      setFloatImpl(array, index, value);
    } else if (array instanceof int[]) {
      setIntImpl(array, index, value);
    } else if (array instanceof long[]) {
      setLongImpl(array, index, value);
    } else {
      checkArgument(false);
    }
  }

  private static void setCharImpl(Object array, int index, char value) {
    char[] typedArray = (char[]) array;
    typedArray[index] = value;
  }

  public static void setDouble(Object array, int index, double value) {
    checkArgument(array instanceof double[]);
    setDoubleImpl(array, index, value);
  }

  private static void setDoubleImpl(Object array,int index, double value) {
    double[] typedArray = (double[]) array;
    typedArray[index] = value;
  }

  public static void setFloat(Object array, int index, float value) {
    if (array instanceof float[]) {
      setFloatImpl(array, index, value);
    } else if (array instanceof double[]) {
      setDoubleImpl(array, index, value);
    } else {
      checkArgument(false);
    }
  }

  private static void setFloatImpl(Object array, int index, float value) {
    float[] typedArray = (float[]) array;
    typedArray[index] = value;
  }

  public static void setInt(Object array, int index, int value) {
    if (array instanceof int[]) {
      setIntImpl(array, index, value);
    } else if (array instanceof double[]) {
      setDoubleImpl(array, index, value);
    } else if (array instanceof float[]) {
      setFloatImpl(array, index, value);
    } else if (array instanceof long[]) {
      setLongImpl(array, index, value);
    } else {
      checkArgument(false);
    }
  }

  private static void setIntImpl(Object array, int index, int value) {
    int[] typedArray = (int[]) array;
    typedArray[index] = value;
  }

  public static void setLong(Object array, int index, long value) {
    if (array instanceof long[]) {
      setLongImpl(array, index, value);
    } else if (array instanceof double[]) {
      setDoubleImpl(array, index, value);
    } else if (array instanceof float[]) {
      setFloatImpl(array, index, value);
    } else {
      checkArgument(false);
    }
  }

  private static void setLongImpl(Object array, int index, long value) {
    long[] typedArray = (long[]) array;
    typedArray[index] = value;
  }

  public static void setShort(Object array, int index, short value) {
    if (array instanceof short[]) {
      setShortImpl(array, index, value);
    } else if (array instanceof double[]) {
      setDoubleImpl(array, index, value);
    } else if (array instanceof float[]) {
      setFloatImpl(array, index, value);
    } else if (array instanceof int[]) {
      setIntImpl(array, index, value);
    } else if (array instanceof long[]) {
      setLongImpl(array, index, value);
    } else {
      checkArgument(false);
    }
  }

  private static void setShortImpl(Object array, int index, short value) {
    short[] typedArray = (short[]) array;
    typedArray[index] = value;
  }

  // There is a good reason to not implement the generic newInstance methods:
  //
  // In GWT we would need access from a class literal to the castable type map, which
  // could be done, but would require some serious work.
  // But it would also mean that we can not compute all Array types being instantiated anymore and
  // thus would have to retain more castable type information (bloat).
  //
  // In J2CL the problem is slightly different. Most checking is deferred to runtime in J2CL and
  // we retain constructor functions of leaf types. To ensure that we are not just retaining
  // all constructors in a program we make sure that access to these always gets inlined with
  // array creation. By allowing a generic method we would not be able to ensure this anymore
  // and might cause serious bloat in a program.
  // A middle ground for J2CL could be to treat this method special in the compiler and fail the
  // compile if its not called with a compile time constant for the class literal.

  // Not implemented:
  // public static Object newInstance(Class<?> componentType, int... dimensions)
  // public static Object newInstance(Class<?> componentType, int length)

  private Array() {
  }
}