package org.eclipse.paho.mqttv5.common.packet;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import org.eclipse.paho.mqttv5.common.MqttException;
import org.eclipse.paho.mqttv5.common.util.MqttTopicValidator;

/* JADX INFO: loaded from: classes2.dex */
public class MqttProperties {
    public static final byte ASSIGNED_CLIENT_IDENTIFIER_IDENTIFIER = 18;
    public static final byte AUTH_DATA_IDENTIFIER = 22;
    public static final byte AUTH_METHOD_IDENTIFIER = 21;
    public static final byte CONTENT_TYPE_IDENTIFIER = 3;
    public static final byte CORRELATION_DATA_IDENTIFIER = 9;
    public static final byte MAXIMUM_PACKET_SIZE_IDENTIFIER = 39;
    public static final byte MAXIMUM_QOS_IDENTIFIER = 36;
    public static final byte MESSAGE_EXPIRY_INTERVAL_IDENTIFIER = 2;
    public static final byte PAYLOAD_FORMAT_INDICATOR_IDENTIFIER = 1;
    public static final byte REASON_STRING_IDENTIFIER = 31;
    public static final byte RECEIVE_MAXIMUM_IDENTIFIER = 33;
    public static final byte REQUEST_PROBLEM_INFO_IDENTIFIER = 23;
    public static final byte REQUEST_RESPONSE_INFO_IDENTIFIER = 25;
    public static final byte RESPONSE_INFO_IDENTIFIER = 26;
    public static final byte RESPONSE_TOPIC_IDENTIFIER = 8;
    public static final byte RETAIN_AVAILABLE_IDENTIFIER = 37;
    public static final byte SERVER_KEEP_ALIVE_IDENTIFIER = 19;
    public static final byte SERVER_REFERENCE_IDENTIFIER = 28;
    public static final byte SESSION_EXPIRY_INTERVAL_IDENTIFIER = 17;
    public static final byte SHARED_SUBSCRIPTION_AVAILABLE_IDENTIFIER = 42;
    public static final byte SUBSCRIPTION_AVAILABLE_IDENTIFIER = 41;
    public static final byte SUBSCRIPTION_IDENTIFIER = 11;
    public static final byte SUBSCRIPTION_IDENTIFIER_MULTI = 126;
    public static final byte SUBSCRIPTION_IDENTIFIER_SINGLE = 127;
    public static final byte TOPIC_ALIAS_IDENTIFIER = 35;
    public static final byte TOPIC_ALIAS_MAXIMUM_IDENTIFIER = 34;
    public static final byte USER_DEFINED_PAIR_IDENTIFIER = 38;
    public static final byte WILDCARD_SUB_AVAILABLE_IDENTIFIER = 40;
    public static final byte WILL_DELAY_INTERVAL_IDENTIFIER = 24;
    private String assignedClientIdentifier;
    private byte[] authenticationData;
    private String authenticationMethod;
    private String contentType;
    private byte[] correlationData;
    private Long maximumPacketSize;
    private Integer maximumQoS;
    private Long messageExpiryInterval;
    private String reasonString;
    private Integer receiveMaximum;
    private Boolean requestProblemInfo;
    private Boolean requestResponseInfo;
    private String responseInfo;
    private String responseTopic;
    private Integer serverKeepAlive;
    private String serverReference;
    private Long sessionExpiryInterval;
    private Integer subscribeSubscriptionIdentifier;
    private Integer topicAlias;
    private Integer topicAliasMaximum;
    private List<Byte> validProperties;
    private Long willDelayInterval;
    private Boolean payloadFormat = false;
    private Boolean retainAvailable = null;
    private Boolean wildcardSubscriptionsAvailable = null;
    private Boolean subscriptionIdentifiersAvailable = null;
    private Boolean sharedSubscriptionAvailable = null;
    private List<UserProperty> userProperties = new ArrayList();
    private List<Integer> publishSubscriptionIdentifiers = new ArrayList();

    public MqttProperties() {
    }

    public MqttProperties(Byte[] bArr) {
        this.validProperties = Arrays.asList(bArr);
    }

    public void setValidProperties(Byte[] bArr) {
        this.validProperties = Arrays.asList(bArr);
    }

