package p037.p123;

import android.util.Log;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/* JADX INFO: renamed from: މ.ޗ.ރ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes.dex */
public final class C2552 {

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public static final String f8046 = AbstractC2562.m4622("Data");

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public static final C2552 f8047;

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public Map<String, Object> f8048;

    /* JADX INFO: renamed from: މ.ޗ.ރ$֏, reason: contains not printable characters */
    public static final class C2553 {

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public Map<String, Object> f8049 = new HashMap();

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public C2553 m4619(Map<String, Object> map) {
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                String key = entry.getKey();
                Object value = entry.getValue();
                if (value == null) {
                    this.f8049.put(key, null);
                } else {
                    Class<?> cls = value.getClass();
                    if (cls == Boolean.class || cls == Byte.class || cls == Integer.class || cls == Long.class || cls == Float.class || cls == Double.class || cls == String.class || cls == Boolean[].class || cls == Byte[].class || cls == Integer[].class || cls == Long[].class || cls == Float[].class || cls == Double[].class || cls == String[].class) {
                        this.f8049.put(key, value);
                    } else if (cls == boolean[].class) {
                        this.f8049.put(key, C2552.m4610((boolean[]) value));
                    } else if (cls == byte[].class) {
                        this.f8049.put(key, C2552.m4611((byte[]) value));
                    } else if (cls == int[].class) {
                        this.f8049.put(key, C2552.m4614((int[]) value));
                    } else if (cls == long[].class) {
                        this.f8049.put(key, C2552.m4615((long[]) value));
                    } else if (cls == float[].class) {
                        this.f8049.put(key, C2552.m4613((float[]) value));
                    } else {
                        if (cls != double[].class) {
                            throw new IllegalArgumentException(String.format("Key %s has invalid type %s", key, cls));
                        }
                        this.f8049.put(key, C2552.m4612((double[]) value));
                    }
                }
            }
            return this;
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public C2552 m4620() throws Throwable {
            C2552 c2552 = new C2552((Map<String, ?>) this.f8049);
            C2552.m4609(c2552);
            return c2552;
        }
    }

    static {
        C2552 c2552 = new C2552(new HashMap());
        m4609(c2552);
        f8047 = c2552;
    }

    public C2552() {
    }

    public C2552(Map<String, ?> map) {
        this.f8048 = new HashMap(map);
    }

