#!/usr/bin/env ruby
# The command line Restfully client

require 'restfully'
require 'optparse'
require 'logger'
require 'pp'
require 'ripl'
require 'ripl/multi_line'
require 'ripl/short_errors'

# Behaviour of pp in IRB is different on ruby1.9:
# * pp(object) returns object#inspect.
# * we prefer the behaviour of ruby1.8 where pp returns nil.
alias :old_pp :pp
def pp(*args)
  old_pp(*args); nil
end

logger = Logger.new(STDERR)
logger.level = Logger::WARN

OPTIONS = {"logger" => logger, "shell" => false}

Ripl.config[:play_quiet] = true
Ripl.config[:play_input] = false

option_parser = OptionParser.new do |opts|
  opts.banner = <<BANNER
* Description
  Restfully #{Restfully::VERSION} - Access REST APIs effortlessly
* Usage
  restfully [options] [FILE]

  If FILE is given and is an HTTP URI or a local file, the content of that file will be executed in the context of the Restfully session. It can also be read from STDIN.
  If no FILE is given, then an interactive shell will be launched in the context of the Restfully session.
BANNER

  opts.separator ""
  opts.separator "* Common options"
  opts.on("--uri=", "Sets the base URI") do |v|
    OPTIONS["uri"] = v
  end
  opts.on("-u=", "--username=", "Sets the username (Basic Authentication)") do |u|
    OPTIONS["username"] = u
  end
  opts.on("-p=", "--password=", "Sets the password (Basic Authentication)") do |p|
    OPTIONS["password"] = p
  end
  opts.on("-c=", "--config=", "Load options from a custom YAML configuration file") do |v|
    OPTIONS["configuration_file"] = v
  end
  opts.on("-r=", "--require=", "Require an additional media-type") do |v|
    OPTIONS["require"] ||= []
    OPTIONS["require"].push(v)
  end
  opts.on("--log=", "Outputs log messages to the given file. Defaults to STDERR") do |v|
    original_logger_level = logger.level
    @log_file = File.open(File.expand_path(v), "w+")
    STDERR.sync = true
    STDERR.reopen(@log_file)
    logger = Logger.new(@log_file)
    logger.level = original_logger_level
    OPTIONS["logger"] = logger
  end
  opts.on("--no-cache", "Disable client-side caching") do |v|
    OPTIONS["cache"] = false
  end
  opts.on("--color", "Color output") do |v|
    require 'ripl/color_streams'
  end
  opts.on("--record [SESSION_FILE]", "Record interactive session into SESSION_FILE (default=#{Restfully::DEFAULT_TAPE}), to be replayed later. This option is ignored if FILE is given.") do |v|
    OPTIONS["record"] = v || Restfully::DEFAULT_TAPE
  end
  opts.on("-v", "--verbose", "Run verbosely") do |v|
    OPTIONS["logger"].level = Logger::INFO
  end
  opts.on("--debug", "Run in debug mode") do |v|
    OPTIONS["logger"].level = Logger::DEBUG
  end

  opts.separator ""
  opts.separator "* Options specific to FILE"
  opts.on("--replay", "Display the FILE input line by line, and the result of each command") do |v|
    Ripl.config[:play_input] = true
    Ripl.config[:play_quiet] = false
  end
  opts.on("--shell", "Start an interactive session even after FILE content has been executed") do |v|
    OPTIONS["shell"] = true
  end
  opts.on("-i", "--install", "Ask to install any gem that might be required in FILE") do |v|
    Ripl.config[:play_install] = true
  end

  opts.separator ""
  opts.separator "* Other"
  opts.on_tail("-h", "--help", "Show this message") do
    puts opts
    exit
  end
  opts.on_tail("--version", "Show version") do
    puts Restfully::VERSION
    exit
  end
end.parse!

if $stdin.tty? && !ARGV[0]
  # Interactive session
  OPTIONS["shell"] = true
  puts "Restfully/#{Restfully::VERSION} - The root resource is available in the 'root' variable."
  if OPTIONS["record"]
    # Recording requested
    require 'ripl/record'
    Ripl.config[:play] = OPTIONS["record"]
  end
else
  # Replayed session
  logger.warn "--record option valid only with interactive session. Ignoring." if OPTIONS["record"]
  require 'ripl/play'

  module Ripl::Play
    # Overwrite #get_input so that it does not display the input if not
    # required.
    def get_input
      puts(prompt + @play_input) if Ripl.config[:play_input]
      @play_input
    end
  end
  
  module Ripl::PlayWithoutWhitespace
    # Remove empty lines when replaying
    def play_back_string(str)
      str.gsub!(/^\s*\n+/, '')
      super(str)
    end
  end
  Ripl::Shell.include Ripl::PlayWithoutWhitespace
  
  unless OPTIONS["shell"]
    # Use readline-rb to avoid error message 'Bond has detected EditLine and
    # may not work with it. See the README's Limitations section.' when no
    # shell is requested after execution of FILE.
    Ripl.config[:readline] = 'readline-rb'
    Ripl.config[:completion] = {:readline => :ruby }
    module Ripl::Exit
      def before_loop; super; exit; end
    end
    Ripl::Shell.include Ripl::Exit
  end
  
  Ripl.config[:play] = ARGV[0].dup if ARGV[0]
end

# Declare original Restfully::Session
SESSION = Restfully::Session.new(OPTIONS)

module Restfully
  class Session
    alias :old_initialize :initialize
    # Overwrite Restfully::Session.new calls that might occur in replayed
    # scripts, so that they preferably take the configuration given with the
    # restfully command-line tool.
    def initialize(options = {}, &block)
      options[:overridden] = true
      old_opts = Configuration.new(options).expand
      new_opts = old_opts.merge(SESSION.config)
      old_initialize(new_opts, &block)
    end
  end
end

# Ensure to close the log file, if any, when exiting.
at_exit{ @log_file && @log_file.close }

ARGV.clear
Ripl.start :binding => SESSION.sandbox.instance_eval{ binding }