package io.netty.handler.codec.dns;

import g.a.a.a.a;
import io.netty.util.AbstractReferenceCounted;
import io.netty.util.ReferenceCountUtil;
import io.netty.util.ReferenceCounted;
import io.netty.util.ResourceLeakDetector;
import io.netty.util.ResourceLeakDetectorFactory;
import io.netty.util.ResourceLeakTracker;
import io.netty.util.internal.ObjectUtil;
import io.netty.util.internal.StringUtil;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
public abstract class AbstractDnsMessage extends AbstractReferenceCounted implements DnsMessage {
    public static final /* synthetic */ boolean $assertionsDisabled = false;
    private static final int SECTION_COUNT = 4;
    private Object additionals;
    private Object answers;
    private Object authorities;
    private short id;
    private final ResourceLeakTracker<DnsMessage> leak;
    private DnsOpCode opCode;
    private Object questions;
    private boolean recursionDesired;

    /* JADX INFO: renamed from: z, reason: collision with root package name */
    private byte f5800z;
    private static final ResourceLeakDetector<DnsMessage> leakDetector = ResourceLeakDetectorFactory.instance().newResourceLeakDetector(DnsMessage.class);
    private static final int SECTION_QUESTION = DnsSection.QUESTION.ordinal();

    public AbstractDnsMessage(int i2) {
        this(i2, DnsOpCode.QUERY);
    }

    public AbstractDnsMessage(int i2, DnsOpCode dnsOpCode) {
        this.leak = leakDetector.track(this);
        setId(i2);
        setOpCode(dnsOpCode);
    }

    private void addRecord(int i2, int i3, DnsRecord dnsRecord) {
        ArrayList<DnsRecord> arrayListNewRecordList;
        checkQuestion(i2, dnsRecord);
        Object objSectionAt = sectionAt(i2);
        if (objSectionAt == null) {
            if (i3 != 0) {
                throw new IndexOutOfBoundsException(a.n("index: ", i3, " (expected: 0)"));
            }
            setSection(i2, dnsRecord);
        } else {
            if (!(objSectionAt instanceof DnsRecord)) {
                ((List) objSectionAt).add(i3, dnsRecord);
                return;
            }
            if (i3 == 0) {
                arrayListNewRecordList = newRecordList();
                arrayListNewRecordList.add(dnsRecord);
                dnsRecord = castRecord(objSectionAt);
            } else {
                if (i3 != 1) {
                    throw new IndexOutOfBoundsException(a.n("index: ", i3, " (expected: 0 or 1)"));
                }
                arrayListNewRecordList = newRecordList();
                arrayListNewRecordList.add(castRecord(objSectionAt));
            }
            arrayListNewRecordList.add(dnsRecord);
            setSection(i2, arrayListNewRecordList);
        }
    }

    private void addRecord(int i2, DnsRecord dnsRecord) {
        checkQuestion(i2, dnsRecord);
        Object objSectionAt = sectionAt(i2);
        if (objSectionAt == null) {
            setSection(i2, dnsRecord);
            return;
        }
        if (!(objSectionAt instanceof DnsRecord)) {
            ((List) objSectionAt).add(dnsRecord);
            return;
        }
        ArrayList<DnsRecord> arrayListNewRecordList = newRecordList();
        arrayListNewRecordList.add(castRecord(objSectionAt));
        arrayListNewRecordList.add(dnsRecord);
        setSection(i2, arrayListNewRecordList);
    }

    private static <T extends DnsRecord> T castRecord(Object obj) {
        return (T) obj;
    }

    private static DnsRecord checkQuestion(int i2, DnsRecord dnsRecord) {
        if (i2 != SECTION_QUESTION || (ObjectUtil.checkNotNull(dnsRecord, "record") instanceof DnsQuestion)) {
            return dnsRecord;
        }
        throw new IllegalArgumentException("record: " + dnsRecord + " (expected: " + StringUtil.simpleClassName((Class<?>) DnsQuestion.class) + ')');
    }

