class Goliath::Runner

def initialize(argv, api)
  api.options_parser(options_parser, options) if api
  options_parser.parse!(argv)
  # We've already dealt with the environment, so just discard it.
  options.delete(:env)
  @api = api
  @address = options.delete(:address)
  @port = options.delete(:port)
  @log_file = options.delete(:log_file)
  @pid_file = options.delete(:pid_file)
  @log_stdout = options.delete(:log_stdout)
  @daemonize = options.delete(:daemonize)
  @verbose = options.delete(:verbose)
  @server_options = options
end

def load_plugins(plugins)
  @plugins = plugins
end

def options_parser
  @options ||= {
    :address => Goliath::Server::DEFAULT_ADDRESS,
    :port => Goliath::Server::DEFAULT_PORT,
    :daemonize => false,
    :verbose => false,
    :log_stdout => false,
    :env => Goliath::DEFAULT_ENV
  }
  @options_parser ||= OptionParser.new do |opts|
    opts.banner = "Usage: <server> [options]"
    opts.separator ""
    opts.separator "Server options:"
    # The environment isn't set as part of this option parsing routine, but
    # we'll leave the flag here so a call to --help shows it correctly.
    opts.on('-e', '--environment NAME', "Set the execution environment (default: #{@options[:env]})") { |val| @options[:env] = val }
    opts.on('-a', '--address HOST', "Bind to HOST address (default: #{@options[:address]})") { |addr| @options[:address] = addr }
    opts.on('-p', '--port PORT', "Use PORT (default: #{@options[:port]})") { |port| @options[:port] = port.to_i }
    opts.on('-S', '--socket FILE', "Bind to unix domain socket") { |v| @options[:address] = v; @options[:port] = nil }
    opts.on('-E', '--einhorn', "Use Einhorn socket manager") { |v| @options[:einhorn] = true }
    opts.separator ""
    opts.separator "Daemon options:"
    opts.on('-u', '--user USER', "Run as specified user") {|v| @options[:user] = v }
    opts.on('-c', '--config FILE', "Config file (default: ./config/<server>.rb)") { |v| @options[:config] = v }
    opts.on('-d', '--daemonize', "Run daemonized in the background (default: #{@options[:daemonize]})") { |v| @options[:daemonize] = v }
    opts.on('-l', '--log FILE', "Log to file (default: off)") { |file| @options[:log_file] = file }
    opts.on('-s', '--stdout', "Log to stdout (default: #{@options[:log_stdout]})") { |v| @options[:log_stdout] = v }
    opts.on('-P', '--pid FILE', "Pid file (default: off)") { |file| @options[:pid_file] = file }
    opts.separator ""
    opts.separator "SSL options:"
    opts.on('--ssl', 'Enables SSL (default: off)') {|v| @options[:ssl] = v }
    opts.on('--ssl-key FILE', 'Path to private key') {|v| @options[:ssl_key] = v }
    opts.on('--ssl-cert FILE', 'Path to certificate') {|v| @options[:ssl_cert] = v }
    opts.on('--ssl-verify', 'Enables SSL certificate verification') {|v| @options[:ssl_verify] = v }
    opts.separator ""
    opts.separator "Common options:"
    opts.on('-C', '--console', 'Start a console') { @options[:console] = true }
    opts.on('-v', '--verbose', "Enable verbose logging (default: #{@options[:verbose]})") { |v| @options[:verbose] = v }
    opts.on('-h', '--help', 'Display help message') { show_options(opts) }
  end
end

def remove_pid
  File.delete(@pid_file)
end

def run
  if options[:console]
    Goliath::Console.run!(setup_server)
    return
  end
  unless Goliath.env?(:test)
    $LOADED_FEATURES.unshift(File.basename($0))
    Dir.chdir(File.expand_path(File.dirname($0)))
  end
  if @daemonize
    Process.fork do
      Process.setsid
      exit if fork
      @pid_file ||= './goliath.pid'
      @log_file ||= File.expand_path('goliath.log')
      store_pid(Process.pid)
      File.umask(0000)
      log_extension = File.extname(@log_file)
      stdout_log_file = "#{File.dirname(@log_file)}/#{File.basename(@log_file, log_extension)}_stdout#{log_extension}"
      STDIN.reopen("/dev/null")
      STDOUT.reopen(stdout_log_file, "a")
      STDERR.reopen(STDOUT)
      run_server
      remove_pid
    end
  else
    run_server
  end
end

def run_server
  log = setup_logger
  log.info("Starting server on http#{ @server_options[:ssl] ? 's' : nil }://#{@address}:#{@port} in #{Goliath.env} mode. Watch out for stones.")
  server = setup_server(log)
  server.api.setup if server.api.respond_to?(:setup)
  server.start
end

def setup_file_logger(log, log_format)
  FileUtils.mkdir_p(File.dirname(@log_file))
  log.add(Log4r::FileOutputter.new('fileOutput', {:filename => @log_file,
                                                  :trunc => false,
                                                  :formatter => log_format}))
end

def setup_logger
  if logger
    warn_on_custom_logger
    return logger
  end
  log = Log4r::Logger.new('goliath')
  log_format = Log4r::PatternFormatter.new(:pattern => "[#{Process.pid}:%l] %d :: %m")
  setup_file_logger(log, log_format) if @log_file
  setup_stdout_logger(log, log_format) if @log_stdout
  log.level = @verbose ? Log4r::DEBUG : Log4r::INFO
  log
end

def setup_server(log = setup_logger)
  server = Goliath::Server.new(@address, @port)
  server.logger = log
  server.app = @app
  server.api = @api
  server.plugins = @plugins || []
  server.options = @server_options
  server
end

def setup_stdout_logger(log, log_format)
  log.add(Log4r::StdoutOutputter.new('console', :formatter => log_format))
end

def show_options(opts)
  puts opts
  at_exit { exit! }
  exit
end

def store_pid(pid)
  FileUtils.mkdir_p(File.dirname(@pid_file))
  File.open(@pid_file, 'w') { |f| f.write(pid) }
end

def warn_on_custom_logger
  warn "log_file option will not take effect with a custom logger" if @log_file
  warn "log_stdout option will not take effect with a custom logger" if @log_stdout
  warn "verbose option will not take effect with a custom logger" if @verbose
end