    public byte[] encodeProperties() throws MqttException {
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream);
            if (this.payloadFormat.booleanValue() && this.validProperties.contains((byte) 1)) {
                dataOutputStream.write(1);
                dataOutputStream.writeByte(1);
            }
            if (this.messageExpiryInterval != null && this.validProperties.contains((byte) 2)) {
                dataOutputStream.write(2);
                MqttDataTypes.writeUnsignedFourByteInt(this.messageExpiryInterval.longValue(), dataOutputStream);
            }
            if (this.contentType != null && this.validProperties.contains((byte) 3)) {
                dataOutputStream.write(3);
                MqttDataTypes.encodeUTF8(dataOutputStream, this.contentType);
            }
            if (this.responseTopic != null && this.validProperties.contains((byte) 8)) {
                dataOutputStream.write(8);
                MqttDataTypes.encodeUTF8(dataOutputStream, this.responseTopic);
            }
            if (this.correlationData != null && this.validProperties.contains((byte) 9)) {
                dataOutputStream.write(9);
                dataOutputStream.writeShort(this.correlationData.length);
                dataOutputStream.write(this.correlationData);
            }
            if (!this.publishSubscriptionIdentifiers.isEmpty() && this.validProperties.contains(Byte.valueOf(SUBSCRIPTION_IDENTIFIER_MULTI))) {
                for (Integer num : this.publishSubscriptionIdentifiers) {
                    dataOutputStream.write(11);
                    dataOutputStream.write(MqttDataTypes.encodeVariableByteInteger(num.intValue()));
                }
            }
            if (this.subscribeSubscriptionIdentifier != null && this.validProperties.contains((byte) 127)) {
                dataOutputStream.write(11);
                dataOutputStream.write(MqttDataTypes.encodeVariableByteInteger(this.subscribeSubscriptionIdentifier.intValue()));
            }
            if (this.sessionExpiryInterval != null && this.validProperties.contains((byte) 17)) {
                dataOutputStream.write(17);
                MqttDataTypes.writeUnsignedFourByteInt(this.sessionExpiryInterval.longValue(), dataOutputStream);
            }
            if (this.assignedClientIdentifier != null && this.validProperties.contains((byte) 18)) {
                dataOutputStream.write(18);
                MqttDataTypes.encodeUTF8(dataOutputStream, this.assignedClientIdentifier);
            }
            if (this.serverKeepAlive != null && this.validProperties.contains((byte) 19)) {
                dataOutputStream.write(19);
                dataOutputStream.writeShort(this.serverKeepAlive.intValue());
            }
            if (this.authenticationMethod != null && this.validProperties.contains((byte) 21)) {
                dataOutputStream.write(21);
                MqttDataTypes.encodeUTF8(dataOutputStream, this.authenticationMethod);
            }
            if (this.authenticationData != null && this.validProperties.contains((byte) 22)) {
                dataOutputStream.write(22);
                dataOutputStream.writeShort(this.authenticationData.length);
                dataOutputStream.write(this.authenticationData);
            }
            if (this.requestProblemInfo != null && this.validProperties.contains((byte) 23)) {
                dataOutputStream.write(23);
                dataOutputStream.write(this.requestProblemInfo.booleanValue() ? 1 : 0);
            }
            if (this.willDelayInterval != null && this.validProperties.contains((byte) 24)) {
                dataOutputStream.write(24);
                MqttDataTypes.writeUnsignedFourByteInt(this.willDelayInterval.longValue(), dataOutputStream);
            }
            if (this.requestResponseInfo != null && this.validProperties.contains((byte) 25)) {
                dataOutputStream.write(25);
                dataOutputStream.write(this.requestResponseInfo.booleanValue() ? 1 : 0);
            }
            if (this.responseInfo != null && this.validProperties.contains((byte) 26)) {
                dataOutputStream.write(26);
                MqttDataTypes.encodeUTF8(dataOutputStream, this.responseInfo);
            }
            if (this.serverReference != null && this.validProperties.contains((byte) 28)) {
                dataOutputStream.write(28);
                MqttDataTypes.encodeUTF8(dataOutputStream, this.serverReference);
            }
            if (this.reasonString != null && this.validProperties.contains((byte) 31)) {
                dataOutputStream.write(31);
                MqttDataTypes.encodeUTF8(dataOutputStream, this.reasonString);
            }
            if (this.receiveMaximum != null && this.validProperties.contains((byte) 33)) {
                dataOutputStream.write(33);
                dataOutputStream.writeShort(this.receiveMaximum.intValue());
            }
            if (this.topicAliasMaximum != null && this.validProperties.contains((byte) 34)) {
                dataOutputStream.write(34);
                dataOutputStream.writeShort(this.topicAliasMaximum.intValue());
            }
            if (this.topicAlias != null && this.validProperties.contains((byte) 35)) {
                dataOutputStream.write(35);
                dataOutputStream.writeShort(this.topicAlias.intValue());
            }
            if (this.maximumQoS != null && this.validProperties.contains((byte) 36)) {
                dataOutputStream.write(36);
                dataOutputStream.writeByte(this.maximumQoS.intValue());
            }
            if (this.retainAvailable != null && this.validProperties.contains((byte) 37)) {
                dataOutputStream.write(37);
                dataOutputStream.writeBoolean(this.retainAvailable.booleanValue());
            }
            List<UserProperty> list = this.userProperties;
            if (list != null && !list.isEmpty() && this.validProperties.contains((byte) 38)) {
                for (UserProperty userProperty : this.userProperties) {
                    dataOutputStream.writeByte(38);
                    MqttDataTypes.encodeUTF8(dataOutputStream, userProperty.getKey());
                    MqttDataTypes.encodeUTF8(dataOutputStream, userProperty.getValue());
                }
            }
            if (this.maximumPacketSize != null && this.validProperties.contains((byte) 39)) {
                dataOutputStream.write(39);
                MqttDataTypes.writeUnsignedFourByteInt(this.maximumPacketSize.longValue(), dataOutputStream);
            }
            if (this.wildcardSubscriptionsAvailable != null && this.validProperties.contains((byte) 40)) {
                dataOutputStream.write(40);
                dataOutputStream.writeBoolean(this.wildcardSubscriptionsAvailable.booleanValue());
            }
            if (this.subscriptionIdentifiersAvailable != null && this.validProperties.contains((byte) 41)) {
                dataOutputStream.write(41);
                dataOutputStream.writeBoolean(this.subscriptionIdentifiersAvailable.booleanValue());
            }
            if (this.sharedSubscriptionAvailable != null && this.validProperties.contains((byte) 42)) {
                dataOutputStream.write(42);
                dataOutputStream.writeBoolean(this.sharedSubscriptionAvailable.booleanValue());
            }
            int size = dataOutputStream.size();
            dataOutputStream.flush();
            ByteArrayOutputStream byteArrayOutputStream2 = new ByteArrayOutputStream();
            byteArrayOutputStream2.write(MqttDataTypes.encodeVariableByteInteger(size));
            byteArrayOutputStream2.write(byteArrayOutputStream.toByteArray());
            return byteArrayOutputStream2.toByteArray();
        } catch (IOException e) {
            throw new MqttException(e);
        }
    }

    public void decodeProperties(DataInputStream dataInputStream) throws MqttException, IOException {
        int value = MqttDataTypes.readVariableByteInteger(dataInputStream).getValue();
        if (value > 0) {
            byte[] bArr = new byte[value];
            dataInputStream.read(bArr, 0, value);
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bArr);
            ArrayList arrayList = new ArrayList();
            DataInputStream dataInputStream2 = new DataInputStream(byteArrayInputStream);
            while (dataInputStream2.available() > 0) {
                byte b = dataInputStream2.readByte();
                if (this.validProperties.contains(Byte.valueOf(b))) {
                    if (!arrayList.contains(Byte.valueOf(b))) {
                        arrayList.add(Byte.valueOf(b));
                    } else if (b != 11 && b != 38) {
                        throw new MqttException(MqttException.REASON_CODE_DUPLICATE_PROPERTY);
                    }
                    if (b == 1) {
                        this.payloadFormat = Boolean.valueOf(dataInputStream2.readBoolean());
                    } else if (b == 2) {
                        this.messageExpiryInterval = MqttDataTypes.readUnsignedFourByteInt(dataInputStream2);
                    } else if (b == 3) {
                        this.contentType = MqttDataTypes.decodeUTF8(dataInputStream2);
                    } else if (b == 8) {
                        this.responseTopic = MqttDataTypes.decodeUTF8(dataInputStream2);
                    } else if (b == 9) {
                        int i = dataInputStream2.readShort();
                        byte[] bArr2 = new byte[i];
                        this.correlationData = bArr2;
                        dataInputStream2.read(bArr2, 0, i);
                    } else if (b == 11) {
                        int value2 = MqttDataTypes.readVariableByteInteger(dataInputStream2).getValue();
                        this.publishSubscriptionIdentifiers.add(Integer.valueOf(value2));
                        this.subscribeSubscriptionIdentifier = Integer.valueOf(value2);
                    } else if (b == 17) {
                        this.sessionExpiryInterval = MqttDataTypes.readUnsignedFourByteInt(dataInputStream2);
                    } else if (b == 18) {
                        this.assignedClientIdentifier = MqttDataTypes.decodeUTF8(dataInputStream2);
                    } else if (b == 19) {
                        this.serverKeepAlive = Integer.valueOf(MqttDataTypes.readUnsignedTwoByteInt(dataInputStream2));
                    } else if (b == 21) {
                        this.authenticationMethod = MqttDataTypes.decodeUTF8(dataInputStream2);
                    } else if (b == 22) {
                        int i2 = dataInputStream2.readShort();
                        byte[] bArr3 = new byte[i2];
                        this.authenticationData = bArr3;
                        dataInputStream2.read(bArr3, 0, i2);
                    } else if (b == 23) {
                        this.requestProblemInfo = Boolean.valueOf(dataInputStream2.read() != 0);
                    } else if (b == 24) {
                        this.willDelayInterval = MqttDataTypes.readUnsignedFourByteInt(dataInputStream2);
                    } else if (b == 25) {
                        this.requestResponseInfo = Boolean.valueOf(dataInputStream2.read() != 0);
                    } else if (b == 26) {
                        this.responseInfo = MqttDataTypes.decodeUTF8(dataInputStream2);
                    } else if (b == 28) {
                        this.serverReference = MqttDataTypes.decodeUTF8(dataInputStream2);
                    } else if (b == 31) {
                        this.reasonString = MqttDataTypes.decodeUTF8(dataInputStream2);
                    } else if (b == 33) {
                        this.receiveMaximum = Integer.valueOf(dataInputStream2.readShort());
                    } else if (b == 34) {
                        this.topicAliasMaximum = Integer.valueOf(dataInputStream2.readShort());
                    } else if (b == 35) {
                        this.topicAlias = Integer.valueOf(dataInputStream2.readShort());
                    } else if (b == 36) {
                        this.maximumQoS = Integer.valueOf(dataInputStream2.read());
                    } else if (b == 37) {
                        this.retainAvailable = Boolean.valueOf(dataInputStream2.readBoolean());
                    } else if (b == 38) {
                        this.userProperties.add(new UserProperty(MqttDataTypes.decodeUTF8(dataInputStream2), MqttDataTypes.decodeUTF8(dataInputStream2)));
                    } else if (b == 39) {
                        this.maximumPacketSize = MqttDataTypes.readUnsignedFourByteInt(dataInputStream2);
                    } else if (b == 40) {
                        this.wildcardSubscriptionsAvailable = Boolean.valueOf(dataInputStream2.readBoolean());
                    } else if (b == 41) {
                        this.subscriptionIdentifiersAvailable = Boolean.valueOf(dataInputStream2.readBoolean());
                    } else if (b == 42) {
                        this.sharedSubscriptionAvailable = Boolean.valueOf(dataInputStream2.readBoolean());
                    } else {
                        dataInputStream2.close();
                        throw new MqttException(MqttException.REASON_CODE_INVALID_IDENTIFIER);
                    }
                } else {
                    dataInputStream2.close();
                    throw new MqttException(MqttException.REASON_CODE_INVALID_IDENTIFIER);
                }
            }
        }
    }

    public List<Byte> getValidProperties() {
        return this.validProperties;
    }

    public Boolean requestResponseInfo() {
        return this.requestResponseInfo;
    }

    public void setRequestResponseInfo(Boolean bool) {
        this.requestResponseInfo = bool;
    }

    public Boolean requestProblemInfo() {
        return this.requestProblemInfo;
    }

    public void setRequestProblemInfo(Boolean bool) {
        this.requestProblemInfo = bool;
    }

    public Long getWillDelayInterval() {
        return this.willDelayInterval;
    }

    public void setWillDelayInterval(Long l) {
        MqttDataTypes.validateFourByteInt(l);
        this.willDelayInterval = l;
    }

    public Integer getReceiveMaximum() {
        return this.receiveMaximum;
    }

    public void setReceiveMaximum(Integer num) {
        MqttDataTypes.validateTwoByteInt(num);
        this.receiveMaximum = num;
    }

    public Integer getMaximumQoS() {
        return this.maximumQoS;
    }

    public void setMaximumQoS(Integer num) {
        this.maximumQoS = num;
    }

    public Long getMaximumPacketSize() {
        return this.maximumPacketSize;
    }

    public void setMaximumPacketSize(Long l) {
        MqttDataTypes.validateFourByteInt(l);
        this.maximumPacketSize = l;
    }

    public Boolean isRetainAvailable() {
        Boolean bool = this.retainAvailable;
        if (bool == null || bool.booleanValue()) {
            return true;
        }
        return false;
    }

    public void setRetainAvailable(boolean z) {
        this.retainAvailable = Boolean.valueOf(z);
    }

    public String getAssignedClientIdentifier() {
        return this.assignedClientIdentifier;
    }

    public void setAssignedClientIdentifier(String str) {
        this.assignedClientIdentifier = str;
    }

    public Integer getTopicAliasMaximum() {
        return this.topicAliasMaximum;
    }

    public void setTopicAliasMaximum(Integer num) {
        MqttDataTypes.validateTwoByteInt(num);
        this.topicAliasMaximum = num;
    }

    public Integer getTopicAlias() {
        return this.topicAlias;
    }

    public void setTopicAlias(Integer num) {
        MqttDataTypes.validateTwoByteInt(num);
        this.topicAlias = num;
    }

    public Integer getServerKeepAlive() {
        return this.serverKeepAlive;
    }

    public void setServerKeepAlive(Integer num) {
        MqttDataTypes.validateTwoByteInt(num);
        this.serverKeepAlive = num;
    }

    public String getResponseInfo() {
        return this.responseInfo;
    }

    public void setResponseInfo(String str) {
        this.responseInfo = str;
    }

    public String getServerReference() {
        return this.serverReference;
    }

    public void setServerReference(String str) {
        this.serverReference = str;
    }

    public boolean isWildcardSubscriptionsAvailable() {
        Boolean bool = this.wildcardSubscriptionsAvailable;
        return bool == null || bool.booleanValue();
    }

    public void setWildcardSubscriptionsAvailable(boolean z) {
        this.wildcardSubscriptionsAvailable = Boolean.valueOf(z);
    }

    public boolean isSubscriptionIdentifiersAvailable() {
        Boolean bool = this.subscriptionIdentifiersAvailable;
        return bool == null || bool.booleanValue();
    }

    public void setSubscriptionIdentifiersAvailable(boolean z) {
        this.subscriptionIdentifiersAvailable = Boolean.valueOf(z);
    }

    public boolean isSharedSubscriptionAvailable() {
        Boolean bool = this.sharedSubscriptionAvailable;
        return bool == null || bool.booleanValue();
    }

    public void setSharedSubscriptionAvailable(boolean z) {
        this.sharedSubscriptionAvailable = Boolean.valueOf(z);
    }

    public Long getSessionExpiryInterval() {
        return this.sessionExpiryInterval;
    }

    public void setSessionExpiryInterval(Long l) {
        MqttDataTypes.validateFourByteInt(l);
        this.sessionExpiryInterval = l;
    }

    public String getAuthenticationMethod() {
        return this.authenticationMethod;
    }

    public void setAuthenticationMethod(String str) {
        this.authenticationMethod = str;
    }

    public byte[] getAuthenticationData() {
        return this.authenticationData;
    }

    public void setAuthenticationData(byte[] bArr) {
        this.authenticationData = bArr;
    }

    public String getReasonString() {
        return this.reasonString;
    }

    public void setReasonString(String str) {
        this.reasonString = str;
    }

    public List<UserProperty> getUserProperties() {
        return this.userProperties;
    }

    public void setUserProperties(List<UserProperty> list) {
        this.userProperties = list;
    }

    public boolean getPayloadFormat() {
        return this.payloadFormat.booleanValue();
    }

    public void setPayloadFormat(boolean z) {
        this.payloadFormat = Boolean.valueOf(z);
    }

    public Long getMessageExpiryInterval() {
        return this.messageExpiryInterval;
    }

    public void setMessageExpiryInterval(Long l) {
        MqttDataTypes.validateFourByteInt(l);
        this.messageExpiryInterval = l;
    }

    public String getContentType() {
        return this.contentType;
    }

    public void setContentType(String str) {
        this.contentType = str;
    }

    public String getResponseTopic() {
        return this.responseTopic;
    }

    public void setResponseTopic(String str) {
        if (str != null) {
            MqttTopicValidator.validate(str, false, true);
        }
        this.responseTopic = str;
    }

    public byte[] getCorrelationData() {
        return this.correlationData;
    }

    public void setCorrelationData(byte[] bArr) {
        this.correlationData = bArr;
    }

    public List<Integer> getSubscriptionIdentifiers() {
        return this.publishSubscriptionIdentifiers;
    }

    public void setSubscriptionIdentifiers(List<Integer> list) {
        Iterator<Integer> it = list.iterator();
        while (it.hasNext()) {
            MqttDataTypes.validateVariableByteInt(it.next().intValue());
        }
        this.publishSubscriptionIdentifiers = list;
    }

    public Integer getSubscriptionIdentifier() {
        return this.subscribeSubscriptionIdentifier;
    }

    public void setSubscriptionIdentifier(Integer num) {
        MqttDataTypes.validateVariableByteInt(num.intValue());
        this.subscribeSubscriptionIdentifier = num;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("MqttProperties [validProperties=" + this.validProperties);
        if (this.requestResponseInfo != null) {
            sb.append(", requestResponseInfo=" + this.requestResponseInfo);
        }
        if (this.requestProblemInfo != null) {
            sb.append(", requestProblemInfo=" + this.requestProblemInfo);
        }
        if (this.willDelayInterval != null) {
            sb.append(", willDelayInterval=" + this.willDelayInterval);
        }
        if (this.receiveMaximum != null) {
            sb.append(", receiveMaximum=" + this.receiveMaximum);
        }
        if (this.maximumQoS != null) {
            sb.append(", maximumQoS=" + this.maximumQoS);
        }
        if (this.maximumPacketSize != null) {
            sb.append(", maximumPacketSize=" + this.maximumPacketSize);
        }
        if (this.retainAvailable != null) {
            sb.append(", retainAvailable=" + this.retainAvailable);
        }
        if (this.assignedClientIdentifier != null) {
            sb.append(", assignedClientIdentifier=" + this.assignedClientIdentifier);
        }
        if (this.topicAliasMaximum != null) {
            sb.append(", topicAliasMaximum=" + this.topicAliasMaximum);
        }
        if (this.topicAlias != null) {
            sb.append(", topicAlias=" + this.topicAlias);
        }
        if (this.serverKeepAlive != null) {
            sb.append(", serverKeepAlive=" + this.serverKeepAlive);
        }
        if (this.responseInfo != null) {
            sb.append(", responseInfo=" + this.responseInfo);
        }
        if (this.serverReference != null) {
            sb.append(", serverReference=" + this.serverReference);
        }
        if (this.wildcardSubscriptionsAvailable != null) {
            sb.append(", wildcardSubscriptionsAvailable=" + this.wildcardSubscriptionsAvailable);
        }
        if (this.subscriptionIdentifiersAvailable != null) {
            sb.append(", subscriptionIdentifiersAvailable=" + this.subscriptionIdentifiersAvailable);
        }
        if (this.sharedSubscriptionAvailable != null) {
            sb.append(", sharedSubscriptionAvailable=" + this.sharedSubscriptionAvailable);
        }
        if (this.sessionExpiryInterval != null) {
            sb.append(", sessionExpiryInterval=" + this.sessionExpiryInterval);
        }
        if (this.authenticationMethod != null) {
            sb.append(", authenticationMethod=" + this.authenticationMethod);
        }
        if (this.authenticationData != null) {
            sb.append(", authenticationData=" + Arrays.toString(this.authenticationData));
        }
        if (this.reasonString != null) {
            sb.append(", reasonString=" + this.reasonString);
        }
        List<UserProperty> list = this.userProperties;
        if (list != null && list.size() != 0) {
            sb.append(", userProperties=" + this.userProperties);
        }
        if (this.payloadFormat.booleanValue()) {
            sb.append(", isUTF8=" + this.payloadFormat);
        }
        if (this.messageExpiryInterval != null) {
            sb.append(", messageExpiryInterval=" + this.messageExpiryInterval);
        }
        if (this.contentType != null) {
            sb.append(", contentType=" + this.contentType);
        }
        if (this.responseTopic != null) {
            sb.append(", responseTopic=" + this.responseTopic);
        }
        if (this.correlationData != null) {
            sb.append(", correlationData=" + Arrays.toString(this.correlationData));
        }
        if (this.publishSubscriptionIdentifiers.size() != 0) {
            sb.append(", subscriptionIdentifiers=" + this.publishSubscriptionIdentifiers);
        }
        sb.append("]");
        return sb.toString();
    }
}