package gnu.trove;

import gnu.trove.TLinkable;
import java.io.Serializable;
import java.util.AbstractSequentialList;
import java.util.ListIterator;
import java.util.NoSuchElementException;

/* loaded from: classes2.dex */
public class TLinkedList<T extends TLinkable> extends AbstractSequentialList<T> implements Serializable {
    protected T _head;
    protected int _size;
    protected T _tail;

    protected final class IteratorImpl implements ListIterator<T> {
        private int a;
        private T b;
        private T c;

        IteratorImpl(int i) {
            int i2;
            if (i < 0 || i > (i2 = TLinkedList.this._size)) {
                throw new IndexOutOfBoundsException();
            }
            this.a = i;
            if (i == 0) {
                this.b = TLinkedList.this._head;
                return;
            }
            if (i == i2) {
                this.b = null;
                return;
            }
            if (i < (i2 >> 1)) {
                this.b = TLinkedList.this._head;
                for (int i3 = 0; i3 < i; i3++) {
                    this.b = (T) this.b.getNext();
                }
                return;
            }
            this.b = TLinkedList.this._tail;
            for (int i4 = i2 - 1; i4 > i; i4--) {
                this.b = (T) this.b.getPrevious();
            }
        }

        @Override // java.util.ListIterator
        /* renamed from: a, reason: merged with bridge method [inline-methods] */
        public final void add(T t) {
            this.c = null;
            this.a++;
            TLinkedList tLinkedList = TLinkedList.this;
            if (tLinkedList._size == 0) {
                tLinkedList.add((TLinkedList) t);
            } else {
                tLinkedList.addBefore(this.b, t);
            }
        }

        @Override // java.util.ListIterator
        /* renamed from: b, reason: merged with bridge method [inline-methods] */
        public final void set(T t) {
            T t2 = this.c;
            if (t2 == null) {
                throw new IllegalStateException();
            }
            TLinkedList tLinkedList = TLinkedList.this;
            if (t2 == tLinkedList._head) {
                tLinkedList._head = t;
            }
            T t3 = this.c;
            TLinkedList tLinkedList2 = TLinkedList.this;
            if (t3 == tLinkedList2._tail) {
                tLinkedList2._tail = t;
            }
            a(this.c, t);
            this.c = t;
        }

        @Override // java.util.ListIterator, java.util.Iterator
        public final boolean hasNext() {
            return this.a != TLinkedList.this._size;
        }

        @Override // java.util.ListIterator
        public final boolean hasPrevious() {
            return this.a != 0;
        }

        @Override // java.util.ListIterator
        public final int nextIndex() {
            return this.a;
        }

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

        @Override // java.util.ListIterator, java.util.Iterator
        public final void remove() {
            T t = this.c;
            if (t == null) {
                throw new IllegalStateException("must invoke next or previous before invoking remove");
            }
            if (t != this.b) {
                this.a--;
            }
            this.b = (T) this.c.getNext();
            TLinkedList.this.remove(this.c);
            this.c = null;
        }

        @Override // java.util.ListIterator, java.util.Iterator
        public final T next() {
            if (this.a == TLinkedList.this._size) {
                throw new NoSuchElementException();
            }
            T t = this.b;
            this.c = t;
            this.b = (T) t.getNext();
            this.a++;
            return this.c;
        }

        @Override // java.util.ListIterator
        public final T previous() {
            int i = this.a;
            if (i == 0) {
                throw new NoSuchElementException();
            }
            TLinkedList tLinkedList = TLinkedList.this;
            if (i == tLinkedList._size) {
                T t = tLinkedList._tail;
                this.b = t;
                this.c = t;
            } else {
                T t2 = (T) this.b.getPrevious();
                this.b = t2;
                this.c = t2;
            }
            this.a--;
            return this.c;
        }

        private void a(T t, T t2) {
            TLinkable previous = t.getPrevious();
            TLinkable next = t.getNext();
            if (previous != null) {
                t2.setPrevious(previous);
                previous.setNext(t2);
            }
            if (next != null) {
                t2.setNext(next);
                next.setPrevious(t2);
            }
            t.setNext(null);
            t.setPrevious(null);
        }
    }

    public void addBefore(T t, T t2) {
        if (t == this._head) {
            addFirst(t2);
            return;
        }
        if (t == null) {
            addLast(t2);
            return;
        }
        TLinkable previous = t.getPrevious();
        t2.setNext(t);
        previous.setNext(t2);
        t2.setPrevious(previous);
        t.setPrevious(t2);
        this._size++;
    }

    public void addFirst(T t) {
        insert(0, t);
    }

