class Falcon::Command::Serve

def call
	container = run(parent.verbose?)
	
	container.wait
end

def client
	Async::HTTP::Client.new(client_endpoint)
end

def client_endpoint
	Async::HTTP::Endpoint.parse(@options[:bind], **endpoint_options)
end

def container_class
	case @options[:container]
	when :threaded
		return Async::Container::Threaded
	when :forked
		return Async::Container::Forked
	when :hybrid
		return Async::Container::Hybrid
	end
end

def container_options
	slice_options(:count, :forks, :threads)
end

def endpoint_options
	slice_options(:hostname, :port, :reuse_port, :timeout)
end

def load_app(verbose)
	rack_app, options = Rack::Builder.parse_file(@options[:config])
	
	return Server.middleware(rack_app, verbose: verbose), options
end

def run(verbose = false)
	app, _ = load_app(verbose)
	
	endpoint = Endpoint.parse(@options[:bind], **endpoint_options)
	
	bound_endpoint = Async::Reactor.run do
		Async::IO::SharedEndpoint.bound(endpoint)
	end.wait
	
	Async.logger.info(endpoint) do |buffer|
		buffer.puts "Falcon taking flight! Using #{container_class} #{container_options}"
		buffer.puts "- To terminate: Ctrl-C or kill #{Process.pid}"
	end
	
	debug_trap = Async::IO::Trap.new(:USR1)
	debug_trap.ignore!
	
	container = container_class.new
	
	container.attach do
		bound_endpoint.close
	end
	
	container.run(name: "Falcon Server", restart: true, **container_options) do |task, instance|
		task.async do
			if debug_trap.install!
				Async.logger.info(instance) do
					"- Per-process status: kill -USR1 #{Process.pid}"
				end
			end
			
			debug_trap.trap do
				Async.logger.info(self) do |buffer|
					task.reactor.print_hierarchy(buffer)
				end
			end
		end
		
		server = Falcon::Server.new(app, bound_endpoint, endpoint.protocol, endpoint.scheme)
		
		server.run
		
		task.children.each(&:wait)
	end
	
	return container
end

def slice_options(*keys)
	# TODO: Ruby 2.5 introduced Hash#slice
	options = {}
	
	keys.each do |key|
		if @options.key?(key)
			options[key] = @options[key]
		end
	end
	
	return options
end