class NIO::Selector

# File lib/nio/selector.rb, line 26
def self.backends
  [:ruby]
end

# File lib/nio/selector.rb, line 31
def initialize(backend = :ruby)
  raise ArgumentError, "unsupported backend: #{backend}" unless [:ruby, nil].include?(backend)

  @selectables = {}
  @lock = Mutex.new

  # Other threads can wake up a selector
  @wakeup, @waker = IO.pipe
  @closed = false
end

# File lib/nio/selector.rb, line 54
def backend
  :ruby
end

# File lib/nio/selector.rb, line 161
def close
  @lock.synchronize do
    return if @closed

    begin
      @wakeup.close
    rescue IOError
    end

    begin
      @waker.close
    rescue IOError
    end

    @closed = true
  end
end

# File lib/nio/selector.rb, line 180
def closed?
  @closed
end

# File lib/nio/selector.rb, line 82
def deregister(io)
  @lock.synchronize do
    monitor = @selectables.delete IO.try_convert(io)
    monitor.close(false) if monitor && !monitor.closed?
    monitor
  end
end

# File lib/nio/selector.rb, line 184
def empty?
  @selectables.empty?
end

# File lib/nio/selector.rb, line 63
def register(io, interest)
  unless defined?(::OpenSSL) && io.is_a?(::OpenSSL::SSL::SSLSocket)
    io = IO.try_convert(io)
  end

  @lock.synchronize do
    raise IOError, "selector is closed" if closed?

    monitor = @selectables[io]
    raise ArgumentError, "already registered as #{monitor.interests.inspect}" if monitor

    monitor = Monitor.new(io, interest, self)
    @selectables[monitor.io] = monitor

    monitor
  end
end

# File lib/nio/selector.rb, line 91
def registered?(io)
  @lock.synchronize { @selectables.key? io }
end

# File lib/nio/selector.rb, line 96
def select(timeout = nil)
  selected_monitors = Set.new

  @lock.synchronize do
    readers = [@wakeup]
    writers = []

    @selectables.each do |io, monitor|
      readers << io if monitor.interests == :r || monitor.interests == :rw
      writers << io if monitor.interests == :w || monitor.interests == :rw
      monitor.readiness = nil
    end

    ready_readers, ready_writers = Kernel.select(readers, writers, [], timeout)
    return unless ready_readers # timeout

    ready_readers.each do |io|
      if io == @wakeup
        # Clear all wakeup signals we've received by reading them
        # Wakeups should have level triggered behavior
        @wakeup.read(@wakeup.stat.size)
      else
        monitor = @selectables[io]
        monitor.readiness = :r
        selected_monitors << monitor
      end
    end

    ready_writers.each do |io|
      monitor = @selectables[io]
      monitor.readiness = monitor.readiness == :r ? :rw : :w
      selected_monitors << monitor
    end
  end

  if block_given?
    selected_monitors.each { |m| yield m }
    selected_monitors.size
  else
    selected_monitors.to_a
  end
end

# File lib/nio/selector.rb, line 145
def wakeup
  # Send the selector a signal in the form of writing data to a pipe
  begin
    @waker.write_nonblock "\0"
  rescue IO::WaitWritable
    # This indicates the wakeup pipe is full, which means the other thread
    # has already received many wakeup calls, but not processed them yet.
    # The other thread will completely drain this pipe when it wakes up,
    # so it's ok to ignore this exception if it occurs: we know the other
    # thread has already been signaled to wake up
  end

  nil
end