    private void clear(int i2) {
        Object objSectionAt = sectionAt(i2);
        setSection(i2, null);
        if (objSectionAt instanceof ReferenceCounted) {
            ((ReferenceCounted) objSectionAt).release();
            return;
        }
        if (objSectionAt instanceof List) {
            List list = (List) objSectionAt;
            if (list.isEmpty()) {
                return;
            }
            Iterator it = list.iterator();
            while (it.hasNext()) {
                ReferenceCountUtil.release(it.next());
            }
        }
    }

    private int count(int i2) {
        Object objSectionAt = sectionAt(i2);
        if (objSectionAt == null) {
            return 0;
        }
        if (objSectionAt instanceof DnsRecord) {
            return 1;
        }
        return ((List) objSectionAt).size();
    }

    private static ArrayList<DnsRecord> newRecordList() {
        return new ArrayList<>(2);
    }

    private <T extends DnsRecord> T recordAt(int i2) {
        Object objSectionAt = sectionAt(i2);
        if (objSectionAt == null) {
            return null;
        }
        if (objSectionAt instanceof DnsRecord) {
            return (T) castRecord(objSectionAt);
        }
        List list = (List) objSectionAt;
        if (list.isEmpty()) {
            return null;
        }
        return (T) castRecord(list.get(0));
    }

    private <T extends DnsRecord> T recordAt(int i2, int i3) {
        Object objSectionAt = sectionAt(i2);
        if (objSectionAt == null) {
            throw new IndexOutOfBoundsException(a.n("index: ", i3, " (expected: none)"));
        }
        if (!(objSectionAt instanceof DnsRecord)) {
            return (T) castRecord(((List) objSectionAt).get(i3));
        }
        if (i3 == 0) {
            return (T) castRecord(objSectionAt);
        }
        throw new IndexOutOfBoundsException(a.n("index: ", i3, "' (expected: 0)"));
    }

    private <T extends DnsRecord> T removeRecord(int i2, int i3) {
        Object objSectionAt = sectionAt(i2);
        if (objSectionAt == null) {
            throw new IndexOutOfBoundsException(a.n("index: ", i3, " (expected: none)"));
        }
        if (!(objSectionAt instanceof DnsRecord)) {
            return (T) castRecord(((List) objSectionAt).remove(i3));
        }
        if (i3 != 0) {
            throw new IndexOutOfBoundsException(a.n("index: ", i3, " (expected: 0)"));
        }
        T t2 = (T) castRecord(objSectionAt);
        setSection(i2, null);
        return t2;
    }

    private Object sectionAt(int i2) {
        if (i2 == 0) {
            return this.questions;
        }
        if (i2 == 1) {
            return this.answers;
        }
        if (i2 == 2) {
            return this.authorities;
        }
        if (i2 == 3) {
            return this.additionals;
        }
        throw new Error();
    }

    private static int sectionOrdinal(DnsSection dnsSection) {
        return ((DnsSection) ObjectUtil.checkNotNull(dnsSection, "section")).ordinal();
    }

    private <T extends DnsRecord> T setRecord(int i2, int i3, DnsRecord dnsRecord) {
        checkQuestion(i2, dnsRecord);
        Object objSectionAt = sectionAt(i2);
        if (objSectionAt == null) {
            throw new IndexOutOfBoundsException(a.n("index: ", i3, " (expected: none)"));
        }
        if (!(objSectionAt instanceof DnsRecord)) {
            return (T) castRecord(((List) objSectionAt).set(i3, dnsRecord));
        }
        if (i3 != 0) {
            throw new IndexOutOfBoundsException(a.n("index: ", i3, " (expected: 0)"));
        }
        setSection(i2, dnsRecord);
        return (T) castRecord(objSectionAt);
    }

    private void setRecord(int i2, DnsRecord dnsRecord) {
        clear(i2);
        setSection(i2, checkQuestion(i2, dnsRecord));
    }

