package com.parse;

import android.os.Parcel;
import android.os.Parcelable;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.json.JSONException;
import org.json.JSONObject;
import p138.p139.p143.p144.C2803;

/* JADX INFO: loaded from: classes.dex */
public class ParseACL implements Parcelable {
    public static final Parcelable.Creator<ParseACL> CREATOR = new Parcelable.Creator<ParseACL>() { // from class: com.parse.ParseACL.1
        @Override // android.os.Parcelable.Creator
        public ParseACL createFromParcel(Parcel parcel) {
            return new ParseACL(parcel, new ParseObjectParcelDecoder());
        }

        @Override // android.os.Parcelable.Creator
        public ParseACL[] newArray(int i) {
            return new ParseACL[i];
        }
    };
    public final Map<String, Permissions> permissionsById = new HashMap();
    public boolean shared;
    public ParseUser unresolvedUser;

    public static class Permissions {
        public final boolean readPermission;
        public final boolean writePermission;

        public Permissions(Permissions permissions) {
            this.readPermission = permissions.readPermission;
            this.writePermission = permissions.writePermission;
        }

        public Permissions(boolean z, boolean z2) {
            this.readPermission = z;
            this.writePermission = z2;
        }
    }

    public static class UserResolutionListener implements GetCallback<ParseObject> {
        public final WeakReference<ParseACL> parent;

        public UserResolutionListener(ParseACL parseACL) {
            this.parent = new WeakReference<>(parseACL);
        }

        @Override // com.parse.ParseCallback2
        public void done(Object obj, Throwable th) {
            ParseObject parseObject = (ParseObject) obj;
            try {
                ParseACL parseACL = this.parent.get();
                if (parseACL != null) {
                    ParseUser parseUser = (ParseUser) parseObject;
                    if (parseACL.isUnresolvedUser(parseUser)) {
                        if (parseACL.permissionsById.containsKey("*unresolved")) {
                            parseACL.permissionsById.put(parseUser.getObjectId(), parseACL.permissionsById.get("*unresolved"));
                            parseACL.permissionsById.remove("*unresolved");
                        }
                        parseACL.unresolvedUser = null;
                    }
                }
            } finally {
                parseObject.unregisterSaveListener(this);
            }
        }
    }

    public ParseACL() {
    }

    public ParseACL(Parcel parcel, ParseParcelDecoder parseParcelDecoder) {
        this.shared = parcel.readByte() == 1;
        int i = parcel.readInt();
        for (int i2 = 0; i2 < i; i2++) {
            this.permissionsById.put(parcel.readString(), new Permissions(parcel.readByte() == 1, parcel.readByte() == 1));
        }
        if (parcel.readByte() == 1) {
            ParseUser parseUser = (ParseUser) parseParcelDecoder.decode(parcel);
            this.unresolvedUser = parseUser;
            parseUser.registerSaveListener(new UserResolutionListener(this));
        }
    }

    public ParseACL(ParseACL parseACL) {
        for (String str : parseACL.permissionsById.keySet()) {
            this.permissionsById.put(str, new Permissions(parseACL.permissionsById.get(str)));
        }
        ParseUser parseUser = parseACL.unresolvedUser;
        this.unresolvedUser = parseUser;
        if (parseUser != null) {
            parseUser.registerSaveListener(new UserResolutionListener(this));
        }
    }

    public static ParseACL createACLFromJSONObject(JSONObject jSONObject, ParseDecoder parseDecoder) {
        ParseACL parseACL = new ParseACL();
        Iterator<String> itKeys = jSONObject.keys();
        while (itKeys.hasNext()) {
            String next = itKeys.next();
            if (next.equals("unresolvedUser")) {
                try {
                    parseACL.unresolvedUser = (ParseUser) parseDecoder.decode(jSONObject.getJSONObject(next));
                } catch (JSONException e) {
                    throw new RuntimeException(e);
                }
            } else {
                try {
                    JSONObject jSONObject2 = jSONObject.getJSONObject(next);
                    parseACL.permissionsById.put(next, new Permissions(jSONObject2.optBoolean("read", false), jSONObject2.optBoolean("write", false)));
                } catch (JSONException e2) {
                    StringBuilder sbM4889 = C2803.m4889("could not decode ACL: ");
                    sbM4889.append(e2.getMessage());
                    throw new RuntimeException(sbM4889.toString());
                }
            }
        }
        return parseACL;
    }

    public static ParseACL getDefaultACL() {
        ParseCorePlugins parseCorePlugins = ParseCorePlugins.INSTANCE;
        if (parseCorePlugins.defaultACLController.get() == null) {
            parseCorePlugins.defaultACLController.compareAndSet(null, new ParseDefaultACLController());
        }
        if (parseCorePlugins.defaultACLController.get() != null) {
            return null;
        }
        throw null;
    }

    @Override // android.os.Parcelable
    public int describeContents() {
        return 0;
    }

    public boolean getReadAccess(String str) {
        if (str == null) {
            throw new IllegalArgumentException("cannot getReadAccess for null userId");
        }
        Permissions permissions = this.permissionsById.get(str);
        return permissions != null && permissions.readPermission;
    }

    public final boolean isUnresolvedUser(ParseUser parseUser) {
        ParseUser parseUser2;
        if (parseUser == null || (parseUser2 = this.unresolvedUser) == null) {
            return false;
        }
        return parseUser == parseUser2 || (parseUser.getObjectId() == null && parseUser.getOrCreateLocalId().equals(this.unresolvedUser.getOrCreateLocalId()));
    }

    public JSONObject toJSONObject(ParseEncoder parseEncoder) {
        JSONObject jSONObject = new JSONObject();
        try {
            for (String str : this.permissionsById.keySet()) {
                Permissions permissions = this.permissionsById.get(str);
                if (permissions == null) {
                    throw null;
                }
                JSONObject jSONObject2 = new JSONObject();
                try {
                    if (permissions.readPermission) {
                        jSONObject2.put("read", true);
                    }
                    if (permissions.writePermission) {
                        jSONObject2.put("write", true);
                    }
                    jSONObject.put(str, jSONObject2);
                } catch (JSONException e) {
                    throw new RuntimeException(e);
                }
            }
            if (this.unresolvedUser != null) {
                jSONObject.put("unresolvedUser", parseEncoder.encode(this.unresolvedUser));
            }
            return jSONObject;
        } catch (JSONException e2) {
            throw new RuntimeException(e2);
        }
    }

    @Override // android.os.Parcelable
    public void writeToParcel(Parcel parcel, int i) {
        writeToParcel(parcel, new ParseObjectParcelEncoder());
    }

    public void writeToParcel(Parcel parcel, ParseParcelEncoder parseParcelEncoder) {
        parcel.writeByte(this.shared ? (byte) 1 : (byte) 0);
        parcel.writeInt(this.permissionsById.size());
        for (String str : this.permissionsById.keySet()) {
            parcel.writeString(str);
            Permissions permissions = this.permissionsById.get(str);
            parcel.writeByte(permissions.readPermission ? (byte) 1 : (byte) 0);
            parcel.writeByte(permissions.writePermission ? (byte) 1 : (byte) 0);
        }
        parcel.writeByte(this.unresolvedUser != null ? (byte) 1 : (byte) 0);
        ParseUser parseUser = this.unresolvedUser;
        if (parseUser != null) {
            parseParcelEncoder.encode(parseUser, parcel);
        }
    }
}