/*
 * Decompiled with CFR 0.152.
 */
package com.tridium.util;

import java.lang.reflect.Array;
import java.util.ArrayList;

public class ArrayUtil {
    public static int indexOf(Object[] objectArray, Object object) {
        int n = 0;
        while (n < objectArray.length) {
            if (objectArray[n] == object) {
                return n;
            }
            ++n;
        }
        return -1;
    }

    public static Object[] grow(Object[] objectArray, int n) {
        if (objectArray.length < n) {
            Class<?> clazz = objectArray.getClass().getComponentType();
            int n2 = Math.max(objectArray.length * 2, n);
            Object[] objectArray2 = (Object[])Array.newInstance(clazz, n2);
            System.arraycopy(objectArray, 0, objectArray2, 0, objectArray.length);
            objectArray = objectArray2;
        }
        return objectArray;
    }

    public static Object[] put(Object[] objectArray, int n, Object object) {
        objectArray = ArrayUtil.grow(objectArray, n + 1);
        objectArray[n] = object;
        return objectArray;
    }

    public static boolean remove(Object[] objectArray, int n, Object object) {
        int n2 = 0;
        while (n2 < n) {
            if (objectArray[n2] == object) {
                if (n2 < objectArray.length) {
                    System.arraycopy(objectArray, n2 + 1, objectArray, n2, objectArray.length - n2 - 1);
                }
                objectArray[n - 1] = null;
                return true;
            }
            ++n2;
        }
        return false;
    }

    public static Object[] addOne(Object[] objectArray, Object object) {
        Class<?> clazz = objectArray.getClass().getComponentType();
        Object[] objectArray2 = (Object[])Array.newInstance(clazz, objectArray.length + 1);
        System.arraycopy(objectArray, 0, objectArray2, 0, objectArray.length);
        objectArray2[objectArray.length] = object;
        return objectArray2;
    }

    public static Object[] removeOne(Object[] objectArray, Object object) {
        int n = objectArray.length;
        int n2 = 0;
        while (n2 < n) {
            if (objectArray[n2] == object) {
                return ArrayUtil.removeOne(objectArray, n2);
            }
            ++n2;
        }
        throw new IllegalStateException();
    }

    public static Object[] removeOne(Object[] objectArray, int n) {
        Class<?> clazz = objectArray.getClass().getComponentType();
        Object[] objectArray2 = (Object[])Array.newInstance(clazz, objectArray.length - 1);
        System.arraycopy(objectArray, 0, objectArray2, 0, n);
        System.arraycopy(objectArray, n + 1, objectArray2, n, objectArray.length - n - 1);
        return objectArray2;
    }

    public static Object[] toTop(Object[] objectArray, int n) {
        ArrayList<Object> arrayList = new ArrayList<Object>();
        int n2 = 0;
        while (n2 < objectArray.length) {
            if (n2 != n) {
                arrayList.add(objectArray[n2]);
            }
            ++n2;
        }
        arrayList.add(0, objectArray[n]);
        return arrayList.toArray(objectArray);
    }

    public static Object[] toBottom(Object[] objectArray, int n) {
        ArrayList<Object> arrayList = new ArrayList<Object>();
        int n2 = 0;
        while (n2 < objectArray.length) {
            if (n2 != n) {
                arrayList.add(objectArray[n2]);
            }
            ++n2;
        }
        arrayList.add(objectArray[n]);
        return arrayList.toArray(objectArray);
    }

    public static int indexOf(int[] nArray, int n) {
        int n2 = 0;
        while (n2 < nArray.length) {
            if (nArray[n2] == n) {
                return n2;
            }
            ++n2;
        }
        return -1;
    }

    public static int[] grow(int[] nArray, int n) {
        if (nArray.length < n) {
            int n2 = Math.max(nArray.length * 2, n);
            int[] nArray2 = new int[n2];
            System.arraycopy(nArray, 0, nArray2, 0, nArray.length);
            nArray = nArray2;
        }
        return nArray;
    }

