class Connection

def maximum_frame_size
	@remote_settings.maximum_frame_size
end

def maximum_concurrent_streams
	@remote_settings.maximum_concurrent_streams
end

def closed?
	@state == :closed || @framer.nil?
end

def close(error = nil)
	# The underlying socket may already be closed by this point.
	@streams.each_value{|stream| stream.close(error)}
	@streams.clear
	
ensure
	if @framer
		@framer.close
		@framer = nil
	end
end

def next_stream_id
	id = @local_stream_id
	
	@local_stream_id += 2
	
	return id
end

def ignore_frame?(frame)
	if self.closed?
		# puts "ignore_frame? #{frame.stream_id} -> #{valid_remote_stream_id?(frame.stream_id)} > #{@remote_stream_id}"
		if valid_remote_stream_id?(frame.stream_id)
			return frame.stream_id > @remote_stream_id
		end
	end
end

def read_frame
	frame = @framer.read_frame(@local_settings.maximum_frame_size)
	
	# puts "#{self.class} #{@state} read_frame: class=#{frame.class} stream_id=#{frame.stream_id} flags=#{frame.flags} length=#{frame.length} (remote_stream_id=#{@remote_stream_id})"
	# puts "Windows: local_window=#{@local_window.inspect}; remote_window=#{@remote_window.inspect}"
	
	return if ignore_frame?(frame)
	
	yield frame if block_given?
	frame.apply(self)
	
	return frame
rescue GoawayError => error
	# Go directly to jail. Do not pass go, do not collect $200.
	raise
rescue ProtocolError => error
	send_goaway(error.code || PROTOCOL_ERROR, error.message)
	
	raise
rescue HPACK::Error => error
	send_goaway(COMPRESSION_ERROR, error.message)
	
	raise
end

def close!
	@state = :closed
	
	return self
end

def send_goaway(error_code = 0, message = "")
	frame = GoawayFrame.new
	frame.pack @remote_stream_id, error_code, message
	
	write_frame(frame)
ensure
	self.close!
end

def process_settings(frame)
	if frame.acknowledgement?
		# The remote end has confirmed the settings have been received:
		changes = @local_settings.acknowledge
		
		update_local_settings(changes)
		
		return true
	else
		# The remote end is updating the settings, we reply with acknowledgement:
		reply = frame.acknowledge
		
		write_frame(reply)
		
		changes = frame.unpack
		@remote_settings.update(changes)
		
		update_remote_settings(changes)
		
		return false
	end
end

def accept_stream(stream_id, &block)
	unless valid_remote_stream_id?(stream_id)
		raise ProtocolError, "Invalid stream id: #{stream_id}"
	end
	
	create_stream(stream_id, &block)
end

def accept_push_promise_stream(stream_id, &block)
	accept_stream(stream_id, &block)
end

def create_stream(id = next_stream_id, &block)
	if @streams.key?(id)
		raise ProtocolError, "Cannot create stream with id #{id}, already exists!"
	end
	
	if block_given?
		return yield(self, id)
	else
		return Stream.create(self, id)
	end
end

def receive_headers(frame)
	stream_id = frame.stream_id
	
	if stream_id.zero?
		raise ProtocolError, "Cannot receive headers for stream 0!"
	end
	
	if stream = @streams[stream_id]
		stream.receive_headers(frame)
	else
		if stream_id <= @remote_stream_id
			raise ProtocolError, "Invalid stream id: #{stream_id} <= #{@remote_stream_id}!"
		end
		
		# We need to validate that we have less streams than the specified maximum:
		if @streams.size < @local_settings.maximum_concurrent_streams
			stream = accept_stream(stream_id)
			@remote_stream_id = stream_id
			
			stream.receive_headers(frame)
		else
			raise ProtocolError, "Exceeded maximum concurrent streams"
		end
	end
end

def receive_priority(frame)
	if dependency = @dependencies[frame.stream_id]
		dependency.receive_priority(frame)
	elsif idle_stream_id?(frame.stream_id)
		Dependency.create(self, frame.stream_id, frame.unpack)
	end
end

def closed_stream_id?(id)
	if id.zero?
		# The connection "stream id" can never be closed:
		false
	else
		!idle_stream_id?(id)
	end
end

def consume_window(size = self.available_size)
	# Return if there is no window to consume:
	return unless size > 0
	
	# Console.logger.debug(self) do |buffer|
	# 	@dependencies.each do |id, dependency|
	# 		buffer.puts "- #{dependency}"
	# 	end
	# 
	# 	buffer.puts
	# 
	# 	@dependency.print_hierarchy(buffer)
	# end
	
	@dependency.consume_window(size)
end