class Net::SFTP::Operations::Upload

def [](name)
  @properties[name.to_sym]
end

def []=(name, value)
  @properties[name.to_sym] = value
end

def abort!
  @active = 0
  @stack.clear
  @uploads.clear
end

def active?
  @active > 0 || @stack.any?
end

def entries_for(local)
  ::Dir.entries(local).reject { |v| %w(. ..).include?(v) }
end

def initialize(sftp, local, remote, options={}, &progress) #:nodoc:
  @sftp = sftp
  @local = local
  @remote = remote
  @progress = progress || options[:progress]
  @options = options
  @properties = options[:properties] || {}
  @active = 0
  self.logger = sftp.logger
  @uploads = []
  @recursive = local.respond_to?(:read) ? false : ::File.directory?(local)
  if recursive?
    @stack = [entries_for(local)]
    @local_cwd = local
    @remote_cwd = remote
    @active += 1
    if @options[:mkdir]
      sftp.mkdir(remote) do |response|
        @active -= 1
        raise StatusException.new(response, "mkdir `#{remote}'") unless response.ok?
        (options[:requests] || RECURSIVE_READERS).to_i.times do
          break unless process_next_entry
        end
      end
    else
      @active -= 1
      process_next_entry
    end
  else
    raise ArgumentError, "expected a file to upload" unless local.respond_to?(:read) || ::File.exist?(local)
    @stack = [[local]]
    process_next_entry
  end
end

def on_close(response)
  @active -= 1
  file = response.request[:file]
  raise StatusException.new(response, "close #{file.remote}") unless response.ok?
  process_next_entry
end

def on_mkdir(response)
  @active -= 1
  dir = response.request[:dir]
  raise StatusException.new(response, "mkdir #{dir}") unless response.ok?
  process_next_entry
end

def on_open(response)
  @active -= 1
  file = response.request[:file]
  raise StatusException.new(response, "open #{file.remote}") unless response.ok?
  file.handle = response[:handle]
  @uploads << file
  write_next_chunk(file)
  if !recursive?
    (options[:requests] || SINGLE_FILE_READERS).to_i.times { write_next_chunk(file) }
  end
end

def on_write(response)
  @active -= 1
  file = response.request[:file]
  raise StatusException.new(response, "write #{file.remote}") unless response.ok?
  write_next_chunk(file)
end

def open_file(local, remote)
  @active += 1
  if local.respond_to?(:read)
    file = local
    name = options[:name] || "<memory>"
  else
    file = ::File.open(local, "rb")
    name = local
  end
  if file.respond_to?(:stat)
    size = file.stat.size
  else
    size = file.size
  end
  metafile = LiveFile.new(name, remote, file, size)
  update_progress(:open, metafile)
  request = sftp.open(remote, "w", &method(:on_open))
  request[:file] = metafile
end

def process_next_entry
  if @stack.empty?
    if @uploads.any?
      write_next_chunk(@uploads.first)
    elsif !active?
      update_progress(:finish)
    end
    return false
  elsif @stack.last.empty?
    @stack.pop
    @local_cwd = ::File.dirname(@local_cwd)
    @remote_cwd = ::File.dirname(@remote_cwd)
    process_next_entry
  elsif recursive?
    entry = @stack.last.shift
    lpath = ::File.join(@local_cwd, entry)
    rpath = ::File.join(@remote_cwd, entry)
    if ::File.directory?(lpath)
      @stack.push(entries_for(lpath))
      @local_cwd = lpath
      @remote_cwd = rpath
      @active += 1
      update_progress(:mkdir, rpath)
      request = sftp.mkdir(rpath, &method(:on_mkdir))
      request[:dir] = rpath
    else
      open_file(lpath, rpath)
    end
  else
    open_file(@stack.pop.first, remote)
  end
  return true
end

def progress; @progress; end

def recursive?
  @recursive
end

def update_progress(event, *args)
  on = "on_#{event}"
  if progress.respond_to?(on)
    progress.send(on, self, *args)
  elsif progress.respond_to?(:call)
    progress.call(event, self, *args)
  end
end

def wait
  sftp.loop { active? }
  self
end

def write_next_chunk(file)
  if file.io.nil?
    process_next_entry
  else
    @active += 1
    offset = file.io.pos
    data = file.io.read(options[:read_size] || DEFAULT_READ_SIZE)
    if data.nil?
      update_progress(:close, file)
      request = sftp.close(file.handle, &method(:on_close))
      request[:file] = file
      file.io.close
      file.io = nil
      @uploads.delete(file)
    else
      update_progress(:put, file, offset, data)
      request = sftp.write(file.handle, offset, data, &method(:on_write))
      request[:file] = file
    end
  end
end