package io.netty.handler.codec.mqtt;

import g.a.a.a.a;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.DecoderException;
import io.netty.handler.codec.MessageToMessageEncoder;
import io.netty.util.CharsetUtil;
import io.netty.util.internal.EmptyArrays;
import java.util.Iterator;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
@ChannelHandler.Sharable
public final class MqttEncoder extends MessageToMessageEncoder<MqttMessage> {
    public static final MqttEncoder INSTANCE = new MqttEncoder();

    /* JADX INFO: renamed from: io.netty.handler.codec.mqtt.MqttEncoder$1, reason: invalid class name */
    public static /* synthetic */ class AnonymousClass1 {
        public static final /* synthetic */ int[] $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType;

        static {
            MqttMessageType.values();
            int[] iArr = new int[14];
            $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType = iArr;
            try {
                iArr[MqttMessageType.CONNECT.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType[MqttMessageType.CONNACK.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType[MqttMessageType.PUBLISH.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType[MqttMessageType.SUBSCRIBE.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
            try {
                $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType[MqttMessageType.UNSUBSCRIBE.ordinal()] = 5;
            } catch (NoSuchFieldError unused5) {
            }
            try {
                $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType[MqttMessageType.SUBACK.ordinal()] = 6;
            } catch (NoSuchFieldError unused6) {
            }
            try {
                $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType[MqttMessageType.UNSUBACK.ordinal()] = 7;
            } catch (NoSuchFieldError unused7) {
            }
            try {
                $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType[MqttMessageType.PUBACK.ordinal()] = 8;
            } catch (NoSuchFieldError unused8) {
            }
            try {
                $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType[MqttMessageType.PUBREC.ordinal()] = 9;
            } catch (NoSuchFieldError unused9) {
            }
            try {
                $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType[MqttMessageType.PUBREL.ordinal()] = 10;
            } catch (NoSuchFieldError unused10) {
            }
            try {
                $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType[MqttMessageType.PUBCOMP.ordinal()] = 11;
            } catch (NoSuchFieldError unused11) {
            }
            try {
                $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType[MqttMessageType.PINGREQ.ordinal()] = 12;
            } catch (NoSuchFieldError unused12) {
            }
            try {
                $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType[MqttMessageType.PINGRESP.ordinal()] = 13;
            } catch (NoSuchFieldError unused13) {
            }
            try {
                $SwitchMap$io$netty$handler$codec$mqtt$MqttMessageType[MqttMessageType.DISCONNECT.ordinal()] = 14;
            } catch (NoSuchFieldError unused14) {
            }
        }
    }

    private MqttEncoder() {
    }

    public static ByteBuf doEncode(ByteBufAllocator byteBufAllocator, MqttMessage mqttMessage) {
        switch (mqttMessage.fixedHeader().messageType()) {
            case CONNECT:
                return encodeConnectMessage(byteBufAllocator, (MqttConnectMessage) mqttMessage);
            case CONNACK:
                return encodeConnAckMessage(byteBufAllocator, (MqttConnAckMessage) mqttMessage);
            case PUBLISH:
                return encodePublishMessage(byteBufAllocator, (MqttPublishMessage) mqttMessage);
            case PUBACK:
            case PUBREC:
            case PUBREL:
            case PUBCOMP:
            case UNSUBACK:
                return encodeMessageWithOnlySingleByteFixedHeaderAndMessageId(byteBufAllocator, mqttMessage);
            case SUBSCRIBE:
                return encodeSubscribeMessage(byteBufAllocator, (MqttSubscribeMessage) mqttMessage);
            case SUBACK:
                return encodeSubAckMessage(byteBufAllocator, (MqttSubAckMessage) mqttMessage);
            case UNSUBSCRIBE:
                return encodeUnsubscribeMessage(byteBufAllocator, (MqttUnsubscribeMessage) mqttMessage);
            case PINGREQ:
            case PINGRESP:
            case DISCONNECT:
                return encodeMessageWithOnlySingleByteFixedHeader(byteBufAllocator, mqttMessage);
            default:
                StringBuilder sbF = a.F("Unknown message type: ");
                sbF.append(mqttMessage.fixedHeader().messageType().value());
                throw new IllegalArgumentException(sbF.toString());
        }
    }

    private static ByteBuf encodeConnAckMessage(ByteBufAllocator byteBufAllocator, MqttConnAckMessage mqttConnAckMessage) {
        ByteBuf byteBufBuffer = byteBufAllocator.buffer(4);
        byteBufBuffer.writeByte(getFixedHeaderByte1(mqttConnAckMessage.fixedHeader()));
        byteBufBuffer.writeByte(2);
        byteBufBuffer.writeByte(mqttConnAckMessage.variableHeader().isSessionPresent() ? 1 : 0);
        byteBufBuffer.writeByte(mqttConnAckMessage.variableHeader().connectReturnCode().byteValue());
        return byteBufBuffer;
    }

    private static ByteBuf encodeConnectMessage(ByteBufAllocator byteBufAllocator, MqttConnectMessage mqttConnectMessage) {
        MqttFixedHeader mqttFixedHeaderFixedHeader = mqttConnectMessage.fixedHeader();
        MqttConnectVariableHeader mqttConnectVariableHeaderVariableHeader = mqttConnectMessage.variableHeader();
        MqttConnectPayload mqttConnectPayloadPayload = mqttConnectMessage.payload();
        MqttVersion mqttVersionFromProtocolNameAndLevel = MqttVersion.fromProtocolNameAndLevel(mqttConnectVariableHeaderVariableHeader.name(), (byte) mqttConnectVariableHeaderVariableHeader.version());
        if (!mqttConnectVariableHeaderVariableHeader.hasUserName() && mqttConnectVariableHeaderVariableHeader.hasPassword()) {
            throw new DecoderException("Without a username, the password MUST be not set");
        }
        String strClientIdentifier = mqttConnectPayloadPayload.clientIdentifier();
        if (!MqttCodecUtil.isValidClientId(mqttVersionFromProtocolNameAndLevel, strClientIdentifier)) {
            throw new MqttIdentifierRejectedException(a.t("invalid clientIdentifier: ", strClientIdentifier));
        }
        byte[] bArrEncodeStringUtf8 = encodeStringUtf8(strClientIdentifier);
        int length = bArrEncodeStringUtf8.length + 2 + 0;
        String strWillTopic = mqttConnectPayloadPayload.willTopic();
        byte[] bArrEncodeStringUtf82 = strWillTopic != null ? encodeStringUtf8(strWillTopic) : EmptyArrays.EMPTY_BYTES;
        byte[] bArrWillMessageInBytes = mqttConnectPayloadPayload.willMessageInBytes();
        if (bArrWillMessageInBytes == null) {
            bArrWillMessageInBytes = EmptyArrays.EMPTY_BYTES;
        }
        if (mqttConnectVariableHeaderVariableHeader.isWillFlag()) {
            length = bArrWillMessageInBytes.length + 2 + bArrEncodeStringUtf82.length + 2 + length;
        }
        String strUserName = mqttConnectPayloadPayload.userName();
        byte[] bArrEncodeStringUtf83 = strUserName != null ? encodeStringUtf8(strUserName) : EmptyArrays.EMPTY_BYTES;
        if (mqttConnectVariableHeaderVariableHeader.hasUserName()) {
            length += bArrEncodeStringUtf83.length + 2;
        }
        byte[] bArrPasswordInBytes = mqttConnectPayloadPayload.passwordInBytes();
        if (bArrPasswordInBytes == null) {
            bArrPasswordInBytes = EmptyArrays.EMPTY_BYTES;
        }
        if (mqttConnectVariableHeaderVariableHeader.hasPassword()) {
            length += bArrPasswordInBytes.length + 2;
        }
        byte[] bArrProtocolNameBytes = mqttVersionFromProtocolNameAndLevel.protocolNameBytes();
        int length2 = bArrProtocolNameBytes.length + 2 + 4 + length;
        ByteBuf byteBufBuffer = byteBufAllocator.buffer(getVariableLengthInt(length2) + 1 + length2);
        byteBufBuffer.writeByte(getFixedHeaderByte1(mqttFixedHeaderFixedHeader));
        writeVariableLengthInt(byteBufBuffer, length2);
        byteBufBuffer.writeShort(bArrProtocolNameBytes.length);
        byteBufBuffer.writeBytes(bArrProtocolNameBytes);
        byteBufBuffer.writeByte(mqttConnectVariableHeaderVariableHeader.version());
        byteBufBuffer.writeByte(getConnVariableHeaderFlag(mqttConnectVariableHeaderVariableHeader));
        byteBufBuffer.writeShort(mqttConnectVariableHeaderVariableHeader.keepAliveTimeSeconds());
        byteBufBuffer.writeShort(bArrEncodeStringUtf8.length);
        byteBufBuffer.writeBytes(bArrEncodeStringUtf8, 0, bArrEncodeStringUtf8.length);
        if (mqttConnectVariableHeaderVariableHeader.isWillFlag()) {
            byteBufBuffer.writeShort(bArrEncodeStringUtf82.length);
            byteBufBuffer.writeBytes(bArrEncodeStringUtf82, 0, bArrEncodeStringUtf82.length);
            byteBufBuffer.writeShort(bArrWillMessageInBytes.length);
            byteBufBuffer.writeBytes(bArrWillMessageInBytes, 0, bArrWillMessageInBytes.length);
        }
        if (mqttConnectVariableHeaderVariableHeader.hasUserName()) {
            byteBufBuffer.writeShort(bArrEncodeStringUtf83.length);
            byteBufBuffer.writeBytes(bArrEncodeStringUtf83, 0, bArrEncodeStringUtf83.length);
        }
        if (mqttConnectVariableHeaderVariableHeader.hasPassword()) {
            byteBufBuffer.writeShort(bArrPasswordInBytes.length);
            byteBufBuffer.writeBytes(bArrPasswordInBytes, 0, bArrPasswordInBytes.length);
        }
        return byteBufBuffer;
    }

    private static ByteBuf encodeMessageWithOnlySingleByteFixedHeader(ByteBufAllocator byteBufAllocator, MqttMessage mqttMessage) {
        MqttFixedHeader mqttFixedHeaderFixedHeader = mqttMessage.fixedHeader();
        ByteBuf byteBufBuffer = byteBufAllocator.buffer(2);
        byteBufBuffer.writeByte(getFixedHeaderByte1(mqttFixedHeaderFixedHeader));
        byteBufBuffer.writeByte(0);
        return byteBufBuffer;
    }

    private static ByteBuf encodeMessageWithOnlySingleByteFixedHeaderAndMessageId(ByteBufAllocator byteBufAllocator, MqttMessage mqttMessage) {
        MqttFixedHeader mqttFixedHeaderFixedHeader = mqttMessage.fixedHeader();
        int iMessageId = ((MqttMessageIdVariableHeader) mqttMessage.variableHeader()).messageId();
        ByteBuf byteBufBuffer = byteBufAllocator.buffer(getVariableLengthInt(2) + 1 + 2);
        byteBufBuffer.writeByte(getFixedHeaderByte1(mqttFixedHeaderFixedHeader));
        writeVariableLengthInt(byteBufBuffer, 2);
        byteBufBuffer.writeShort(iMessageId);
        return byteBufBuffer;
    }

    private static ByteBuf encodePublishMessage(ByteBufAllocator byteBufAllocator, MqttPublishMessage mqttPublishMessage) {
        MqttFixedHeader mqttFixedHeaderFixedHeader = mqttPublishMessage.fixedHeader();
        MqttPublishVariableHeader mqttPublishVariableHeaderVariableHeader = mqttPublishMessage.variableHeader();
        ByteBuf byteBufDuplicate = mqttPublishMessage.payload().duplicate();
        byte[] bArrEncodeStringUtf8 = encodeStringUtf8(mqttPublishVariableHeaderVariableHeader.topicName());
        int length = byteBufDuplicate.readableBytes() + bArrEncodeStringUtf8.length + 2 + (mqttFixedHeaderFixedHeader.qosLevel().value() <= 0 ? 0 : 2);
        ByteBuf byteBufBuffer = byteBufAllocator.buffer(getVariableLengthInt(length) + 1 + length);
        byteBufBuffer.writeByte(getFixedHeaderByte1(mqttFixedHeaderFixedHeader));
        writeVariableLengthInt(byteBufBuffer, length);
        byteBufBuffer.writeShort(bArrEncodeStringUtf8.length);
        byteBufBuffer.writeBytes(bArrEncodeStringUtf8);
        if (mqttFixedHeaderFixedHeader.qosLevel().value() > 0) {
            byteBufBuffer.writeShort(mqttPublishVariableHeaderVariableHeader.messageId());
        }
        byteBufBuffer.writeBytes(byteBufDuplicate);
        return byteBufBuffer;
    }

    private static byte[] encodeStringUtf8(String str) {
        return str.getBytes(CharsetUtil.UTF_8);
    }

    private static ByteBuf encodeSubAckMessage(ByteBufAllocator byteBufAllocator, MqttSubAckMessage mqttSubAckMessage) {
        int size = mqttSubAckMessage.payload().grantedQoSLevels().size() + 2;
        ByteBuf byteBufBuffer = byteBufAllocator.buffer(getVariableLengthInt(size) + 1 + size);
        byteBufBuffer.writeByte(getFixedHeaderByte1(mqttSubAckMessage.fixedHeader()));
        writeVariableLengthInt(byteBufBuffer, size);
        byteBufBuffer.writeShort(mqttSubAckMessage.variableHeader().messageId());
        Iterator<Integer> it = mqttSubAckMessage.payload().grantedQoSLevels().iterator();
        while (it.hasNext()) {
            byteBufBuffer.writeByte(it.next().intValue());
        }
        return byteBufBuffer;
    }

    private static ByteBuf encodeSubscribeMessage(ByteBufAllocator byteBufAllocator, MqttSubscribeMessage mqttSubscribeMessage) {
        MqttFixedHeader mqttFixedHeaderFixedHeader = mqttSubscribeMessage.fixedHeader();
        MqttMessageIdVariableHeader mqttMessageIdVariableHeaderVariableHeader = mqttSubscribeMessage.variableHeader();
        MqttSubscribePayload mqttSubscribePayloadPayload = mqttSubscribeMessage.payload();
        Iterator<MqttTopicSubscription> it = mqttSubscribePayloadPayload.topicSubscriptions().iterator();
        int length = 0;
        while (it.hasNext()) {
            length = encodeStringUtf8(it.next().topicName()).length + 2 + length + 1;
        }
        int i2 = 2 + length;
        ByteBuf byteBufBuffer = byteBufAllocator.buffer(getVariableLengthInt(i2) + 1 + i2);
        byteBufBuffer.writeByte(getFixedHeaderByte1(mqttFixedHeaderFixedHeader));
        writeVariableLengthInt(byteBufBuffer, i2);
        byteBufBuffer.writeShort(mqttMessageIdVariableHeaderVariableHeader.messageId());
        for (MqttTopicSubscription mqttTopicSubscription : mqttSubscribePayloadPayload.topicSubscriptions()) {
            byte[] bArrEncodeStringUtf8 = encodeStringUtf8(mqttTopicSubscription.topicName());
            byteBufBuffer.writeShort(bArrEncodeStringUtf8.length);
            byteBufBuffer.writeBytes(bArrEncodeStringUtf8, 0, bArrEncodeStringUtf8.length);
            byteBufBuffer.writeByte(mqttTopicSubscription.qualityOfService().value());
        }
        return byteBufBuffer;
    }

    private static ByteBuf encodeUnsubscribeMessage(ByteBufAllocator byteBufAllocator, MqttUnsubscribeMessage mqttUnsubscribeMessage) {
        MqttFixedHeader mqttFixedHeaderFixedHeader = mqttUnsubscribeMessage.fixedHeader();
        MqttMessageIdVariableHeader mqttMessageIdVariableHeaderVariableHeader = mqttUnsubscribeMessage.variableHeader();
        MqttUnsubscribePayload mqttUnsubscribePayloadPayload = mqttUnsubscribeMessage.payload();
        Iterator<String> it = mqttUnsubscribePayloadPayload.topics().iterator();
        int length = 0;
        while (it.hasNext()) {
            length += encodeStringUtf8(it.next()).length + 2;
        }
        int i2 = 2 + length;
        ByteBuf byteBufBuffer = byteBufAllocator.buffer(getVariableLengthInt(i2) + 1 + i2);
        byteBufBuffer.writeByte(getFixedHeaderByte1(mqttFixedHeaderFixedHeader));
        writeVariableLengthInt(byteBufBuffer, i2);
        byteBufBuffer.writeShort(mqttMessageIdVariableHeaderVariableHeader.messageId());
        Iterator<String> it2 = mqttUnsubscribePayloadPayload.topics().iterator();
        while (it2.hasNext()) {
            byte[] bArrEncodeStringUtf8 = encodeStringUtf8(it2.next());
            byteBufBuffer.writeShort(bArrEncodeStringUtf8.length);
            byteBufBuffer.writeBytes(bArrEncodeStringUtf8, 0, bArrEncodeStringUtf8.length);
        }
        return byteBufBuffer;
    }

    private static int getConnVariableHeaderFlag(MqttConnectVariableHeader mqttConnectVariableHeader) {
        int i2 = mqttConnectVariableHeader.hasUserName() ? 128 : 0;
        if (mqttConnectVariableHeader.hasPassword()) {
            i2 |= 64;
        }
        if (mqttConnectVariableHeader.isWillRetain()) {
            i2 |= 32;
        }
        int iWillQos = i2 | ((mqttConnectVariableHeader.willQos() & 3) << 3);
        if (mqttConnectVariableHeader.isWillFlag()) {
            iWillQos |= 4;
        }
        return mqttConnectVariableHeader.isCleanSession() ? iWillQos | 2 : iWillQos;
    }

    private static int getFixedHeaderByte1(MqttFixedHeader mqttFixedHeader) {
        int iValue = (mqttFixedHeader.messageType().value() << 4) | 0;
        if (mqttFixedHeader.isDup()) {
            iValue |= 8;
        }
        int iValue2 = iValue | (mqttFixedHeader.qosLevel().value() << 1);
        return mqttFixedHeader.isRetain() ? iValue2 | 1 : iValue2;
    }

    private static int getVariableLengthInt(int i2) {
        int i3 = 0;
        do {
            i2 /= 128;
            i3++;
        } while (i2 > 0);
        return i3;
    }

    private static void writeVariableLengthInt(ByteBuf byteBuf, int i2) {
        do {
            int i3 = i2 % 128;
            i2 /= 128;
            if (i2 > 0) {
                i3 |= 128;
            }
            byteBuf.writeByte(i3);
        } while (i2 > 0);
    }

    /* JADX INFO: renamed from: encode, reason: avoid collision after fix types in other method */
    public void encode2(ChannelHandlerContext channelHandlerContext, MqttMessage mqttMessage, List<Object> list) {
        list.add(doEncode(channelHandlerContext.alloc(), mqttMessage));
    }

    @Override // io.netty.handler.codec.MessageToMessageEncoder
    public /* bridge */ /* synthetic */ void encode(ChannelHandlerContext channelHandlerContext, MqttMessage mqttMessage, List list) {
        encode2(channelHandlerContext, mqttMessage, (List<Object>) list);
    }
}