    private void setSection(int i2, Object obj) {
        if (i2 == 0) {
            this.questions = obj;
            return;
        }
        if (i2 == 1) {
            this.answers = obj;
        } else if (i2 == 2) {
            this.authorities = obj;
        } else {
            if (i2 != 3) {
                throw new Error();
            }
            this.additionals = obj;
        }
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public DnsMessage addRecord(DnsSection dnsSection, int i2, DnsRecord dnsRecord) {
        addRecord(sectionOrdinal(dnsSection), i2, dnsRecord);
        return this;
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public DnsMessage addRecord(DnsSection dnsSection, DnsRecord dnsRecord) {
        addRecord(sectionOrdinal(dnsSection), dnsRecord);
        return this;
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public DnsMessage clear() {
        for (int i2 = 0; i2 < 4; i2++) {
            clear(i2);
        }
        return this;
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public DnsMessage clear(DnsSection dnsSection) {
        clear(sectionOrdinal(dnsSection));
        return this;
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public int count() {
        int iCount = 0;
        for (int i2 = 0; i2 < 4; i2++) {
            iCount += count(i2);
        }
        return iCount;
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public int count(DnsSection dnsSection) {
        return count(sectionOrdinal(dnsSection));
    }

    @Override // io.netty.util.AbstractReferenceCounted
    public void deallocate() {
        clear();
        ResourceLeakTracker<DnsMessage> resourceLeakTracker = this.leak;
        if (resourceLeakTracker != null) {
            resourceLeakTracker.close(this);
        }
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof DnsMessage)) {
            return false;
        }
        DnsMessage dnsMessage = (DnsMessage) obj;
        if (id() != dnsMessage.id()) {
            return false;
        }
        boolean z2 = dnsMessage instanceof DnsQuery;
        if (this instanceof DnsQuery) {
            if (!z2) {
                return false;
            }
        } else if (z2) {
            return false;
        }
        return true;
    }

    public int hashCode() {
        return (id() * 31) + (!(this instanceof DnsQuery) ? 1 : 0);
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public int id() {
        return this.id & 65535;
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public boolean isRecursionDesired() {
        return this.recursionDesired;
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public DnsOpCode opCode() {
        return this.opCode;
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public <T extends DnsRecord> T recordAt(DnsSection dnsSection) {
        return (T) recordAt(sectionOrdinal(dnsSection));
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public <T extends DnsRecord> T recordAt(DnsSection dnsSection, int i2) {
        return (T) recordAt(sectionOrdinal(dnsSection), i2);
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public <T extends DnsRecord> T removeRecord(DnsSection dnsSection, int i2) {
        return (T) removeRecord(sectionOrdinal(dnsSection), i2);
    }

    @Override // io.netty.util.AbstractReferenceCounted, io.netty.util.ReferenceCounted
    public DnsMessage retain() {
        return (DnsMessage) super.retain();
    }

    @Override // io.netty.util.AbstractReferenceCounted, io.netty.util.ReferenceCounted
    public DnsMessage retain(int i2) {
        return (DnsMessage) super.retain(i2);
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public DnsMessage setId(int i2) {
        this.id = (short) i2;
        return this;
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public DnsMessage setOpCode(DnsOpCode dnsOpCode) {
        this.opCode = (DnsOpCode) ObjectUtil.checkNotNull(dnsOpCode, "opCode");
        return this;
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public DnsMessage setRecord(DnsSection dnsSection, DnsRecord dnsRecord) {
        setRecord(sectionOrdinal(dnsSection), dnsRecord);
        return this;
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public <T extends DnsRecord> T setRecord(DnsSection dnsSection, int i2, DnsRecord dnsRecord) {
        return (T) setRecord(sectionOrdinal(dnsSection), i2, dnsRecord);
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public DnsMessage setRecursionDesired(boolean z2) {
        this.recursionDesired = z2;
        return this;
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public DnsMessage setZ(int i2) {
        this.f5800z = (byte) (i2 & 7);
        return this;
    }

    @Override // io.netty.util.AbstractReferenceCounted, io.netty.util.ReferenceCounted
    public DnsMessage touch() {
        return (DnsMessage) super.touch();
    }

    @Override // io.netty.util.ReferenceCounted
    public DnsMessage touch(Object obj) {
        ResourceLeakTracker<DnsMessage> resourceLeakTracker = this.leak;
        if (resourceLeakTracker != null) {
            resourceLeakTracker.record(obj);
        }
        return this;
    }

    @Override // io.netty.handler.codec.dns.DnsMessage
    public int z() {
        return this.f5800z;
    }
}