# -*- encoding: binary -*-
require 'io_splice_ext'

module IO::Splice

  # The maximum default capacity of the pipe in bytes.
  # Under stock Linux, this is 65536 bytes as of 2.6.11, and 4096 before
  # We detect this at runtime as it is easy to recompile the kernel
  # and set a new value.
  # Starting with Linux 2.6.35, pipe capacity will be tunable
  # and this will only represent the default capacity of a
  # newly-created pipe.
  PIPE_CAPA = begin
    rd, wr = IO.pipe
    buf = ' ' * PIPE_BUF
    n = 0
    begin
      n += wr.write_nonblock(buf)
    rescue Errno::EAGAIN
      break
    end while true
    wr.close
    rd.close
    n
  end

  # copies the contents of the IO object given by +src+ to +dst+
  # If +len+ is specified, then only +len+ bytes are copied and
  # +EOFError+ is raised if fewer than +len+ bytes could be copied.
  # Otherwise the copy will be until EOF is reached on the +src+.
  # +src+ and +dst+ must be IO objects or respond to +to_io+
  def self.copy_stream(src, dst, len = nil, src_offset = nil)
    close = []
    src.kind_of?(String) and close << (src = File.open(src))
    dst.kind_of?(String) and close << (dst = File.open(dst, "w"))
    src, dst = src.to_io, dst.to_io
    rv = len
    src.sysseek(src_offset) if src_offset
    select_args = selectable(src, dst)

    if src.stat.pipe? || dst.stat.pipe?
      if len
        len -= full(src, dst, len, select_args) until len == 0
      else
        rv = 0
        while n = partial(src, dst, PIPE_CAPA, select_args)
          rv += n
        end
      end
    else
      r, w = tmp = IO.pipe
      close.concat(tmp)
      if len
        while len != 0 && n = partial(src, w, len, select_args)
          len -= full(r, dst, n, select_args)
        end
      else
        rv = 0
        while n = partial(src, w, PIPE_CAPA, select_args)
          rv += full(r, dst, n, select_args)
        end
      end
    end

    rv
    ensure
      close.each { |io| io.close }
  end

  # splice the full amount specified from +src+ to +dst+
  # Either +dst+ or +src+ must be a pipe.  +dst+ and +src+
  # may BOTH be pipes in Linux 2.6.31 or later.
  # This will block and wait for IO completion of +len+
  # Raises +EOFError+ if end of file is reached.
  # bytes.  Returns the number of bytes actually spliced (always +len+)
  # The +_select_args+ parameter is reserved for internal use and
  # may be removed in future versions.  Do not write code that
  # depends on +_select_args+.
  def self.full(src, dst, len, _select_args = selectable(src, dst))
    nr = len
    while nr > 0
      n = partial(src, dst, nr, _select_args) or
                                     raise EOFError, "end of file reached"
      nr -= n
    end
    len
  end

  # splice up to +len+ bytes from +src+ to +dst+.
  # Either +dst+ or +src+ must be a pipe.  +dst+ and +src+
  # may BOTH be pipes in Linux 2.6.31 or later.
  # Returns the number of bytes actually spliced.
  # Like IO#readpartial, this never returns Errno::EAGAIN
  # The +_select_args+ parameter is reserved for internal use and
  # may be removed in future versions.  Do not write code that
  # depends on +_select_args+.
  def self.partial(src, dst, len, _select_args = selectable(src, dst))
    begin
      rv = IO.trysplice(src, nil, dst, nil, len, F_MOVE)
    end while rv == :EAGAIN and IO.select(*_select_args)
    rv
  end

  # returns an array suitable for splat-ing to IO.select for blocking I/O
  def self.selectable(src, dst)
    rv = []
    src.stat.pipe? or rv[0] = [ src ]
    dst.stat.pipe? or rv[1] = [ dst ]
    rv
  end
end