/*
 * Copyright (C) 2022 The Android Open Source Project
 *
 * 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 android.uwb.util;

import android.annotation.NonNull;
import android.annotation.Nullable;
import android.compat.annotation.UnsupportedAppUsage;
import android.os.ParcelUuid;
import android.os.PersistableBundle;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.TreeSet;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/** @hide */
public class PersistableBundleUtils {
//    private static final String LIST_KEY_FORMAT = "LIST_ITEM_%d";
//    private static final String COLLECTION_SIZE_KEY = "COLLECTION_LENGTH";
//    private static final String MAP_KEY_FORMAT = "MAP_KEY_%d";
//    private static final String MAP_VALUE_FORMAT = "MAP_VALUE_%d";
//
//    private static final String PARCEL_UUID_KEY = "PARCEL_UUID";
//    private static final String BYTE_ARRAY_KEY = "BYTE_ARRAY_KEY";
//    private static final String INTEGER_KEY = "INTEGER_KEY";
//    private static final String STRING_KEY = "STRING_KEY";
//
//    private final static char[] HEX_DIGITS =
//            {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
//    private final static char[] HEX_LOWER_CASE_DIGITS =
//            {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};


//    /**
//     * Functional interface to convert an object of the specified type to a PersistableBundle.
//     *
//     * @param <T> the type of the source object
//     */
//    public interface Serializer<T> {
//        /**
//         * Converts this object to a PersistableBundle.
//         *
//         * @return the PersistableBundle representation of this object
//         */
//        PersistableBundle toPersistableBundle(T obj);
//    }
//
//    /**
//     * Functional interface used to create an object of the specified type from a PersistableBundle.
//     *
//     * @param <T> the type of the resultant object
//     */
//    public interface Deserializer<T> {
//        /**
//         * Creates an instance of specified type from a PersistableBundle representation.
//         *
//         * @param in the PersistableBundle representation
//         * @return an instance of the specified type
//         */
//        T fromPersistableBundle(PersistableBundle in);
//    }
//
//    /** Serializer to convert an integer to a PersistableBundle. */
//    public static final Serializer<Integer> INTEGER_SERIALIZER =
//            (i) -> {
//                final PersistableBundle result = new PersistableBundle();
//                result.putInt(INTEGER_KEY, i);
//                return result;
//            };
//
//    /** Deserializer to convert a PersistableBundle to an integer. */
//    public static final Deserializer<Integer> INTEGER_DESERIALIZER =
//            (bundle) -> {
//                Objects.requireNonNull(bundle, "PersistableBundle is null");
//                return bundle.getInt(INTEGER_KEY);
//            };
//
//    /** Serializer to convert s String to a PersistableBundle. */
//    public static final Serializer<String> STRING_SERIALIZER =
//            (i) -> {
//                final PersistableBundle result = new PersistableBundle();
//                result.putString(STRING_KEY, i);
//                return result;
//            };
//
//    /** Deserializer to convert a PersistableBundle to a String. */
//    public static final Deserializer<String> STRING_DESERIALIZER =
//            (bundle) -> {
//                Objects.requireNonNull(bundle, "PersistableBundle is null");
//                return bundle.getString(STRING_KEY);
//            };
//
//    /**
//     * Converts a ParcelUuid to a PersistableBundle.
//     *
//     * <p>To avoid key collisions, NO additional key/value pairs should be added to the returned
//     * PersistableBundle object.
//     *
//     * @param uuid a ParcelUuid instance to persist
//     * @return the PersistableBundle instance
//     */
//    public static PersistableBundle fromParcelUuid(ParcelUuid uuid) {
//        final PersistableBundle result = new PersistableBundle();
//
//        result.putString(PARCEL_UUID_KEY, uuid.toString());
//
//        return result;
//    }
//
//    /**
//     * Converts from a PersistableBundle to a ParcelUuid.
//     *
//     * @param bundle the PersistableBundle containing the ParcelUuid
//     * @return the ParcelUuid instance
//     */
//    public static ParcelUuid toParcelUuid(PersistableBundle bundle) {
//        return ParcelUuid.fromString(bundle.getString(PARCEL_UUID_KEY));
//    }
//
//    /**
//     * Converts from a list of Persistable objects to a single PersistableBundle.
//     *
//     * <p>To avoid key collisions, NO additional key/value pairs should be added to the returned
//     * PersistableBundle object.
//     *
//     * @param <T>        the type of the objects to convert to the PersistableBundle
//     * @param in         the list of objects to be serialized into a PersistableBundle
//     * @param serializer an implementation of the {@link Serializer} functional interface that
//     *                   converts an object of type T to a PersistableBundle
//     */
//    @NonNull
//    public static <T> PersistableBundle fromList(
//            @NonNull List<T> in, @NonNull Serializer<T> serializer) {
//        final PersistableBundle result = new PersistableBundle();
//
//        result.putInt(COLLECTION_SIZE_KEY, in.size());
//        for (int i = 0; i < in.size(); i++) {
//            final String key = String.format(LIST_KEY_FORMAT, i);
//            result.putPersistableBundle(key, serializer.toPersistableBundle(in.get(i)));
//        }
//        return result;
//    }
//
//    /**
//     * Converts from a PersistableBundle to a list of objects.
//     *
//     * @param <T>          the type of the objects to convert from a PersistableBundle
//     * @param in           the PersistableBundle containing the persisted list
//     * @param deserializer an implementation of the {@link Deserializer} functional interface that
//     *                     builds the relevant type of objects.
//     */
//    @NonNull
//    public static <T> List<T> toList(
//            @NonNull PersistableBundle in, @NonNull Deserializer<T> deserializer) {
//        final int listLength = in.getInt(COLLECTION_SIZE_KEY);
//        final ArrayList<T> result = new ArrayList<>(listLength);
//
//        for (int i = 0; i < listLength; i++) {
//            final String key = String.format(LIST_KEY_FORMAT, i);
//            final PersistableBundle item = in.getPersistableBundle(key);
//
//            result.add(deserializer.fromPersistableBundle(item));
//        }
//        return result;
//    }
//
//    // TODO: b/170513329 Delete #fromByteArray and #toByteArray once BaseBundle#putByteArray and
//    // BaseBundle#getByteArray are exposed.
//
//    /**
//     * Converts a byte array to a PersistableBundle.
//     *
//     * <p>To avoid key collisions, NO additional key/value pairs should be added to the returned
//     * PersistableBundle object.
//     *
//     * @param array a byte array instance to persist
//     * @return the PersistableBundle instance
//     */
//    public static PersistableBundle fromByteArray(byte[] array) {
//        final PersistableBundle result = new PersistableBundle();
//
//        result.putString(BYTE_ARRAY_KEY, toHexString(array));
//
//        return result;
//    }
//
//    // Copied from com.android.internal.util.HexDump
//    @UnsupportedAppUsage
//    public static String toHexString(byte[] array, int offset, int length) {
//        return toHexString(array, offset, length, true);
//    }
//
//    public static String toHexString(byte[] array, int offset, int length, boolean upperCase) {
//        char[] digits = upperCase ? HEX_DIGITS : HEX_LOWER_CASE_DIGITS;
//        char[] buf = new char[length * 2];
//
//        int bufIndex = 0;
//        for (int i = offset; i < offset + length; i++) {
//            byte b = array[i];
//            buf[bufIndex++] = digits[(b >>> 4) & 0x0F];
//            buf[bufIndex++] = digits[b & 0x0F];
//        }
//
//        return new String(buf);
//    }
//
//    @UnsupportedAppUsage
//    public static String toHexString(byte[] array) {
//        return toHexString(array, 0, array.length, true);
//    }
//
//    @UnsupportedAppUsage
//    public static String toHexString(int i) {
//        return toHexString(toByteArray(i));
//    }
//
//    public static byte[] toByteArray(int i) {
//        byte[] array = new byte[4];
//
//        array[3] = (byte) (i & 0xFF);
//        array[2] = (byte) ((i >> 8) & 0xFF);
//        array[1] = (byte) ((i >> 16) & 0xFF);
//        array[0] = (byte) ((i >> 24) & 0xFF);
//
//        return array;
//    }
//
//    @UnsupportedAppUsage
//    public static byte[] hexStringToByteArray(String hexString) {
//        int length = hexString.length();
//        byte[] buffer = new byte[length / 2];
//
//        for (int i = 0; i < length; i += 2) {
//            buffer[i / 2] = (byte) ((toByte(hexString.charAt(i)) << 4) | toByte(
//                    hexString.charAt(i + 1)));
//        }
//
//        return buffer;
//    }
//
//    private static int toByte(char c) {
//        if (c >= '0' && c <= '9') return (c - '0');
//        if (c >= 'A' && c <= 'F') return (c - 'A' + 10);
//        if (c >= 'a' && c <= 'f') return (c - 'a' + 10);
//
//        throw new RuntimeException("Invalid hex char '" + c + "'");
//    }
//
//    /**
//     * Converts from a PersistableBundle to a byte array.
//     *
//     * @param bundle the PersistableBundle containing the byte array
//     * @return the byte array instance
//     */
//    public static byte[] toByteArray(PersistableBundle bundle) {
//        Objects.requireNonNull(bundle, "PersistableBundle is null");
//
//        String hex = bundle.getString(BYTE_ARRAY_KEY);
//        if (hex == null || hex.length() % 2 != 0) {
//            throw new IllegalArgumentException("PersistableBundle contains invalid byte array");
//        }
//
//        return hexStringToByteArray(hex);
//    }
//
//    /**
//     * Converts from a Map of Persistable objects to a single PersistableBundle.
//     *
//     * <p>To avoid key collisions, NO additional key/value pairs should be added to the returned
//     * PersistableBundle object.
//     *
//     * @param <K>             the type of the map-key to convert to the PersistableBundle
//     * @param <V>             the type of the map-value to convert to the PersistableBundle
//     * @param in              the Map of objects implementing the {@link Persistable} interface
//     * @param keySerializer   an implementation of the {@link Serializer} functional interface that
//     *                        converts a map-key of type T to a PersistableBundle
//     * @param valueSerializer an implementation of the {@link Serializer} functional interface that
//     *                        converts a map-value of type E to a PersistableBundle
//     */
//    @NonNull
//    public static <K, V> PersistableBundle fromMap(
//            @NonNull Map<K, V> in,
//            @NonNull Serializer<K> keySerializer,
//            @NonNull Serializer<V> valueSerializer) {
//        final PersistableBundle result = new PersistableBundle();
//
//        result.putInt(COLLECTION_SIZE_KEY, in.size());
//        int i = 0;
//        for (Entry<K, V> entry : in.entrySet()) {
//            final String keyKey = String.format(MAP_KEY_FORMAT, i);
//            final String valueKey = String.format(MAP_VALUE_FORMAT, i);
//            result.putPersistableBundle(keyKey, keySerializer.toPersistableBundle(entry.getKey()));
//            result.putPersistableBundle(
//                    valueKey, valueSerializer.toPersistableBundle(entry.getValue()));
//
//            i++;
//        }
//
//        return result;
//    }
//
//    /**
//     * Converts from a PersistableBundle to a Map of objects.
//     *
//     * <p>In an attempt to preserve ordering, the returned map will be a LinkedHashMap. However, the
//     * guarantees on the ordering can only ever be as strong as the map that was serialized in
//     * {@link fromMap()}. If the initial map that was serialized had no ordering guarantees, the
//     * deserialized map similarly may be of a non-deterministic order.
//     *
//     * @param <K>               the type of the map-key to convert from a PersistableBundle
//     * @param <V>               the type of the map-value to convert from a PersistableBundle
//     * @param in                the PersistableBundle containing the persisted Map
//     * @param keyDeserializer   an implementation of the {@link Deserializer} functional interface
//     *                          that builds the relevant type of map-key.
//     * @param valueDeserializer an implementation of the {@link Deserializer} functional interface
//     *                          that builds the relevant type of map-value.
//     * @return An instance of the parsed map as a LinkedHashMap (in an attempt to preserve
//     * ordering).
//     */
//    @NonNull
//    public static <K, V> LinkedHashMap<K, V> toMap(
//            @NonNull PersistableBundle in,
//            @NonNull Deserializer<K> keyDeserializer,
//            @NonNull Deserializer<V> valueDeserializer) {
//        final int mapSize = in.getInt(COLLECTION_SIZE_KEY);
//        final LinkedHashMap<K, V> result = new LinkedHashMap<>(mapSize);
//
//        for (int i = 0; i < mapSize; i++) {
//            final String keyKey = String.format(MAP_KEY_FORMAT, i);
//            final String valueKey = String.format(MAP_VALUE_FORMAT, i);
//            final PersistableBundle keyBundle = in.getPersistableBundle(keyKey);
//            final PersistableBundle valueBundle = in.getPersistableBundle(valueKey);
//
//            final K key = keyDeserializer.fromPersistableBundle(keyBundle);
//            final V value = valueDeserializer.fromPersistableBundle(valueBundle);
//            result.put(key, value);
//        }
//        return result;
//    }
//
//    /**
//     * Converts a PersistableBundle into a disk-stable byte array format
//     *
//     * @param bundle the PersistableBundle to be converted to a disk-stable format
//     * @return the byte array representation of the PersistableBundle
//     */
//    @Nullable
//    public static byte[] toDiskStableBytes(@NonNull PersistableBundle bundle) throws IOException {
//        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
//        bundle.writeToStream(outputStream);
//        return outputStream.toByteArray();
//    }
//
//    /**
//     * Converts from a disk-stable byte array format to a PersistableBundle
//     *
//     * @param bytes the disk-stable byte array
//     * @return the PersistableBundle parsed from this byte array.
//     */
//    public static PersistableBundle fromDiskStableBytes(@NonNull byte[] bytes) throws IOException {
//        final ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);
//        return PersistableBundle.readFromStream(inputStream);
//    }
//
//    /**
//     * Ensures safe reading and writing of {@link PersistableBundle}s to and from disk.
//     *
//     * <p>This class will enforce exclusion between reads and writes using the standard semantics of
//     * a ReadWriteLock. Specifically, concurrent readers ARE allowed, but reads/writes from/to the
//     * file are mutually exclusive. In other words, for an unbounded number n, the acceptable states
//     * are n readers, OR 1 writer (but not both).
//     */
//    public static class LockingReadWriteHelper {
//        private final ReadWriteLock mDiskLock = new ReentrantReadWriteLock();
//        private final String mPath;
//
//        public LockingReadWriteHelper(@NonNull String path) {
//            mPath = Objects.requireNonNull(path, "fileName was null");
//        }
//
//        /**
//         * Reads the {@link PersistableBundle} from the disk.
//         *
//         * @return the PersistableBundle, if the file existed, or null otherwise
//         */
//        @Nullable
//        public PersistableBundle readFromDisk() throws IOException {
//            try {
//                mDiskLock.readLock().lock();
//                final File file = new File(mPath);
//                if (!file.exists()) {
//                    return null;
//                }
//
//                try (FileInputStream fis = new FileInputStream(file)) {
//                    return PersistableBundle.readFromStream(fis);
//                }
//            } finally {
//                mDiskLock.readLock().unlock();
//            }
//        }
//
//        /**
//         * Writes a {@link PersistableBundle} to disk.
//         *
//         * @param bundle the {@link PersistableBundle} to write to disk
//         */
//        public void writeToDisk(@NonNull PersistableBundle bundle) throws IOException {
//            Objects.requireNonNull(bundle, "bundle was null");
//
//            try {
//                mDiskLock.writeLock().lock();
//                final File file = new File(mPath);
//                if (!file.exists()) {
//                    file.getParentFile().mkdirs();
//                }
//
//                try (FileOutputStream fos = new FileOutputStream(file)) {
//                    bundle.writeToStream(fos);
//                }
//            } finally {
//                mDiskLock.writeLock().unlock();
//            }
//        }
//    }
//
//    /**
//     * Returns a copy of the persistable bundle with only the specified keys
//     *
//     * <p>This allows for holding minimized copies for memory-saving purposes.
//     */
//    @NonNull
//    public static PersistableBundle minimizeBundle(
//            @NonNull PersistableBundle bundle, String... keys) {
//        final PersistableBundle minimized = new PersistableBundle();
//
//        if (bundle == null) {
//            return minimized;
//        }
//
//        for (String key : keys) {
//            if (bundle.containsKey(key)) {
//                final Object value = bundle.get(key);
//                if (value == null) {
//                    continue;
//                }
//
//                if (value instanceof Boolean) {
//                    minimized.putBoolean(key, (Boolean) value);
//                } else if (value instanceof boolean[]) {
//                    minimized.putBooleanArray(key, (boolean[]) value);
//                } else if (value instanceof Double) {
//                    minimized.putDouble(key, (Double) value);
//                } else if (value instanceof double[]) {
//                    minimized.putDoubleArray(key, (double[]) value);
//                } else if (value instanceof Integer) {
//                    minimized.putInt(key, (Integer) value);
//                } else if (value instanceof int[]) {
//                    minimized.putIntArray(key, (int[]) value);
//                } else if (value instanceof Long) {
//                    minimized.putLong(key, (Long) value);
//                } else if (value instanceof long[]) {
//                    minimized.putLongArray(key, (long[]) value);
//                } else if (value instanceof String) {
//                    minimized.putString(key, (String) value);
//                } else if (value instanceof String[]) {
//                    minimized.putStringArray(key, (String[]) value);
//                } else if (value instanceof PersistableBundle) {
//                    minimized.putPersistableBundle(key, (PersistableBundle) value);
//                } else {
//                    continue;
//                }
//            }
//        }
//
//        return minimized;
//    }

