package androidx.fragment.app;

import android.util.Log;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Objects;

/* JADX INFO: loaded from: classes.dex */
final class FragmentManagerViewModel extends androidx.lifecycle.s0 {
    private static final androidx.lifecycle.u0 FACTORY = new h1();
    private static final String TAG = "FragmentManager";
    private final boolean mStateAutomaticallySaved;
    private final HashMap<String, e0> mRetainedFragments = new HashMap<>();
    private final HashMap<String, FragmentManagerViewModel> mChildNonConfigs = new HashMap<>();
    private final HashMap<String, androidx.lifecycle.y0> mViewModelStores = new HashMap<>();
    private boolean mHasBeenCleared = false;
    private boolean mHasSavedSnapshot = false;
    private boolean mIsStateSaved = false;

    public FragmentManagerViewModel(boolean z10) {
        this.mStateAutomaticallySaved = z10;
    }

    private void clearNonConfigStateInternal(@NonNull String str, boolean z10) {
        FragmentManagerViewModel fragmentManagerViewModel = this.mChildNonConfigs.get(str);
        if (fragmentManagerViewModel != null) {
            if (z10) {
                ArrayList arrayList = new ArrayList();
                arrayList.addAll(fragmentManagerViewModel.mChildNonConfigs.keySet());
                Iterator it = arrayList.iterator();
                while (it.hasNext()) {
                    fragmentManagerViewModel.clearNonConfigState((String) it.next(), true);
                }
            }
            fragmentManagerViewModel.onCleared();
            this.mChildNonConfigs.remove(str);
        }
        androidx.lifecycle.y0 y0Var = this.mViewModelStores.get(str);
        if (y0Var != null) {
            y0Var.a();
            this.mViewModelStores.remove(str);
        }
    }

    @NonNull
    public static FragmentManagerViewModel getInstance(androidx.lifecycle.y0 y0Var) {
        return (FragmentManagerViewModel) new androidx.lifecycle.x0(y0Var, FACTORY).a(FragmentManagerViewModel.class);
    }

    public void addRetainedFragment(@NonNull e0 e0Var) {
        if (this.mIsStateSaved || this.mRetainedFragments.containsKey(e0Var.f2406e)) {
            return;
        }
        this.mRetainedFragments.put(e0Var.f2406e, e0Var);
        if (Log.isLoggable(TAG, 2)) {
            e0Var.toString();
        }
    }

