package io.netty.handler.logging;

import g.a.a.a.a;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufHolder;
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.ChannelDuplexHandler;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPromise;
import io.netty.util.internal.StringUtil;
import io.netty.util.internal.logging.InternalLogLevel;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
import java.net.SocketAddress;
import java.util.Objects;

/* JADX INFO: loaded from: classes.dex */
@ChannelHandler.Sharable
public class LoggingHandler extends ChannelDuplexHandler {
    private static final LogLevel DEFAULT_LEVEL = LogLevel.DEBUG;
    public final InternalLogLevel internalLevel;
    private final LogLevel level;
    public final InternalLogger logger;

    public LoggingHandler() {
        this(DEFAULT_LEVEL);
    }

    public LoggingHandler(LogLevel logLevel) {
        Objects.requireNonNull(logLevel, "level");
        this.logger = InternalLoggerFactory.getInstance(getClass());
        this.level = logLevel;
        this.internalLevel = logLevel.toInternalLevel();
    }

    public LoggingHandler(Class<?> cls) {
        this(cls, DEFAULT_LEVEL);
    }

    public LoggingHandler(Class<?> cls, LogLevel logLevel) {
        Objects.requireNonNull(cls, "clazz");
        Objects.requireNonNull(logLevel, "level");
        this.logger = InternalLoggerFactory.getInstance(cls);
        this.level = logLevel;
        this.internalLevel = logLevel.toInternalLevel();
    }

    public LoggingHandler(String str) {
        this(str, DEFAULT_LEVEL);
    }

    public LoggingHandler(String str, LogLevel logLevel) {
        Objects.requireNonNull(str, "name");
        Objects.requireNonNull(logLevel, "level");
        this.logger = InternalLoggerFactory.getInstance(str);
        this.level = logLevel;
        this.internalLevel = logLevel.toInternalLevel();
    }

    private static String formatByteBuf(ChannelHandlerContext channelHandlerContext, String str, ByteBuf byteBuf) {
        String string = channelHandlerContext.channel().toString();
        int i2 = byteBuf.readableBytes();
        if (i2 == 0) {
            StringBuilder sb = new StringBuilder(str.length() + string.length() + 1 + 4);
            sb.append(string);
            sb.append(' ');
            sb.append(str);
            sb.append(": 0B");
            return sb.toString();
        }
        StringBuilder sb2 = new StringBuilder((((i2 / 16) + (i2 % 15 == 0 ? 0 : 1) + 4) * 80) + str.length() + string.length() + 1 + 2 + 10 + 1 + 2);
        sb2.append(string);
        sb2.append(' ');
        sb2.append(str);
        sb2.append(": ");
        sb2.append(i2);
        sb2.append('B');
        sb2.append(StringUtil.NEWLINE);
        ByteBufUtil.appendPrettyHexDump(sb2, byteBuf);
        return sb2.toString();
    }

    private static String formatByteBufHolder(ChannelHandlerContext channelHandlerContext, String str, ByteBufHolder byteBufHolder) {
        String string = channelHandlerContext.channel().toString();
        String string2 = byteBufHolder.toString();
        ByteBuf byteBufContent = byteBufHolder.content();
        int i2 = byteBufContent.readableBytes();
        if (i2 == 0) {
            StringBuilder sb = new StringBuilder(string2.length() + str.length() + string.length() + 1 + 2 + 4);
            sb.append(string);
            sb.append(' ');
            sb.append(str);
            sb.append(", ");
            return a.A(sb, string2, ", 0B");
        }
        StringBuilder sb2 = new StringBuilder((((i2 / 16) + (i2 % 15 == 0 ? 0 : 1) + 4) * 80) + string2.length() + str.length() + string.length() + 1 + 2 + 2 + 10 + 1 + 2);
        sb2.append(string);
        sb2.append(' ');
        sb2.append(str);
        sb2.append(": ");
        sb2.append(string2);
        sb2.append(", ");
        sb2.append(i2);
        sb2.append('B');
        sb2.append(StringUtil.NEWLINE);
        ByteBufUtil.appendPrettyHexDump(sb2, byteBufContent);
        return sb2.toString();
    }

    private static String formatSimple(ChannelHandlerContext channelHandlerContext, String str, Object obj) {
        String string = channelHandlerContext.channel().toString();
        String strValueOf = String.valueOf(obj);
        StringBuilder sb = new StringBuilder(strValueOf.length() + str.length() + string.length() + 1 + 2);
        sb.append(string);
        sb.append(' ');
        sb.append(str);
        sb.append(": ");
        sb.append(strValueOf);
        return sb.toString();
    }

