package com.discord.utilities.collections;

import c.d.b.a.a;
import d0.t.n;
import d0.t.q;
import d0.t.s;
import d0.z.d.g;
import d0.z.d.g0.c;
import d0.z.d.m;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
/* compiled from: SparseMutableList.kt */
public final class SparseMutableList<T> implements List<T>, c {
    private final List<Chunk<T>> chunks;
    private final int expectedChunkSize;
    private int size;

    /* compiled from: SparseMutableList.kt */
    public static final class Chunk<T> implements Comparable<Chunk<T>> {
        public static final Companion Companion = new Companion(null);
        private List<T> list;
        private int startIndex;

        /* compiled from: SparseMutableList.kt */
        public static final class Companion {
            private Companion() {
            }

            public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
                this();
            }

            public final <T> Chunk<T> create(T t, int i, int i2) {
                ArrayList arrayList = new ArrayList(i2);
                arrayList.add(t);
                return new Chunk<>(i, arrayList);
            }

            public final <T> Chunk<T> tryMergeChunks(Chunk<T> chunk, Chunk<T> chunk2) {
                Chunk<T> chunk3;
                m.checkNotNullParameter(chunk, "chunk1");
                m.checkNotNullParameter(chunk2, "chunk2");
                if (Chunk.access$getStartIndex$p(chunk) < Chunk.access$getStartIndex$p(chunk2)) {
                    chunk3 = chunk;
                } else if (Chunk.access$getStartIndex$p(chunk2) < Chunk.access$getStartIndex$p(chunk)) {
                    chunk3 = chunk2;
                } else {
                    throw new IllegalArgumentException("both chunks begin at the same index");
                }
                Chunk<T> chunk4 = chunk == chunk3 ? chunk2 : chunk;
                int size = (chunk3.getSize() + Chunk.access$getStartIndex$p(chunk3)) - 1;
                if (size >= Chunk.access$getStartIndex$p(chunk4)) {
                    throw new IllegalArgumentException("chunks overlap: " + chunk + ", " + chunk2);
                } else if (size != Chunk.access$getStartIndex$p(chunk4) - 1) {
                    return null;
                } else {
                    List<T> list = chunk3.getList();
                    list.addAll(chunk4.getList());
                    return new Chunk<>(Chunk.access$getStartIndex$p(chunk3), list);
                }
            }
        }

        public Chunk(int i, List<T> list) {
            m.checkNotNullParameter(list, "list");
            this.startIndex = i;
            this.list = list;
        }

        public static final /* synthetic */ int access$getStartIndex$p(Chunk chunk) {
            return chunk.startIndex;
        }

        public static final /* synthetic */ void access$setStartIndex$p(Chunk chunk, int i) {
            chunk.startIndex = i;
        }

        private final int component1() {
            return this.startIndex;
        }

        /* JADX DEBUG: Multi-variable search result rejected for r0v0, resolved type: com.discord.utilities.collections.SparseMutableList$Chunk */
        /* JADX WARN: Multi-variable type inference failed */
        public static /* synthetic */ Chunk copy$default(Chunk chunk, int i, List list, int i2, Object obj) {
            if ((i2 & 1) != 0) {
                i = chunk.startIndex;
            }
            if ((i2 & 2) != 0) {
                list = chunk.list;
            }
            return chunk.copy(i, list);
        }

        public final void addAtListIndex(int i, T t) {
            int i2 = i - this.startIndex;
            if (i2 == 0 && t == null) {
                incrementStartIndex();
            } else {
                this.list.add(i2, t);
            }
        }

        public final boolean beginsAfterListIndex(int i) {
            return this.startIndex > i;
        }

        public int compareTo(Chunk<T> chunk) {
            m.checkNotNullParameter(chunk, "other");
            return this.startIndex - chunk.startIndex;
        }

        @Override // java.lang.Comparable
        public /* bridge */ /* synthetic */ int compareTo(Object obj) {
            return compareTo((Chunk) ((Chunk) obj));
        }

        public final List<T> component2() {
            return this.list;
        }

        public final boolean containsListIndex(int i) {
            return this.startIndex <= i && n.getLastIndex(this.list) + this.startIndex >= i;
        }

        public final Chunk<T> copy(int i, List<T> list) {
            m.checkNotNullParameter(list, "list");
            return new Chunk<>(i, list);
        }