    public void addLast(T t) {
        insert(size(), t);
    }

    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
    public void clear() {
        T t = this._head;
        if (t != null) {
            for (TLinkable next = t.getNext(); next != null; next = next.getNext()) {
                next.getPrevious().setNext(null);
                next.setPrevious(null);
            }
            this._tail = null;
            this._head = null;
        }
        this._size = 0;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean contains(Object obj) {
        for (TLinkable tLinkable = this._head; tLinkable != null; tLinkable = tLinkable.getNext()) {
            if (obj.equals(tLinkable)) {
                return true;
            }
        }
        return false;
    }

    public T getFirst() {
        return this._head;
    }

    public T getLast() {
        return this._tail;
    }

    protected void insert(int i, T t) {
        TLinkable tLinkable;
        int i2 = this._size;
        if (i2 == 0) {
            this._tail = t;
            this._head = t;
        } else if (i == 0) {
            t.setNext(this._head);
            this._head.setPrevious(t);
            this._head = t;
        } else if (i == i2) {
            this._tail.setNext(t);
            t.setPrevious(this._tail);
            this._tail = t;
        } else {
            if (i > (i2 >> 1)) {
                tLinkable = this._tail;
                for (int i3 = i2 - 1; i3 > i; i3--) {
                    tLinkable = tLinkable.getPrevious();
                }
            } else {
                tLinkable = this._head;
                for (int i4 = 0; i4 < i; i4++) {
                    tLinkable = tLinkable.getNext();
                }
            }
            TLinkable next = tLinkable.getNext();
            t.setNext(next);
            t.setPrevious(tLinkable);
            next.setPrevious(t);
            tLinkable.setNext(t);
        }
        this._size++;
    }

    @Override // java.util.AbstractSequentialList, java.util.AbstractList, java.util.List
    public ListIterator<T> listIterator(int i) {
        return new IteratorImpl(i);
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean remove(Object obj) {
        if (!(obj instanceof TLinkable)) {
            return false;
        }
        TLinkable tLinkable = (TLinkable) obj;
        TLinkableAdaptor tLinkableAdaptor = (T) tLinkable.getPrevious();
        TLinkableAdaptor tLinkableAdaptor2 = (T) tLinkable.getNext();
        if (tLinkableAdaptor2 == null && tLinkableAdaptor == null) {
            this._tail = null;
            this._head = null;
        } else if (tLinkableAdaptor2 == null) {
            tLinkable.setPrevious(null);
            tLinkableAdaptor.setNext(null);
            this._tail = tLinkableAdaptor;
        } else if (tLinkableAdaptor == null) {
            tLinkable.setNext(null);
            tLinkableAdaptor2.setPrevious(null);
            this._head = tLinkableAdaptor2;
        } else {
            tLinkableAdaptor.setNext(tLinkableAdaptor2);
            tLinkableAdaptor2.setPrevious(tLinkableAdaptor);
            tLinkable.setNext(null);
            tLinkable.setPrevious(null);
        }
        this._size--;
        return true;
    }

    public T removeFirst() {
        T t = this._head;
        T t2 = (T) t.getNext();
        t.setNext(null);
        if (t2 != null) {
            t2.setPrevious(null);
        }
        this._head = t2;
        int i = this._size - 1;
        this._size = i;
        if (i == 0) {
            this._tail = null;
        }
        return t;
    }

    public T removeLast() {
        T t = this._tail;
        T t2 = (T) t.getPrevious();
        t.setPrevious(null);
        if (t2 != null) {
            t2.setNext(null);
        }
        this._tail = t2;
        int i = this._size - 1;
        this._size = i;
        if (i == 0) {
            this._head = null;
        }
        return t;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public int size() {
        return this._size;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public Object[] toArray() {
        Object[] objArr = new Object[this._size];
        TLinkable tLinkable = this._head;
        int i = 0;
        while (tLinkable != null) {
            objArr[i] = tLinkable;
            tLinkable = tLinkable.getNext();
            i++;
        }
        return objArr;
    }

    public Object[] toUnlinkedArray() {
        Object[] objArr = new Object[this._size];
        T t = this._head;
        int i = 0;
        while (t != null) {
            objArr[i] = t;
            TLinkable next = t.getNext();
            t.setNext(null);
            t.setPrevious(null);
            i++;
            t = next;
        }
        this._size = 0;
        this._tail = null;
        this._head = null;
        return objArr;
    }

    @Override // java.util.AbstractSequentialList, java.util.AbstractList, java.util.List
    public void add(int i, T t) {
        if (i >= 0 && i <= size()) {
            insert(i, t);
            return;
        }
        throw new IndexOutOfBoundsException("index:" + i);
    }

    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean add(T t) {
        insert(this._size, t);
        return true;
    }
}