    public C2552(C2552 c2552) {
        this.f8048 = new HashMap(c2552.f8048);
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static byte[] m4609(C2552 c2552) throws Throwable {
        ObjectOutputStream objectOutputStream;
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream2 = null;
        try {
            try {
                objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            } catch (IOException e) {
                e = e;
            }
        } catch (Throwable th) {
            th = th;
        }
        try {
            objectOutputStream.writeInt(c2552.f8048.size());
            for (Map.Entry<String, Object> entry : c2552.f8048.entrySet()) {
                objectOutputStream.writeUTF(entry.getKey());
                objectOutputStream.writeObject(entry.getValue());
            }
            try {
                objectOutputStream.close();
            } catch (IOException e2) {
                Log.e(f8046, "Error in Data#toByteArray: ", e2);
            }
            try {
                byteArrayOutputStream.close();
            } catch (IOException e3) {
                Log.e(f8046, "Error in Data#toByteArray: ", e3);
            }
            if (byteArrayOutputStream.size() <= 10240) {
                return byteArrayOutputStream.toByteArray();
            }
            throw new IllegalStateException("Data cannot occupy more than 10240 bytes when serialized");
        } catch (IOException e4) {
            e = e4;
            objectOutputStream2 = objectOutputStream;
            Log.e(f8046, "Error in Data#toByteArray: ", e);
            byte[] byteArray = byteArrayOutputStream.toByteArray();
            if (objectOutputStream2 != null) {
                try {
                    objectOutputStream2.close();
                } catch (IOException e5) {
                    Log.e(f8046, "Error in Data#toByteArray: ", e5);
                }
            }
            try {
                byteArrayOutputStream.close();
            } catch (IOException e6) {
                Log.e(f8046, "Error in Data#toByteArray: ", e6);
            }
            return byteArray;
        } catch (Throwable th2) {
            th = th2;
            objectOutputStream2 = objectOutputStream;
            if (objectOutputStream2 != null) {
                try {
                    objectOutputStream2.close();
                } catch (IOException e7) {
                    Log.e(f8046, "Error in Data#toByteArray: ", e7);
                }
            }
            try {
                byteArrayOutputStream.close();
                throw th;
            } catch (IOException e8) {
                Log.e(f8046, "Error in Data#toByteArray: ", e8);
                throw th;
            }
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static Boolean[] m4610(boolean[] zArr) {
        Boolean[] boolArr = new Boolean[zArr.length];
        for (int i = 0; i < zArr.length; i++) {
            boolArr[i] = Boolean.valueOf(zArr[i]);
        }
        return boolArr;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static Byte[] m4611(byte[] bArr) {
        Byte[] bArr2 = new Byte[bArr.length];
        for (int i = 0; i < bArr.length; i++) {
            bArr2[i] = Byte.valueOf(bArr[i]);
        }
        return bArr2;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static Double[] m4612(double[] dArr) {
        Double[] dArr2 = new Double[dArr.length];
        for (int i = 0; i < dArr.length; i++) {
            dArr2[i] = Double.valueOf(dArr[i]);
        }
        return dArr2;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static Float[] m4613(float[] fArr) {
        Float[] fArr2 = new Float[fArr.length];
        for (int i = 0; i < fArr.length; i++) {
            fArr2[i] = Float.valueOf(fArr[i]);
        }
        return fArr2;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static Integer[] m4614(int[] iArr) {
        Integer[] numArr = new Integer[iArr.length];
        for (int i = 0; i < iArr.length; i++) {
            numArr[i] = Integer.valueOf(iArr[i]);
        }
        return numArr;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static Long[] m4615(long[] jArr) {
        Long[] lArr = new Long[jArr.length];
        for (int i = 0; i < jArr.length; i++) {
            lArr[i] = Long.valueOf(jArr[i]);
        }
        return lArr;
    }

    /* JADX WARN: Can't wrap try/catch for region: R(7:4|(2:60|5)|(5:64|6|(2:8|9)|58|10)|52|14|37|38) */
    /* JADX WARN: Code restructure failed: missing block: B:16:0x0039, code lost:
    
        r7 = move-exception;
     */
    /* JADX WARN: Code restructure failed: missing block: B:36:0x005b, code lost:
    
        android.util.Log.e(p037.p123.C2552.f8046, "Error in Data#fromByteArray: ", r7);
     */
    /* JADX WARN: Not initialized variable reg: 3, insn: 0x0067: MOVE (r7 I:??[OBJECT, ARRAY]) = (r3 I:??[OBJECT, ARRAY]), block:B:39:0x0066 */
    /* JADX WARN: Removed duplicated region for block: B:56:0x0050 A[EXC_TOP_SPLITTER, SYNTHETIC] */
    /* JADX WARN: Removed duplicated region for block: B:61:0x006a A[EXC_TOP_SPLITTER, SYNTHETIC] */
    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static C2552 m4616(byte[] bArr) throws Throwable {
        ObjectInputStream objectInputStream;
        Throwable e;
        ObjectInputStream objectInputStream2;
        if (bArr.length > 10240) {
            throw new IllegalStateException("Data cannot occupy more than 10240 bytes when serialized");
        }
        HashMap map = new HashMap();
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bArr);
        ObjectInputStream objectInputStream3 = null;
        try {
            try {
                objectInputStream = new ObjectInputStream(byteArrayInputStream);
            } catch (Throwable th) {
                th = th;
                objectInputStream3 = objectInputStream2;
                if (objectInputStream3 != null) {
                    try {
                        objectInputStream3.close();
                    } catch (IOException e2) {
                        Log.e(f8046, "Error in Data#fromByteArray: ", e2);
                    }
                }
                try {
                    byteArrayInputStream.close();
                    throw th;
                } catch (IOException e3) {
                    Log.e(f8046, "Error in Data#fromByteArray: ", e3);
                    throw th;
                }
            }
        } catch (IOException e4) {
            e = e4;
            Throwable th2 = e;
            objectInputStream = null;
            e = th2;
            Log.e(f8046, "Error in Data#fromByteArray: ", e);
            if (objectInputStream != null) {
                try {
                    objectInputStream.close();
                } catch (IOException e5) {
                    Log.e(f8046, "Error in Data#fromByteArray: ", e5);
                }
            }
            byteArrayInputStream.close();
            return new C2552(map);
        } catch (ClassNotFoundException e6) {
            e = e6;
            Throwable th22 = e;
            objectInputStream = null;
            e = th22;
            Log.e(f8046, "Error in Data#fromByteArray: ", e);
            if (objectInputStream != null) {
            }
            byteArrayInputStream.close();
            return new C2552(map);
        } catch (Throwable th3) {
            th = th3;
            if (objectInputStream3 != null) {
            }
            byteArrayInputStream.close();
            throw th;
        }
        try {
            for (int i = objectInputStream.readInt(); i > 0; i--) {
                map.put(objectInputStream.readUTF(), objectInputStream.readObject());
            }
            try {
                objectInputStream.close();
            } catch (IOException e7) {
                Log.e(f8046, "Error in Data#fromByteArray: ", e7);
            }
        } catch (IOException e8) {
            e = e8;
            Log.e(f8046, "Error in Data#fromByteArray: ", e);
            if (objectInputStream != null) {
            }
        } catch (ClassNotFoundException e9) {
            e = e9;
            Log.e(f8046, "Error in Data#fromByteArray: ", e);
            if (objectInputStream != null) {
            }
        }
        byteArrayInputStream.close();
        return new C2552(map);
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || C2552.class != obj.getClass()) {
            return false;
        }
        C2552 c2552 = (C2552) obj;
        Set<String> setKeySet = this.f8048.keySet();
        if (!setKeySet.equals(c2552.f8048.keySet())) {
            return false;
        }
        for (String str : setKeySet) {
            Object obj2 = this.f8048.get(str);
            Object obj3 = c2552.f8048.get(str);
            if (!((obj2 == null || obj3 == null) ? obj2 == obj3 : ((obj2 instanceof Object[]) && (obj3 instanceof Object[])) ? Arrays.deepEquals((Object[]) obj2, (Object[]) obj3) : obj2.equals(obj3))) {
                return false;
            }
        }
        return true;
    }

    public int hashCode() {
        return this.f8048.hashCode() * 31;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder("Data {");
        if (!this.f8048.isEmpty()) {
            for (String str : this.f8048.keySet()) {
                sb.append(str);
                sb.append(" : ");
                Object obj = this.f8048.get(str);
                if (obj instanceof Object[]) {
                    sb.append(Arrays.toString((Object[]) obj));
                } else {
                    sb.append(obj);
                }
                sb.append(", ");
            }
        }
        sb.append("}");
        return sb.toString();
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public long m4617(String str, long j) {
        Object obj = this.f8048.get(str);
        return obj instanceof Long ? ((Long) obj).longValue() : j;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public String m4618(String str) {
        Object obj = this.f8048.get(str);
        if (obj instanceof String) {
            return (String) obj;
        }
        return null;
    }
}