    /** Builds a stable hashcode */
    public static int getHashCode(@Nullable PersistableBundle bundle) {
        if (bundle == null) {
            return -1;
        }

        int iterativeHashcode = 0;
        TreeSet<String> treeSet = new TreeSet<>(bundle.keySet());
        for (String key : treeSet) {
            Object val = bundle.get(key);
            if (val instanceof PersistableBundle) {
                iterativeHashcode =
                        Objects.hash(iterativeHashcode, key, getHashCode((PersistableBundle) val));
            } else {
                iterativeHashcode = Objects.hash(iterativeHashcode, key, val);
            }
        }

        return iterativeHashcode;
    }

    /** Checks for persistable bundle equality */
    public static boolean isEqual(
            @Nullable PersistableBundle left, @Nullable PersistableBundle right) {
        // Check for pointer equality & null equality
        if (Objects.equals(left, right)) {
            return true;
        }

        // If only one of the two is null, but not the other, not equal by definition.
        if (Objects.isNull(left) != Objects.isNull(right)) {
            return false;
        }

        if (!left.keySet().equals(right.keySet())) {
            return false;
        }

        for (String key : left.keySet()) {
            Object leftVal = left.get(key);
            Object rightVal = right.get(key);

            // Check for equality
            if (Objects.equals(leftVal, rightVal)) {
                continue;
            } else if (Objects.isNull(leftVal) != Objects.isNull(rightVal)) {
                // If only one of the two is null, but not the other, not equal by definition.
                return false;
            } else if (!Objects.equals(leftVal.getClass(), rightVal.getClass())) {
                // If classes are different, not equal by definition.
                return false;
            }
            if (leftVal instanceof PersistableBundle) {
                if (!isEqual((PersistableBundle) leftVal, (PersistableBundle) rightVal)) {
                    return false;
                }
            } else if (leftVal.getClass().isArray()) {
                if (leftVal instanceof boolean[]) {
                    if (!Arrays.equals((boolean[]) leftVal, (boolean[]) rightVal)) {
                        return false;
                    }
                } else if (leftVal instanceof double[]) {
                    if (!Arrays.equals((double[]) leftVal, (double[]) rightVal)) {
                        return false;
                    }
                } else if (leftVal instanceof int[]) {
                    if (!Arrays.equals((int[]) leftVal, (int[]) rightVal)) {
                        return false;
                    }
                } else if (leftVal instanceof long[]) {
                    if (!Arrays.equals((long[]) leftVal, (long[]) rightVal)) {
                        return false;
                    }
                } else if (!Arrays.equals((Object[]) leftVal, (Object[]) rightVal)) {
                    return false;
                }
            } else {
                if (!Objects.equals(leftVal, rightVal)) {
                    return false;
                }
            }
        }

        return true;
    }

//    /**
//     * Wrapper class around PersistableBundles to allow equality comparisons
//     *
//     * <p>This class exposes the minimal getters to retrieve values.
//     */
//    public static class PersistableBundleWrapper {
//        @NonNull
//        private final PersistableBundle mBundle;
//
//        public PersistableBundleWrapper(@NonNull PersistableBundle bundle) {
//            mBundle = Objects.requireNonNull(bundle, "Bundle was null");
//        }
//
//        /**
//         * Retrieves the integer associated with the provided key.
//         *
//         * @param key          the string key to query
//         * @param defaultValue the value to return if key does not exist
//         * @return the int value, or the default
//         */
//        public int getInt(String key, int defaultValue) {
//            return mBundle.getInt(key, defaultValue);
//        }
//
//        @Override
//        public int hashCode() {
//            return getHashCode(mBundle);
//        }
//
//        @Override
//        public boolean equals(Object obj) {
//            if (!(obj instanceof PersistableBundleWrapper)) {
//                return false;
//            }
//
//            final PersistableBundleWrapper other = (PersistableBundleWrapper) obj;
//
//            return isEqual(mBundle, other.mBundle);
//        }
//    }
}