require 'optparse'

if ENV["SPARK_API_CONSOLE"].nil?
  require 'spark_api'
else
  puts "Enabling console mode for local gem"
  Bundler.require(:default, "development") if defined?(Bundler)
  path = File.expand_path(File.dirname(__FILE__) + "/../../../lib/")
  $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
  require path + '/spark_api'
end

module SparkApi
  module CLI
    class ConsoleCLI
      OPTIONS_ENV = {
        :endpoint => "API_ENDPOINT",
        :ssl_verify => "SSL_VERIFY",
        # OAUTH2 Options
        :access_uri  => "ACCESS_URI",
        :authorization_uri => "AUTHORIZATION_URI",
        :redirect_uri => "REDIRECT_URI",
        :code => "CODE",
        :username=> "USERNAME",
        :password=> "PASSWORD",
        :client_id=> "CLIENT_ID",
        :client_secret=> "CLIENT_SECRET",
        # API AUTH Options
        :api_key => "API_KEY", 
        :api_secret => "API_SECRET",
        :api_user => "API_USER",
        # OTHER
        :debug=> "DEBUG",
        :middleware => "SPARK_MIDDLEWARE",
        :dictionary_version => "DICTIONARY_VERSION",
        :console => "SPARK_API_CONSOLE"  # not a public option, meant to distinguish bin/spark_api and script/console
      }
      
      def self.execute(stdout, arguments=[])
        options = setup_options(stdout,arguments)
        libs =  " -r irb/completion"
        # Perhaps use a console_lib to store any extra methods I may want available in the cosole
        libs << (options[:oauth2] ? setup_oauth2 : setup_api_auth)
        
        bundler = (options[:console] ? "bundle exec" : "")  
        cmd = "#{export_env(options)} #{bundler} #{irb} #{libs} --simple-prompt"
        puts "Loading spark_api gem..."
        exec "#{cmd}"
      end
      
      def self.irb()
        RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
      end
      
      private
      def self.setup_options(stdout,arguments)
        env_options = {
          :oauth2            => false,
          :endpoint          => ENV[OPTIONS_ENV[:endpoint]],
          # OAUTH2 Options
          :access_uri  => ENV[OPTIONS_ENV[:access_uri]],
          :authorization_uri  => ENV[OPTIONS_ENV[:authorization_uri]],
          :redirect_uri  => ENV[OPTIONS_ENV[:redirect_uri]],
          :code  => ENV[OPTIONS_ENV[:code]],
          :username=> ENV[OPTIONS_ENV[:username]],
          :password=> ENV[OPTIONS_ENV[:password]],
          :client_id=> ENV[OPTIONS_ENV[:client_id]],
          :client_secret=> ENV[OPTIONS_ENV[:client_secret]],
          # API AUTH Options
          :api_key => ENV[OPTIONS_ENV[:api_key]], 
          :api_secret => ENV[OPTIONS_ENV[:api_secret]],
          :api_user => ENV[OPTIONS_ENV[:api_user]],
          :ssl_verify => ENV.fetch(OPTIONS_ENV[:ssl_verify], true),
          :console => ENV[OPTIONS_ENV[:console]],
          :middleware => ENV[OPTIONS_ENV[:middleware]],
          :dictionary_version => ENV[OPTIONS_ENV[:dictionary_version]]
        }
        cli_options = {}
        file_options = {}
        parser = OptionParser.new do |opts|
          opts.banner = <<-BANNER.gsub(/^          /,'')
            #{version}
            SparkApi Client Console - http://sparkplatform.com/docs/overview/api
            
            Usage: #{File.basename($0)} [options]
            
            Environment Variables: some options (as indicated below), will default to values of keys set in the environment. 
        
            Options are:
          BANNER
          opts.separator ""
          opts.on("-e","--endpoint ENDPOINT",
                  "URI of the API.",
                  "Default: ENV['#{OPTIONS_ENV[:endpoint]}'] or #{SparkApi::Configuration::DEFAULT_ENDPOINT}") { |arg| cli_options[:endpoint] = arg }

          # OAUTH2
          opts.on("-o","--oauth2",
                  "Run the API using OAuth2 credentials.  The client defaults to using the Spark API authentication mode for access. ",
                  "See http://sparkplatform.com/docs/authentication/authentication for more information on authentication types.",
                  "Default: false") { |arg| cli_options[:oauth2] = arg }
          opts.on("--client_id CLIENT_ID",
                  "OAuth2 client id",
                  "Default: ENV['#{OPTIONS_ENV[:client_id]}']") { |arg| cli_options[:client_id] = arg }
          opts.on("--client_secret CLIENT_SECRET",
                  "OAuth2 client secret",
                  "Default: ENV['#{OPTIONS_ENV[:client_secret]}']") { |arg| cli_options[:client_secret] = arg }
          opts.on("-u","--username USERNAME",
                  "OAuth2 username",
                  "Default: ENV['#{OPTIONS_ENV[:username]}']") { |arg| cli_options[:username] = arg }
          opts.on("-p","--password PASSWORD",
                  "OAuth2 password",
                  "Default: ENV['#{OPTIONS_ENV[:password]}']") { |arg| cli_options[:password] = arg }
          opts.on("--access_uri ACCESS_URI",
                  "OAuth2 path for granting access to the application using one of the supported grant types.",
                  "Default: ENV['#{OPTIONS_ENV[:access_uri]}'] or #{SparkApi::Configuration::DEFAULT_ACCESS_URI}") { |arg| cli_options[:access_uri] = arg }
          opts.on("--redirect_uri REDIRECT_URI",
                  "OAuth2 application redirect for the client id. This needs to match whatever value is saved for the application's client_id",
                  "Default: ENV['#{OPTIONS_ENV[:redirect_uri]}'] or #{SparkApi::Configuration::DEFAULT_REDIRECT_URI}") { |arg| cli_options[:redirect_uri] = arg }
          opts.on("--authorization_uri AUTHORIZATION_URI",
                  "OAuth2 authorization endpoint for a user. This is where the user should go to sign in and authorize client id.",
                  "Default: ENV['#{OPTIONS_ENV[:authorization_uri]}'] or #{SparkApi::Configuration::DEFAULT_AUTH_ENDPOINT}") { |arg| cli_options[:authorization_uri] = arg }
          opts.on("--code CODE",
                  "OAuth2 authorization code used for granting application access to the API for a user") { |arg| cli_options[:code] = arg }
          
          # API AUTH
          opts.on("--api_key API_KEY",
                  "Authentication key for running the api using the default api authentication",
                  "Default: ENV['#{OPTIONS_ENV[:api_key]}']") { |arg| cli_options[:api_key] = arg }
          opts.on("--api_secret API_SECRET",
                  "API secret for the api key",
                   "Default: ENV['#{OPTIONS_ENV[:api_secret]}']") { |arg| cli_options[:api_secret] = arg }
          opts.on("--api_user API_USER",
                  "ID of the Spark user to run the client as.",
                  "Default: ENV['#{OPTIONS_ENV[:api_user]}']") { |arg| cli_options[:api_user] = arg }
          opts.on("--middleware SPARK_MIDDLEWARE",
                  "spark_api for accessing spark, reso_api for accessing reso adapter",
                  "Default: spark_api") { |arg| cli_options[:middleware] = arg }
          opts.on("--dictionary_version DICTIONARY_VERSION",
                  "spark_api for accessing spark, reso_api for accessing reso adapter",
                  "Default: spark_api") { |arg| cli_options[:dictionary_version] = arg }

          # General           
          opts.on("-f", "--file FILE",
                  "Load configuration for yaml file.") { |arg| file_options = parse_file_options(arg) }
          opts.on("--no_verify",
                  "Disable SSL Certificate verification. This is useful for development servers.") { |arg| cli_options[:ssl_verify] = !arg }
          opts.on("-d", "--debug",
                  "Show detailed request logging information.") { |arg| cli_options[:debug] = arg }
          opts.on("-v", "--version",
                  "Show client version.") { stdout.puts version; exit }
          opts.on("-h", "--help",
                  "Show this help message.") { stdout.puts opts; exit }
          opts.parse!(arguments)
        
        end
        options = env_options.merge(file_options.merge(cli_options))
        return options
      end

      def self.setup_api_auth
        " -r #{File.dirname(__FILE__) + '/../../lib/spark_api/cli/api_auth.rb'}"
      end
  
      def self.setup_oauth2
        " -r #{File.dirname(__FILE__) + '/../../lib/spark_api/cli/oauth2.rb'}"
      end
      
      def self.export_env(options)
        run_env = ""
        OPTIONS_ENV.each do |k,v|
          run_env << " #{v}=\"#{options[k]}\"" unless options[k].nil?
        end
        run_env
      end
      
      private 
      def self.parse_file_options(file)
        yaml = SparkApi::Configuration::YamlConfig.new(file)
        return {:oauth2 => yaml.oauth2}.merge(yaml.client_keys.merge(yaml.oauth2_keys))
      end
      
      def self.version
        "SparkApi v#{SparkApi::VERSION}"
      end
    end
  end
end