    @Override // io.netty.channel.ChannelDuplexHandler, io.netty.channel.ChannelOutboundHandler
    public void bind(ChannelHandlerContext channelHandlerContext, SocketAddress socketAddress, ChannelPromise channelPromise) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "BIND", socketAddress));
        }
        channelHandlerContext.bind(socketAddress, channelPromise);
    }

    @Override // io.netty.channel.ChannelInboundHandlerAdapter, io.netty.channel.ChannelInboundHandler
    public void channelActive(ChannelHandlerContext channelHandlerContext) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "ACTIVE"));
        }
        channelHandlerContext.fireChannelActive();
    }

    @Override // io.netty.channel.ChannelInboundHandlerAdapter, io.netty.channel.ChannelInboundHandler
    public void channelInactive(ChannelHandlerContext channelHandlerContext) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "INACTIVE"));
        }
        channelHandlerContext.fireChannelInactive();
    }

    @Override // io.netty.channel.ChannelInboundHandlerAdapter, io.netty.channel.ChannelInboundHandler
    public void channelRead(ChannelHandlerContext channelHandlerContext, Object obj) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "READ", obj));
        }
        channelHandlerContext.fireChannelRead(obj);
    }

    @Override // io.netty.channel.ChannelInboundHandlerAdapter, io.netty.channel.ChannelInboundHandler
    public void channelReadComplete(ChannelHandlerContext channelHandlerContext) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "READ COMPLETE"));
        }
        channelHandlerContext.fireChannelReadComplete();
    }

    @Override // io.netty.channel.ChannelInboundHandlerAdapter, io.netty.channel.ChannelInboundHandler
    public void channelRegistered(ChannelHandlerContext channelHandlerContext) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "REGISTERED"));
        }
        channelHandlerContext.fireChannelRegistered();
    }

    @Override // io.netty.channel.ChannelInboundHandlerAdapter, io.netty.channel.ChannelInboundHandler
    public void channelUnregistered(ChannelHandlerContext channelHandlerContext) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "UNREGISTERED"));
        }
        channelHandlerContext.fireChannelUnregistered();
    }

    @Override // io.netty.channel.ChannelInboundHandlerAdapter, io.netty.channel.ChannelInboundHandler
    public void channelWritabilityChanged(ChannelHandlerContext channelHandlerContext) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "WRITABILITY CHANGED"));
        }
        channelHandlerContext.fireChannelWritabilityChanged();
    }

    @Override // io.netty.channel.ChannelDuplexHandler, io.netty.channel.ChannelOutboundHandler
    public void close(ChannelHandlerContext channelHandlerContext, ChannelPromise channelPromise) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "CLOSE"));
        }
        channelHandlerContext.close(channelPromise);
    }

    @Override // io.netty.channel.ChannelDuplexHandler, io.netty.channel.ChannelOutboundHandler
    public void connect(ChannelHandlerContext channelHandlerContext, SocketAddress socketAddress, SocketAddress socketAddress2, ChannelPromise channelPromise) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "CONNECT", socketAddress, socketAddress2));
        }
        channelHandlerContext.connect(socketAddress, socketAddress2, channelPromise);
    }

    @Override // io.netty.channel.ChannelDuplexHandler, io.netty.channel.ChannelOutboundHandler
    public void deregister(ChannelHandlerContext channelHandlerContext, ChannelPromise channelPromise) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "DEREGISTER"));
        }
        channelHandlerContext.deregister(channelPromise);
    }

    @Override // io.netty.channel.ChannelDuplexHandler, io.netty.channel.ChannelOutboundHandler
    public void disconnect(ChannelHandlerContext channelHandlerContext, ChannelPromise channelPromise) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "DISCONNECT"));
        }
        channelHandlerContext.disconnect(channelPromise);
    }

    @Override // io.netty.channel.ChannelInboundHandlerAdapter, io.netty.channel.ChannelHandlerAdapter, io.netty.channel.ChannelHandler, io.netty.channel.ChannelInboundHandler
    public void exceptionCaught(ChannelHandlerContext channelHandlerContext, Throwable th) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "EXCEPTION", th), th);
        }
        channelHandlerContext.fireExceptionCaught(th);
    }

    @Override // io.netty.channel.ChannelDuplexHandler, io.netty.channel.ChannelOutboundHandler
    public void flush(ChannelHandlerContext channelHandlerContext) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "FLUSH"));
        }
        channelHandlerContext.flush();
    }

    public String format(ChannelHandlerContext channelHandlerContext, String str) {
        String string = channelHandlerContext.channel().toString();
        StringBuilder sb = new StringBuilder(str.length() + string.length() + 1);
        sb.append(string);
        sb.append(' ');
        sb.append(str);
        return sb.toString();
    }

    public String format(ChannelHandlerContext channelHandlerContext, String str, Object obj) {
        return obj instanceof ByteBuf ? formatByteBuf(channelHandlerContext, str, (ByteBuf) obj) : obj instanceof ByteBufHolder ? formatByteBufHolder(channelHandlerContext, str, (ByteBufHolder) obj) : formatSimple(channelHandlerContext, str, obj);
    }

    public String format(ChannelHandlerContext channelHandlerContext, String str, Object obj, Object obj2) {
        if (obj2 == null) {
            return formatSimple(channelHandlerContext, str, obj);
        }
        String string = channelHandlerContext.channel().toString();
        String strValueOf = String.valueOf(obj);
        String string2 = obj2.toString();
        StringBuilder sb = new StringBuilder(string2.length() + strValueOf.length() + str.length() + string.length() + 1 + 2 + 2);
        sb.append(string);
        sb.append(' ');
        sb.append(str);
        sb.append(": ");
        sb.append(strValueOf);
        sb.append(", ");
        sb.append(string2);
        return sb.toString();
    }

    public LogLevel level() {
        return this.level;
    }

    @Override // io.netty.channel.ChannelInboundHandlerAdapter, io.netty.channel.ChannelInboundHandler
    public void userEventTriggered(ChannelHandlerContext channelHandlerContext, Object obj) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "USER_EVENT", obj));
        }
        channelHandlerContext.fireUserEventTriggered(obj);
    }

    @Override // io.netty.channel.ChannelDuplexHandler, io.netty.channel.ChannelOutboundHandler
    public void write(ChannelHandlerContext channelHandlerContext, Object obj, ChannelPromise channelPromise) {
        if (this.logger.isEnabled(this.internalLevel)) {
            this.logger.log(this.internalLevel, format(channelHandlerContext, "WRITE", obj));
        }
        channelHandlerContext.write(obj, channelPromise);
    }
}