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

package io.netty.channel.socket.nio;

import io.netty.channel.ChannelConfig;
import java.util.Map;
import java.nio.channels.Channel;
import io.netty.channel.ChannelOption;
import java.io.IOException;
import java.net.SocketOption;
import java.net.SocketException;
import io.netty.channel.ChannelException;
import java.util.Enumeration;
import java.net.NetworkInterface;
import io.netty.util.internal.SocketUtils;
import java.net.InetAddress;
import io.netty.channel.socket.DatagramChannelConfig;
import java.net.StandardSocketOptions;
import java.nio.channels.DatagramChannel;
import io.netty.channel.socket.DefaultDatagramChannelConfig;

class NioDatagramChannelConfig extends DefaultDatagramChannelConfig
{
    private final DatagramChannel javaChannel;
    
    NioDatagramChannelConfig(final NioDatagramChannel channel, final DatagramChannel javaChannel) {
        super(channel, javaChannel.socket());
        this.javaChannel = javaChannel;
    }
    
    @Override
    public int getTimeToLive() {
        return this.getOption0(StandardSocketOptions.IP_MULTICAST_TTL);
    }
    
    @Override
    public DatagramChannelConfig setTimeToLive(final int ttl) {
        this.setOption0(StandardSocketOptions.IP_MULTICAST_TTL, ttl);
        return this;
    }
    
    @Override
    public InetAddress getInterface() {
        final NetworkInterface inf = this.getNetworkInterface();
        if (inf != null) {
            final Enumeration<InetAddress> addresses = SocketUtils.addressesFromNetworkInterface(inf);
            if (addresses.hasMoreElements()) {
                return addresses.nextElement();
            }
        }
        return null;
    }
    
    @Override
    public DatagramChannelConfig setInterface(final InetAddress interfaceAddress) {
        try {
            this.setNetworkInterface(NetworkInterface.getByInetAddress(interfaceAddress));
        }
        catch (final SocketException e) {
            throw new ChannelException(e);
        }
        return this;
    }
    
    @Override
    public NetworkInterface getNetworkInterface() {
        return this.getOption0(StandardSocketOptions.IP_MULTICAST_IF);
    }
    
    @Override
    public DatagramChannelConfig setNetworkInterface(final NetworkInterface networkInterface) {
        this.setOption0(StandardSocketOptions.IP_MULTICAST_IF, networkInterface);
        return this;
    }
    
    @Override
    public boolean isLoopbackModeDisabled() {
        return this.getOption0(StandardSocketOptions.IP_MULTICAST_LOOP);
    }
    
    @Override
    public DatagramChannelConfig setLoopbackModeDisabled(final boolean loopbackModeDisabled) {
        this.setOption0(StandardSocketOptions.IP_MULTICAST_LOOP, loopbackModeDisabled);
        return this;
    }
    
    @Override
    public DatagramChannelConfig setAutoRead(final boolean autoRead) {
        super.setAutoRead(autoRead);
        return this;
    }
    
    @Override
    protected void autoReadCleared() {
        ((NioDatagramChannel)this.channel).clearReadPending0();
    }
    
    private <T> T getOption0(final SocketOption<T> option) {
        try {
            return this.javaChannel.getOption(option);
        }
        catch (final IOException e) {
            throw new ChannelException(e);
        }
    }
    
    private <T> void setOption0(final SocketOption<T> option, final T value) {
        try {
            this.javaChannel.setOption(option, value);
        }
        catch (final IOException e) {
            throw new ChannelException(e);
        }
    }
    
    @Override
    public <T> boolean setOption(final ChannelOption<T> option, final T value) {
        if (option instanceof NioChannelOption) {
            return NioChannelOption.setOption(this.javaChannel, (NioChannelOption)option, value);
        }
        return super.setOption(option, value);
    }
    
    @Override
    public <T> T getOption(final ChannelOption<T> option) {
        if (option instanceof NioChannelOption) {
            return NioChannelOption.getOption(this.javaChannel, (NioChannelOption<T>)(NioChannelOption)option);
        }
        return super.getOption(option);
    }
    
    @Override
    public Map<ChannelOption<?>, Object> getOptions() {
        return this.getOptions(super.getOptions(), NioChannelOption.getOptions(this.javaChannel));
    }
}