/*
    * 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
    *
    *      https://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 org.apache.commons.jexl3.internal;
  
  import java.lang.reflect.Array;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.IdentityHashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.jexl3.JexlArithmetic;
  import org.apache.commons.jexl3.internal.introspection.ClassMisc;
  
  /**
   * Helper class to create typed arrays.
   */
  public class ArrayBuilder implements JexlArithmetic.ArrayBuilder {
  
      /** The number of primitive types. */
      private static final int PRIMITIVE_SIZE = 8;
  
      /** The boxing types to primitive conversion map. */
      private static final Map<Class<?>, Class<?>> BOXING_CLASSES;
      static {
          BOXING_CLASSES = new IdentityHashMap<>(PRIMITIVE_SIZE);
          BOXING_CLASSES.put(Boolean.class, Boolean.TYPE);
          BOXING_CLASSES.put(Byte.class, Byte.TYPE);
          BOXING_CLASSES.put(Character.class, Character.TYPE);
          BOXING_CLASSES.put(Double.class, Double.TYPE);
          BOXING_CLASSES.put(Float.class, Float.TYPE);
          BOXING_CLASSES.put(Integer.class, Integer.TYPE);
          BOXING_CLASSES.put(Long.class, Long.TYPE);
          BOXING_CLASSES.put(Short.class, Short.TYPE);
      }
  
      /**
       * Gets the primitive type of given class (when it exists).
       *
       * @param parm a class
       * @return the primitive type or null it the argument is not unboxable
       */
      protected static Class<?> unboxingClass(final Class<?> parm) {
          return BOXING_CLASSES.getOrDefault(parm, parm);
      }
  
      /** The intended class array. */
      protected Class<?> commonClass;
  
      /** Whether the array stores numbers. */
      protected boolean isNumber = true;
  
      /** Whether we can try unboxing. */
      protected boolean unboxing = true;
  
      /** The untyped list of items being added. */
      protected final Object[] untyped;
  
      /** Number of added items. */
      protected int added;
  
      /** Extended? */
      protected final boolean extended;
  
      /**
       * Creates a new builder.
       *
       * @param size the exact array size
       */
      public ArrayBuilder(final int size) {
          this(size, false);
      }
  
      /**
       * Creates a new builder.
       *
       * @param size the exact array size
       * @param extended whether the array is extended
       */
      public ArrayBuilder(final int size, final boolean extended) {
          this.untyped = new Object[size];
          this.extended = extended;
      }
      @Override
      public void add(final Object value) {
         // for all children after first...
         if (!Object.class.equals(commonClass)) {
             if (value == null) {
                 isNumber = false;
                 unboxing = false;
             } else {
                 final Class<?> eclass = value.getClass();
                 // base common class on first non-null entry
                 if (commonClass == null) {
                     commonClass = eclass;
                     isNumber = isNumber && Number.class.isAssignableFrom(commonClass);
                 } else if (!commonClass.isAssignableFrom(eclass)) {
                     // if both are numbers...
                     if (isNumber && Number.class.isAssignableFrom(eclass)) {
                         commonClass = Number.class;
                     } else {
                         isNumber = false;
                         commonClass = getCommonSuperClass(commonClass, eclass);
                     }
                 }
             }
         }
         if (added >= untyped.length) {
             throw new IllegalArgumentException("add() over size");
         }
         untyped[added++] = value;
     }
 
     @Override
     public Object create(final boolean e) {
         if (untyped == null) {
             return new Object[0];
         }
         final int size = added;
         if (extended || e) {
             final List<Object> list = newList(commonClass, size);
             list.addAll(Arrays.asList(untyped).subList(0, size));
             return list;
         }
         // convert untyped array to the common class if not Object.class
         if (commonClass == null || Object.class.equals(commonClass)) {
             return untyped.clone();
         }
         // if the commonClass is a number, it has an equivalent primitive type, get it
         if (unboxing) {
             commonClass = unboxingClass(commonClass);
         }
         // allocate and fill up the typed array
         final Object typed = Array.newInstance(commonClass, size);
         for (int i = 0; i < size; ++i) {
             Array.set(typed, i, untyped[i]);
         }
         return typed;
     }
 
     /**
      * Computes the best super class/super interface.
      * <p>Used to try and maintain type safe arrays.</p>
      *
      * @param baseClass the baseClass
      * @param other another class
      * @return a common ancestor, class or interface, worst case being class Object
      */
     protected Class<?> getCommonSuperClass(final Class<?> baseClass, final Class<?> other) {
         return ClassMisc.getCommonSuperClass(baseClass, other);
     }
 
     /**
      * Creates a new list (aka extended array)/
      *
      * @param clazz the class
      * @param size the size
      * @return the instance
      * @param <T> the type
      */
     protected <T> List<T> newList(final Class<? extends T> clazz, final int size) {
         return new ArrayList<>(size);
     }
 }