        public final void decrementStartIndex() {
            this.startIndex--;
        }

        public final Chunk<T> deepCopy() {
            return new Chunk<>(this.startIndex, new ArrayList(this.list));
        }

        public final <R> Chunk<R> deepCopy(Function1<? super T, ? extends R> function1) {
            m.checkNotNullParameter(function1, "transform");
            ArrayList arrayList = new ArrayList(this.list.size());
            Iterator<T> it = this.list.iterator();
            while (it.hasNext()) {
                T next = it.next();
                arrayList.add(next != null ? function1.invoke(next) : null);
            }
            return new Chunk<>(this.startIndex, arrayList);
        }

        @Override // java.lang.Object
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof Chunk)) {
                return false;
            }
            Chunk chunk = (Chunk) obj;
            return this.startIndex == chunk.startIndex && m.areEqual(this.list, chunk.list);
        }

        public final int firstListIndexOf(T t) {
            int lastIndex = n.getLastIndex(this.list);
            if (lastIndex < 0) {
                return -1;
            }
            int i = 0;
            while (!m.areEqual(this.list.get(i), t)) {
                if (i == lastIndex) {
                    return -1;
                }
                i++;
            }
            return this.startIndex + i;
        }

        public final T getAtListIndex(int i) {
            return this.list.get(i - this.startIndex);
        }

        public final List<T> getList() {
            return this.list;
        }

        public final int getSize() {
            return this.list.size();
        }

        @Override // java.lang.Object
        public int hashCode() {
            int i = this.startIndex * 31;
            List<T> list = this.list;
            return i + (list != null ? list.hashCode() : 0);
        }

        public final void incrementStartIndex() {
            this.startIndex++;
        }

        public final boolean isEmpty() {
            return this.list.isEmpty();
        }

        public final int lastListIndexOf(T t) {
            for (int lastIndex = n.getLastIndex(this.list); lastIndex >= 0; lastIndex--) {
                if (m.areEqual(this.list.get(lastIndex), t)) {
                    return this.startIndex + lastIndex;
                }
            }
            return -1;
        }

        public final void removeAfterInclusive(int i) {
            int i2 = i - this.startIndex;
            if (i2 <= n.getLastIndex(this.list)) {
                if (i2 <= 0) {
                    this.list.clear();
                } else {
                    this.list = this.list.subList(0, i2);
                }
            }
        }

        public final T removeAtListIndex(int i) {
            return this.list.remove(i - this.startIndex);
        }

        public final T setAtListIndex(int i, T t) {
            int i2 = i - this.startIndex;
            if (t != null) {
                return this.list.set(i2, t);
            }
            if (i2 != 0) {
                return this.list.set(i2, t);
            }
            incrementStartIndex();
            return this.list.remove(0);
        }

        public final void setList(List<T> list) {
            m.checkNotNullParameter(list, "<set-?>");
            this.list = list;
        }

        @Override // java.lang.Object
        public String toString() {
            StringBuilder L = a.L("Chunk(startIndex=");
            L.append(this.startIndex);
            L.append(", list=");
            return a.E(L, this.list, ")");
        }
    }

    /* compiled from: SparseMutableList.kt */
    public static final class SparseMutableListIterator<T> implements ListIterator<T>, d0.z.d.g0.a {
        private int index;
        private final SparseMutableList<T> sparseMutableList;

        public SparseMutableListIterator(SparseMutableList<T> sparseMutableList, int i) {
            m.checkNotNullParameter(sparseMutableList, "sparseMutableList");
            this.sparseMutableList = sparseMutableList;
            this.index = i;
        }

        /* JADX INFO: this call moved to the top of the method (can break code semantics) */
        public /* synthetic */ SparseMutableListIterator(SparseMutableList sparseMutableList, int i, int i2, DefaultConstructorMarker defaultConstructorMarker) {
            this(sparseMutableList, (i2 & 2) != 0 ? -1 : i);
        }

        @Override // java.util.ListIterator
        public void add(T t) {
            throw new UnsupportedOperationException("add not supported during iteration");
        }

        public final int getIndex() {
            return this.index;
        }

        @Override // java.util.ListIterator, java.util.Iterator
        public boolean hasNext() {
            return nextIndex() < n.getLastIndex(this.sparseMutableList);
        }

        @Override // java.util.ListIterator
        public boolean hasPrevious() {
            return this.index > 0;
        }

        @Override // java.util.ListIterator, java.util.Iterator
        public T next() {
            int i = this.index + 1;
            this.index = i;
            return this.sparseMutableList.get(i);
        }

        @Override // java.util.ListIterator
        public int nextIndex() {
            return this.index + 1;
        }

        @Override // java.util.ListIterator
        public T previous() {
            int i = this.index - 1;
            this.index = i;
            return this.sparseMutableList.get(i);
        }

        @Override // java.util.ListIterator
        public int previousIndex() {
            return this.index - 1;
        }

        @Override // java.util.ListIterator, java.util.Iterator
        public void remove() {
            this.sparseMutableList.remove(this.index);
        }

        @Override // java.util.ListIterator
        public void set(T t) {
            this.sparseMutableList.set(this.index, t);
        }

        public final void setIndex(int i) {
            this.index = i;
        }
    }

    public SparseMutableList() {
        this(0, 0, 3, null);
    }

    public SparseMutableList(int i, int i2) {
        this.expectedChunkSize = i2;
        this.chunks = new ArrayList();
        this.size = i;
    }

    /* JADX INFO: this call moved to the top of the method (can break code semantics) */
    public /* synthetic */ SparseMutableList(int i, int i2, int i3, DefaultConstructorMarker defaultConstructorMarker) {
        this((i3 & 1) != 0 ? 0 : i, (i3 & 2) != 0 ? 5 : i2);
    }

    private final void addChunk(int i, Chunk<T> chunk) {
        this.chunks.add(i, chunk);
        q.sort(this.chunks);
    }

    private final void addChunk(Chunk<T> chunk) {
        this.chunks.add(chunk);
        q.sort(this.chunks);
    }

    private final void decrementChunksFromIndex(int i) {
        int lastIndex;
        int lastIndex2 = n.getLastIndex(this.chunks);
        if (i >= 0 && lastIndex2 >= i && i <= (lastIndex = n.getLastIndex(this.chunks))) {
            while (true) {
                this.chunks.get(i).decrementStartIndex();
                if (i != lastIndex) {
                    i++;
                } else {
                    return;
                }
            }
        }
    }

    private final int getChunkIndex(int i) {
        int i2 = 0;
        for (Chunk<T> chunk : this.chunks) {
            if (chunk.containsListIndex(i)) {
                return i2;
            }
            i2++;
        }
        return -1;
    }

    private final int getFirstChunkIndexAfter(int i) {
        int i2 = 0;
        for (Chunk<T> chunk : this.chunks) {
            if (chunk.beginsAfterListIndex(i)) {
                return i2;
            }
            i2++;
        }
        return -1;
    }

    private final void incrementChunksFromIndex(int i) {
        int lastIndex;
        int lastIndex2 = n.getLastIndex(this.chunks);
        if (i >= 0 && lastIndex2 >= i && i <= (lastIndex = n.getLastIndex(this.chunks))) {
            while (true) {
                this.chunks.get(i).incrementStartIndex();
                if (i != lastIndex) {
                    i++;
                } else {
                    return;
                }
            }
        }
    }

    private final void resolveChunks() {
        q.sort(this.chunks);
        int i = 0;
        while (i < this.chunks.size() - 1) {
            Chunk<T> chunk = this.chunks.get(i);
            if (chunk.isEmpty()) {
                this.chunks.remove(i);
            } else {
                int i2 = i + 1;
                Chunk<T> tryMergeChunks = Chunk.Companion.tryMergeChunks(chunk, this.chunks.get(i2));
                if (tryMergeChunks != null) {
                    this.chunks.set(i, tryMergeChunks);
                    this.chunks.remove(i2);
                } else {
                    i = i2;
                }
            }
        }
    }

    @Override // java.util.List
    public void add(int i, T t) {
        if (i == size()) {
            add(t);
        } else if (i <= size()) {
            int chunkIndex = getChunkIndex(i);
            if (t != null) {
                if (chunkIndex >= 0) {
                    this.chunks.get(chunkIndex).addAtListIndex(i, t);
                    incrementChunksFromIndex(chunkIndex + 1);
                } else {
                    Chunk<T> create = Chunk.Companion.create(t, i, this.expectedChunkSize);
                    int firstChunkIndexAfter = getFirstChunkIndexAfter(i);
                    if (firstChunkIndexAfter == -1) {
                        addChunk(create);
                    } else {
                        addChunk(firstChunkIndexAfter, create);
                        incrementChunksFromIndex(firstChunkIndexAfter + 1);
                    }
                }
            } else if (chunkIndex >= 0) {
                this.chunks.get(chunkIndex).addAtListIndex(i, null);
                incrementChunksFromIndex(chunkIndex + 1);
            } else {
                int firstChunkIndexAfter2 = getFirstChunkIndexAfter(i);
                if (firstChunkIndexAfter2 != -1) {
                    incrementChunksFromIndex(firstChunkIndexAfter2);
                }
            }
            setSize(size() + 1);
            resolveChunks();
        } else {
            throw new IndexOutOfBoundsException();
        }
    }

    @Override // java.util.List, java.util.Collection
    public boolean add(T t) {
        set(size(), t);
        return true;
    }

    @Override // java.util.List
    public boolean addAll(int i, Collection<? extends T> collection) {
        m.checkNotNullParameter(collection, "elements");
        throw new UnsupportedOperationException();
    }

    @Override // java.util.List, java.util.Collection
    public boolean addAll(Collection<? extends T> collection) {
        m.checkNotNullParameter(collection, "elements");
        return addAll(size(), collection);
    }

    @Override // java.util.List, java.util.Collection
    public void clear() {
        this.chunks.clear();
        setSize(0);
    }

    @Override // java.util.List, java.util.Collection
    public boolean contains(Object obj) {
        if (isEmpty()) {
            return false;
        }
        for (T t : this) {
            if (m.areEqual(t, obj)) {
                return true;
            }
        }
        return false;
    }

    @Override // java.util.List, java.util.Collection
    public boolean containsAll(Collection<? extends Object> collection) {
        m.checkNotNullParameter(collection, "elements");
        HashSet hashSet = new HashSet(collection);
        if (hashSet.size() > size()) {
            return false;
        }
        for (T t : this) {
            if (hashSet.contains(t)) {
                hashSet.remove(t);
                if (hashSet.isEmpty()) {
                    return true;
                }
            }
        }
        return false;
    }

    public final SparseMutableList<T> deepCopy() {
        SparseMutableList<T> sparseMutableList = new SparseMutableList<>(size(), 0, 2, null);
        Iterator<T> it = this.chunks.iterator();
        while (it.hasNext()) {
            sparseMutableList.chunks.add(it.next().deepCopy());
        }
        return sparseMutableList;
    }

    public final <R> SparseMutableList<R> deepCopy(Function1<? super T, ? extends R> function1) {
        m.checkNotNullParameter(function1, "transform");
        SparseMutableList<R> sparseMutableList = new SparseMutableList<>(size(), 0, 2, null);
        Iterator<T> it = this.chunks.iterator();
        while (it.hasNext()) {
            sparseMutableList.chunks.add(it.next().deepCopy(function1));
        }
        return sparseMutableList;
    }

    @Override // java.util.List
    public T get(int i) {
        if (i <= n.getLastIndex(this)) {
            int chunkIndex = getChunkIndex(i);
            Chunk<T> chunk = chunkIndex >= 0 ? this.chunks.get(chunkIndex) : null;
            if (chunk != null) {
                return chunk.getAtListIndex(i);
            }
            return null;
        }
        StringBuilder M = a.M("index ", i, " invalid in list of size ");
        M.append(size());
        throw new IndexOutOfBoundsException(M.toString());
    }

    public int getSize() {
        return this.size;
    }

    @Override // java.util.List
    public int indexOf(Object obj) {
        if (obj != null) {
            Iterator<T> it = this.chunks.iterator();
            while (it.hasNext()) {
                int firstListIndexOf = it.next().firstListIndexOf(obj);
                if (firstListIndexOf >= 0) {
                    return firstListIndexOf;
                }
            }
            return -1;
        }
        int i = 0;
        for (T t : this) {
            int i2 = i + 1;
            if (i < 0) {
                n.throwIndexOverflow();
            }
            if (m.areEqual(t, obj)) {
                return i;
            }
            i = i2;
        }
        return -1;
    }

    @Override // java.util.List, java.util.Collection
    public boolean isEmpty() {
        return size() == 0;
    }

    @Override // java.util.List, java.util.Collection, java.lang.Iterable
    public Iterator<T> iterator() {
        return new SparseMutableListIterator(this, 0, 2, null);
    }

    @Override // java.util.List
    public int lastIndexOf(Object obj) {
        if (obj != null) {
            for (T t : s.asReversedMutable(this.chunks)) {
                int lastListIndexOf = t.lastListIndexOf(obj);
                if (lastListIndexOf >= 0) {
                    return lastListIndexOf;
                }
            }
            return -1;
        }
        for (int lastIndex = n.getLastIndex(this); lastIndex >= 0; lastIndex--) {
            if (m.areEqual(get(lastIndex), obj)) {
                return lastIndex;
            }
        }
        return -1;
    }

    @Override // java.util.List
    public ListIterator<T> listIterator() {
        return new SparseMutableListIterator(this, 0, 2, null);
    }

    @Override // java.util.List
    public ListIterator<T> listIterator(int i) {
        return new SparseMutableListIterator(this, 0, 2, null);
    }

    @Override // java.util.List
    public final /* bridge */ T remove(int i) {
        return removeAt(i);
    }

    @Override // java.util.List, java.util.Collection
    public boolean remove(Object obj) {
        SparseMutableListIterator sparseMutableListIterator = new SparseMutableListIterator(this, 0, 2, null);
        while (sparseMutableListIterator.hasNext()) {
            if (m.areEqual(sparseMutableListIterator.next(), obj)) {
                sparseMutableListIterator.remove();
                return true;
            }
        }
        return false;
    }

    @Override // java.util.List, java.util.Collection
    public boolean removeAll(Collection<? extends Object> collection) {
        m.checkNotNullParameter(collection, "elements");
        boolean z2 = false;
        SparseMutableListIterator sparseMutableListIterator = new SparseMutableListIterator(this, 0, 2, null);
        while (sparseMutableListIterator.hasNext()) {
            if (collection.contains(sparseMutableListIterator.next())) {
                sparseMutableListIterator.remove();
                z2 = true;
            }
        }
        return z2;
    }

    public T removeAt(int i) {
        T t;
        if (i < 0 || i >= size()) {
            StringBuilder M = a.M("index: ", i, " -- size: ");
            M.append(size());
            throw new ArrayIndexOutOfBoundsException(M.toString());
        }
        int chunkIndex = getChunkIndex(i);
        if (chunkIndex >= 0) {
            t = this.chunks.get(chunkIndex).removeAtListIndex(i);
            decrementChunksFromIndex(chunkIndex + 1);
        } else {
            int firstChunkIndexAfter = getFirstChunkIndexAfter(i);
            if (firstChunkIndexAfter != -1) {
                decrementChunksFromIndex(firstChunkIndexAfter);
            }
            t = null;
        }
        setSize(size() - 1);
        resolveChunks();
        return t;
    }

    @Override // java.util.List, java.util.Collection
    public boolean retainAll(Collection<? extends Object> collection) {
        m.checkNotNullParameter(collection, "elements");
        throw new UnsupportedOperationException();
    }

    @Override // java.util.List
    public T set(int i, T t) {
        if (i >= size()) {
            setSize(i + 1);
        }
        int chunkIndex = getChunkIndex(i);
        if (chunkIndex >= 0) {
            T atListIndex = this.chunks.get(chunkIndex).setAtListIndex(i, t);
            resolveChunks();
            return atListIndex;
        } else if (t == null) {
            return null;
        } else {
            addChunk(Chunk.Companion.create(t, i, this.expectedChunkSize));
            resolveChunks();
            return null;
        }
    }

    public void setSize(int i) {
        int i2 = this.size;
        if (i > i2) {
            this.size = i;
        } else if (i < i2) {
            Iterator<T> it = this.chunks.iterator();
            while (it.hasNext()) {
                it.next().removeAfterInclusive(i);
            }
            this.size = i;
            resolveChunks();
        }
    }

    @Override // java.util.List, java.util.Collection
    public final /* bridge */ int size() {
        return getSize();
    }

    @Override // java.util.List
    public List<T> subList(int i, int i2) {
        throw new UnsupportedOperationException();
    }

    @Override // java.util.List, java.util.Collection
    public Object[] toArray() {
        return g.toArray(this);
    }

    @Override // java.util.List, java.util.Collection
    public <T> T[] toArray(T[] tArr) {
        return (T[]) g.toArray(this, tArr);
    }
}