// 
// Decompiled by Procyon v0.6.0
// 

package io.netty.handler.codec.quic;

import io.netty.util.internal.logging.InternalLoggerFactory;
import java.io.IOException;
import java.io.OutputStream;
import java.io.DataOutputStream;
import java.io.ByteArrayOutputStream;
import java.util.concurrent.TimeUnit;
import java.util.Arrays;
import io.netty.util.internal.EmptyArrays;
import org.jetbrains.annotations.Nullable;
import io.netty.util.internal.logging.InternalLogger;

final class BoringSSLSessionCallback
{
    private static final InternalLogger logger;
    private final QuicClientSessionCache sessionCache;
    private final QuicheQuicSslEngineMap engineMap;
    
    BoringSSLSessionCallback(final QuicheQuicSslEngineMap engineMap, @Nullable final QuicClientSessionCache sessionCache) {
        this.engineMap = engineMap;
        this.sessionCache = sessionCache;
    }
    
    void newSession(final long ssl, final long creationTime, final long timeout, final byte[] session, final boolean isSingleUse, byte[] peerParams) {
        if (this.sessionCache == null) {
            return;
        }
        final QuicheQuicSslEngine engine = this.engineMap.get(ssl);
        if (engine == null) {
            BoringSSLSessionCallback.logger.warn("engine is null ssl: {}", (Object)ssl);
            return;
        }
        if (peerParams == null) {
            peerParams = EmptyArrays.EMPTY_BYTES;
        }
        if (BoringSSLSessionCallback.logger.isDebugEnabled()) {
            BoringSSLSessionCallback.logger.debug("ssl: {}, session: {}, peerParams: {}", ssl, Arrays.toString(session), Arrays.toString(peerParams));
        }
        final byte[] quicSession = toQuicheQuicSession(session, peerParams);
        if (quicSession != null) {
            BoringSSLSessionCallback.logger.debug("save session host={}, port={}", engine.getSession().getPeerHost(), engine.getSession().getPeerPort());
            this.sessionCache.saveSession(engine.getSession().getPeerHost(), engine.getSession().getPeerPort(), TimeUnit.SECONDS.toMillis(creationTime), TimeUnit.SECONDS.toMillis(timeout), quicSession, isSingleUse);
        }
    }
    
    private static byte[] toQuicheQuicSession(final byte[] sslSession, final byte[] peerParams) {
        if (sslSession != null && peerParams != null) {
            try (final ByteArrayOutputStream bos = new ByteArrayOutputStream();
                 final DataOutputStream dos = new DataOutputStream(bos)) {
                dos.writeLong(sslSession.length);
                dos.write(sslSession);
                dos.writeLong(peerParams.length);
                dos.write(peerParams);
                return bos.toByteArray();
            }
            catch (final IOException e) {
                return null;
            }
        }
        return null;
    }
    
    static {
        logger = InternalLoggerFactory.getInstance(BoringSSLSessionCallback.class);
    }
}