    public static int[] put(int[] nArray, int n, int n2) {
        nArray = ArrayUtil.grow(nArray, n + 1);
        nArray[n] = n2;
        return nArray;
    }

    public static boolean remove(int[] nArray, int n, int n2) {
        int n3 = 0;
        while (n3 < n) {
            if (nArray[n3] == n2) {
                if (n3 < nArray.length) {
                    System.arraycopy(nArray, n3 + 1, nArray, n3, nArray.length - n3 - 1);
                }
                nArray[n - 1] = -1;
                return true;
            }
            ++n3;
        }
        return false;
    }

    public static int[] addOne(int[] nArray, int n) {
        int[] nArray2 = new int[nArray.length + 1];
        System.arraycopy(nArray, 0, nArray2, 0, nArray.length);
        nArray2[nArray.length] = n;
        return nArray2;
    }

    public static int[] removeOne(int[] nArray, int n) {
        int[] nArray2 = new int[nArray.length - 1];
        int n2 = nArray.length;
        int n3 = 0;
        while (n3 < n2) {
            if (nArray[n3] == n) {
                System.arraycopy(nArray, 0, nArray2, 0, n3);
                System.arraycopy(nArray, n3 + 1, nArray2, n3, n2 - n3 - 1);
                return nArray2;
            }
            ++n3;
        }
        throw new IllegalStateException();
    }

    public static int[] removeOneIndex(int[] nArray, int n) {
        int[] nArray2 = new int[nArray.length - 1];
        System.arraycopy(nArray, 0, nArray2, 0, n);
        System.arraycopy(nArray, n + 1, nArray2, n, nArray.length - n - 1);
        return nArray2;
    }

    public static void sort(int[] nArray) {
        int n = nArray.length;
        int n2 = n / 2;
        while (n2 >= 1) {
            int n3 = n2;
            while (n3 < n) {
                int n4 = nArray[n3];
                int n5 = n3;
                while (n5 >= n2 && n4 < nArray[n5 - n2]) {
                    nArray[n5] = nArray[n5 - n2];
                    n5 -= n2;
                }
                nArray[n5] = n4;
                ++n3;
            }
            n2 /= 2;
        }
    }

    public static int binarySearch(int[] nArray, int n) {
        int n2 = nArray.length;
        int n3 = -1;
        int n4 = n2;
        while (n4 - n3 > 1) {
            int n5 = (n4 + n3) / 2;
            int n6 = nArray[n5];
            if (n6 > n) {
                n4 = n5;
                continue;
            }
            if (n6 < n) {
                n3 = n5;
                continue;
            }
            return n5;
        }
        return -1;
    }

    public static int[] orderCircular(int[] nArray, int n) {
        int n2 = nArray.length;
        int[] nArray2 = new int[n2];
        int n3 = n2 - n;
        int n4 = n;
        if (n3 > 0) {
            System.arraycopy(nArray, n, nArray2, 0, n3);
        }
        if (n4 > 0) {
            System.arraycopy(nArray, 0, nArray2, n3, n4);
        }
        return nArray2;
    }

    public static Object[] add(Object[] objectArray, Object[] objectArray2) {
        Class<?> clazz = objectArray.getClass().getComponentType();
        Object[] objectArray3 = (Object[])Array.newInstance(clazz, objectArray.length + objectArray2.length);
        System.arraycopy(objectArray, 0, objectArray3, 0, objectArray.length);
        System.arraycopy(objectArray2, 0, objectArray3, objectArray.length, objectArray2.length);
        return objectArray3;
    }

    public static String join(Object[] objectArray, String string) {
        if (objectArray == null || objectArray.length <= 0) {
            return "";
        }
        StringBuffer stringBuffer = new StringBuffer();
        int n = 0;
        while (n < objectArray.length) {
            if (n > 0) {
                stringBuffer.append(string);
            }
            stringBuffer.append(objectArray[n].toString());
            ++n;
        }
        return stringBuffer.toString();
    }
}