    public void clearNonConfigState(@NonNull e0 e0Var, boolean z10) {
        if (Log.isLoggable(TAG, 3)) {
            Objects.toString(e0Var);
        }
        clearNonConfigStateInternal(e0Var.f2406e, z10);
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || FragmentManagerViewModel.class != obj.getClass()) {
            return false;
        }
        FragmentManagerViewModel fragmentManagerViewModel = (FragmentManagerViewModel) obj;
        return this.mRetainedFragments.equals(fragmentManagerViewModel.mRetainedFragments) && this.mChildNonConfigs.equals(fragmentManagerViewModel.mChildNonConfigs) && this.mViewModelStores.equals(fragmentManagerViewModel.mViewModelStores);
    }

    @Nullable
    public e0 findRetainedFragmentByWho(String str) {
        return this.mRetainedFragments.get(str);
    }

    @NonNull
    public FragmentManagerViewModel getChildNonConfig(@NonNull e0 e0Var) {
        FragmentManagerViewModel fragmentManagerViewModel = this.mChildNonConfigs.get(e0Var.f2406e);
        if (fragmentManagerViewModel != null) {
            return fragmentManagerViewModel;
        }
        FragmentManagerViewModel fragmentManagerViewModel2 = new FragmentManagerViewModel(this.mStateAutomaticallySaved);
        this.mChildNonConfigs.put(e0Var.f2406e, fragmentManagerViewModel2);
        return fragmentManagerViewModel2;
    }

    @NonNull
    public Collection<e0> getRetainedFragments() {
        return new ArrayList(this.mRetainedFragments.values());
    }

    @Nullable
    @Deprecated
    public f1 getSnapshot() {
        if (this.mRetainedFragments.isEmpty() && this.mChildNonConfigs.isEmpty() && this.mViewModelStores.isEmpty()) {
            return null;
        }
        HashMap map = new HashMap();
        for (Map.Entry<String, FragmentManagerViewModel> entry : this.mChildNonConfigs.entrySet()) {
            f1 snapshot = entry.getValue().getSnapshot();
            if (snapshot != null) {
                map.put(entry.getKey(), snapshot);
            }
        }
        this.mHasSavedSnapshot = true;
        if (this.mRetainedFragments.isEmpty() && map.isEmpty() && this.mViewModelStores.isEmpty()) {
            return null;
        }
        return new f1(new ArrayList(this.mRetainedFragments.values()), map, new HashMap(this.mViewModelStores));
    }

    @NonNull
    public androidx.lifecycle.y0 getViewModelStore(@NonNull e0 e0Var) {
        androidx.lifecycle.y0 y0Var = this.mViewModelStores.get(e0Var.f2406e);
        if (y0Var != null) {
            return y0Var;
        }
        androidx.lifecycle.y0 y0Var2 = new androidx.lifecycle.y0();
        this.mViewModelStores.put(e0Var.f2406e, y0Var2);
        return y0Var2;
    }

    public int hashCode() {
        return this.mViewModelStores.hashCode() + ((this.mChildNonConfigs.hashCode() + (this.mRetainedFragments.hashCode() * 31)) * 31);
    }

    public boolean isCleared() {
        return this.mHasBeenCleared;
    }

    @Override // androidx.lifecycle.s0
    public void onCleared() {
        if (Log.isLoggable(TAG, 3)) {
            toString();
        }
        this.mHasBeenCleared = true;
    }

    public void removeRetainedFragment(@NonNull e0 e0Var) {
        if (this.mIsStateSaved || this.mRetainedFragments.remove(e0Var.f2406e) == null || !Log.isLoggable(TAG, 2)) {
            return;
        }
        e0Var.toString();
    }

    @Deprecated
    public void restoreFromSnapshot(@Nullable f1 f1Var) {
        this.mRetainedFragments.clear();
        this.mChildNonConfigs.clear();
        this.mViewModelStores.clear();
        if (f1Var != null) {
            Collection<e0> fragments = f1Var.getFragments();
            if (fragments != null) {
                for (e0 e0Var : fragments) {
                    if (e0Var != null) {
                        this.mRetainedFragments.put(e0Var.f2406e, e0Var);
                    }
                }
            }
            Map<String, f1> childNonConfigs = f1Var.getChildNonConfigs();
            if (childNonConfigs != null) {
                for (Map.Entry<String, f1> entry : childNonConfigs.entrySet()) {
                    FragmentManagerViewModel fragmentManagerViewModel = new FragmentManagerViewModel(this.mStateAutomaticallySaved);
                    fragmentManagerViewModel.restoreFromSnapshot(entry.getValue());
                    this.mChildNonConfigs.put(entry.getKey(), fragmentManagerViewModel);
                }
            }
            Map<String, androidx.lifecycle.y0> viewModelStores = f1Var.getViewModelStores();
            if (viewModelStores != null) {
                this.mViewModelStores.putAll(viewModelStores);
            }
        }
        this.mHasSavedSnapshot = false;
    }

    public void setIsStateSaved(boolean z10) {
        this.mIsStateSaved = z10;
    }

    public boolean shouldDestroy(@NonNull e0 e0Var) {
        if (this.mRetainedFragments.containsKey(e0Var.f2406e)) {
            return this.mStateAutomaticallySaved ? this.mHasBeenCleared : !this.mHasSavedSnapshot;
        }
        return true;
    }

    @NonNull
    public String toString() {
        StringBuilder sb = new StringBuilder("FragmentManagerViewModel{");
        sb.append(Integer.toHexString(System.identityHashCode(this)));
        sb.append("} Fragments (");
        Iterator<e0> it = this.mRetainedFragments.values().iterator();
        while (it.hasNext()) {
            sb.append(it.next());
            if (it.hasNext()) {
                sb.append(", ");
            }
        }
        sb.append(") Child Non Config (");
        Iterator<String> it2 = this.mChildNonConfigs.keySet().iterator();
        while (it2.hasNext()) {
            sb.append(it2.next());
            if (it2.hasNext()) {
                sb.append(", ");
            }
        }
        sb.append(") ViewModelStores (");
        Iterator<String> it3 = this.mViewModelStores.keySet().iterator();
        while (it3.hasNext()) {
            sb.append(it3.next());
            if (it3.hasNext()) {
                sb.append(", ");
            }
        }
        sb.append(')');
        return sb.toString();
    }

    public void clearNonConfigState(@NonNull String str, boolean z10) {
        clearNonConfigStateInternal(str, z10);
    }
}