class Net::SSH::Connection::Channel

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

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

def active?
  connection.channels.key?(local_id)
end

def close
  return if @closing
  @closing = true
end

def closing?
  @closing
end

def do_close
  @on_close.call(self) if @on_close
end

def do_data(data) # :nodoc:
  update_local_window_size(data.length)
  @on_data.call(self, data) if @on_data
end

def do_eof
  @on_eof.call(self) if @on_eof
end

def do_extended_data(type, data)
  update_local_window_size(data.length)
  @on_extended_data.call(self, type, data) if @on_extended_data
end

def do_failure
  if callback = pending_requests.shift
    callback.call(self, false)
  else
    error { "channel failure received with no pending request to handle it (bug?)" }
  end
end

def do_open_confirmation(remote_id, max_window, max_packet) # :nodoc:
  @remote_id = remote_id
  @remote_window_size = @remote_maximum_window_size = max_window
  @remote_maximum_packet_size = max_packet
  connection.forward.agent(self) if connection.options[:forward_agent] && type == "session"
  forward_local_env(connection.options[:send_env]) if connection.options[:send_env]
  set_remote_env(connection.options[:set_env]) if connection.options[:set_env]
  @on_confirm_open.call(self) if @on_confirm_open
end

def do_open_failed(reason_code, description)
  if @on_open_failed
    @on_open_failed.call(self, reason_code, description)
  else
    raise ChannelOpenFailed.new(reason_code, description)
  end
end

def do_request(request, want_reply, data) # :nodoc:
  result = true
  begin
    callback = @on_request[request] or raise ChannelRequestFailed
    callback.call(self, data)
  rescue ChannelRequestFailed
    result = false
  end
  if want_reply
    msg = Buffer.from(:byte, result ? CHANNEL_SUCCESS : CHANNEL_FAILURE, :long, remote_id)
    connection.send_message(msg)
  end
end

def do_success
  if callback = pending_requests.shift
    callback.call(self, true)
  else
    error { "channel success received with no pending request to handle it (bug?)" }
  end
end

def do_window_adjust(bytes) # :nodoc:
  @remote_maximum_window_size += bytes
  @remote_window_size += bytes
end

def enqueue_pending_output # :nodoc:
  return unless remote_id
  while output.length > 0
    length = output.length
    length = remote_window_size if length > remote_window_size
    length = remote_maximum_packet_size if length > remote_maximum_packet_size
    if length > 0
      connection.send_message(Buffer.from(:byte, CHANNEL_DATA, :long, remote_id, :string, output.read(length)))
      output.consume!
      @remote_window_size -= length
    else
      break
    end
  end
end

def env(variable_name, variable_value, &block)
  send_channel_request("env", :string, variable_name, :string, variable_value, &block)
end

def eof!
  return if eof?
  @eof = true
end

def eof?
  @eof
end

def exec(command, &block)
  send_channel_request("exec", :string, command, &block)
end

def forward_local_env(env_variable_patterns)
  Array(env_variable_patterns).each do |env_variable_pattern|
    matched_variables = ENV.find_all do |env_name, _|
      case env_variable_pattern
      when Regexp then env_name =~ env_variable_pattern
      when String then env_name == env_variable_pattern
      end
    end
    matched_variables.each do |env_name, env_value|
      self.env(env_name, env_value)
    end
  end
end

def initialize(connection, type, local_id, max_pkt_size = 0x8000, max_win_size = 0x20000, &on_confirm_open)
  self.logger = connection.logger
  @connection = connection
  @type       = type
  @local_id   = local_id
  @local_maximum_packet_size = max_pkt_size
  @local_window_size = @local_maximum_window_size = max_win_size
  @on_confirm_open = on_confirm_open
  @output = Buffer.new
  @properties = {}
  @pending_requests = []
  @on_open_failed = @on_data = @on_extended_data = @on_process = @on_close = @on_eof = nil
  @on_request = {}
  @closing = @eof = @sent_eof = @local_closed = @remote_closed = false
end

def local_closed?
  @local_closed
end

def on_close(&block)
  old, @on_close = @on_close, block
  old
end

def on_data(&block)
  old, @on_data = @on_data, block
  old
end

def on_eof(&block)
  old, @on_eof = @on_eof, block
  old
end

def on_extended_data(&block)
  old, @on_extended_data = @on_extended_data, block
  old
end

def on_open_failed(&block)
  old, @on_open_failed = @on_open_failed, block
  old
end

def on_process(&block)
  old, @on_process = @on_process, block
  old
end

def on_request(type, &block)
  old, @on_request[type] = @on_request[type], block
  old
end

def process
  @on_process.call(self) if @on_process
  enqueue_pending_output
  if @eof and not @sent_eof and output.empty? and remote_id and not @local_closed
    connection.send_message(Buffer.from(:byte, CHANNEL_EOF, :long, remote_id))
    @sent_eof = true
  end
  if @closing and not @local_closed and output.empty? and remote_id
    connection.send_message(Buffer.from(:byte, CHANNEL_CLOSE, :long, remote_id))
    @local_closed = true
    connection.cleanup_channel(self)
  end
end

def remote_closed!
  @remote_closed = true
end

def remote_closed?
  @remote_closed
end

def request_pty(opts = {}, &block)
  extra = opts.keys - VALID_PTY_OPTIONS.keys
  raise ArgumentError, "invalid option(s) to request_pty: #{extra.inspect}" if extra.any?
  opts = VALID_PTY_OPTIONS.merge(opts)
  modes = opts[:modes].inject(Buffer.new) do |memo, (mode, data)|
    memo.write_byte(mode).write_long(data)
  end
  # mark the end of the mode opcode list with a 0 byte
  modes.write_byte(0)
  send_channel_request("pty-req", :string, opts[:term],
                       :long, opts[:chars_wide], :long, opts[:chars_high],
                       :long, opts[:pixels_wide], :long, opts[:pixels_high],
                       :string, modes.to_s, &block)
end

def send_channel_request(request_name, *data, &callback)
  info { "sending channel request #{request_name.inspect}" }
  fail "Channel open not yet confirmed, please call send_channel_request(or exec) from block of open_channel" unless remote_id
  msg = Buffer.from(:byte, CHANNEL_REQUEST,
                    :long, remote_id, :string, request_name,
                    :bool, !callback.nil?, *data)
  connection.send_message(msg)
  pending_requests << callback if callback
end

def send_data(data)
  raise EOFError, "cannot send data if channel has declared eof" if eof?
  output.append(data.to_s)
end

def set_remote_env(env)
  env.each { |key, value| self.env(key, value) }
end

def subsystem(subsystem, &block)
  send_channel_request("subsystem", :string, subsystem, &block)
end

def update_local_window_size(size)
  @local_window_size -= size
  if local_window_size < local_maximum_window_size / 2
    connection.send_message(
      Buffer.from(:byte, CHANNEL_WINDOW_ADJUST, :long, remote_id, :long, LOCAL_WINDOW_SIZE_INCREMENT)
    )
    @local_window_size += LOCAL_WINDOW_SIZE_INCREMENT
    if @local_maximum_window_size < @local_window_size || @local_maximum_window_size < GOOD_LOCAL_MAXIUMUM_WINDOW_SIZE
      @local_maximum_window_size += LOCAL_WINDOW_SIZE_INCREMENT
    end
  end
end

def wait
  connection.loop { active? }
end

def wait_until_open_confirmed
  connection.loop { !remote_id }
end