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

package io.netty.handler.codec.quic;

import io.netty.channel.socket.DuplexChannelConfig;
import io.netty.channel.ChannelConfig;
import io.netty.channel.MessageSizeEstimator;
import io.netty.channel.WriteBufferWaterMark;
import io.netty.channel.RecvByteBufAllocator;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelOption;
import java.util.Map;
import io.netty.channel.Channel;
import io.netty.channel.DefaultChannelConfig;

final class QuicheQuicStreamChannelConfig extends DefaultChannelConfig implements QuicStreamChannelConfig
{
    private volatile boolean allowHalfClosure;
    private volatile boolean readFrames;
    volatile DirectIoByteBufAllocator allocator;
    
    QuicheQuicStreamChannelConfig(final QuicStreamChannel channel) {
        super(channel);
        this.allowHalfClosure = true;
        this.allocator = new DirectIoByteBufAllocator(super.getAllocator());
    }
    
    @Override
    public Map<ChannelOption<?>, Object> getOptions() {
        if (this.isHalfClosureSupported()) {
            return this.getOptions(super.getOptions(), ChannelOption.ALLOW_HALF_CLOSURE, QuicChannelOption.READ_FRAMES);
        }
        return super.getOptions();
    }
    
    @Override
    public <T> T getOption(final ChannelOption<T> option) {
        if (option == ChannelOption.ALLOW_HALF_CLOSURE) {
            return (T)Boolean.valueOf(this.isAllowHalfClosure());
        }
        if (option == QuicChannelOption.READ_FRAMES) {
            return (T)Boolean.valueOf(this.isReadFrames());
        }
        return super.getOption(option);
    }
    
    @Override
    public <T> boolean setOption(final ChannelOption<T> option, final T value) {
        this.validate(option, value);
        if (option != ChannelOption.ALLOW_HALF_CLOSURE) {
            if (option == QuicChannelOption.READ_FRAMES) {
                this.setReadFrames((boolean)value);
            }
            return super.setOption(option, value);
        }
        if (this.isHalfClosureSupported()) {
            this.setAllowHalfClosure((boolean)value);
            return true;
        }
        return false;
    }
    
    @Override
    public QuicStreamChannelConfig setReadFrames(final boolean readFrames) {
        this.readFrames = readFrames;
        return this;
    }
    
    @Override
    public boolean isReadFrames() {
        return this.readFrames;
    }
    
    @Override
    public QuicStreamChannelConfig setConnectTimeoutMillis(final int connectTimeoutMillis) {
        super.setConnectTimeoutMillis(connectTimeoutMillis);
        return this;
    }
    
    @Override
    public QuicStreamChannelConfig setMaxMessagesPerRead(final int maxMessagesPerRead) {
        super.setMaxMessagesPerRead(maxMessagesPerRead);
        return this;
    }
    
    @Override
    public QuicStreamChannelConfig setWriteSpinCount(final int writeSpinCount) {
        super.setWriteSpinCount(writeSpinCount);
        return this;
    }
    
    @Override
    public QuicStreamChannelConfig setAllocator(final ByteBufAllocator allocator) {
        this.allocator = new DirectIoByteBufAllocator(allocator);
        return this;
    }
    
    @Override
    public QuicStreamChannelConfig setRecvByteBufAllocator(final RecvByteBufAllocator allocator) {
        super.setRecvByteBufAllocator(allocator);
        return this;
    }
    
    @Override
    public QuicStreamChannelConfig setAutoRead(final boolean autoRead) {
        super.setAutoRead(autoRead);
        return this;
    }
    
    @Override
    public QuicStreamChannelConfig setAutoClose(final boolean autoClose) {
        super.setAutoClose(autoClose);
        return this;
    }
    
    @Override
    public QuicStreamChannelConfig setWriteBufferHighWaterMark(final int writeBufferHighWaterMark) {
        super.setWriteBufferHighWaterMark(writeBufferHighWaterMark);
        return this;
    }
    
    @Override
    public QuicStreamChannelConfig setWriteBufferLowWaterMark(final int writeBufferLowWaterMark) {
        super.setWriteBufferLowWaterMark(writeBufferLowWaterMark);
        return this;
    }
    
    @Override
    public QuicStreamChannelConfig setWriteBufferWaterMark(final WriteBufferWaterMark writeBufferWaterMark) {
        super.setWriteBufferWaterMark(writeBufferWaterMark);
        return this;
    }
    
    @Override
    public QuicStreamChannelConfig setMessageSizeEstimator(final MessageSizeEstimator estimator) {
        super.setMessageSizeEstimator(estimator);
        return this;
    }
    
    @Override
    public QuicStreamChannelConfig setAllowHalfClosure(final boolean allowHalfClosure) {
        if (!this.isHalfClosureSupported()) {
            throw new UnsupportedOperationException("Undirectional streams don't support half-closure");
        }
        this.allowHalfClosure = allowHalfClosure;
        return this;
    }
    
    @Override
    public ByteBufAllocator getAllocator() {
        return this.allocator.wrapped();
    }
    
    @Override
    public boolean isAllowHalfClosure() {
        return this.allowHalfClosure;
    }
    
    private boolean isHalfClosureSupported() {
        return ((QuicStreamChannel)this.channel).type() == QuicStreamType.BIDIRECTIONAL;
    }
}