#!/usr/bin/env ruby

$LOAD_PATH.unshift File.join(__dir__, '../lib')

ENV["SCOUT_NOCOLOR"] = "true" if ARGV.include? "--nocolor"

ENV["SCOUT_NO_PROGRESS"] = "true" if ARGV.include? "--nobar"

require 'scout-gear'

class CmdStop < Exception
  attr_accessor :exit_status
  def initialize(exit_status = 0)
    @exit_status = exit_status
  end
end

# Add paths to scout repos under --dev to LOAD_PATHS
dev_dir = nil
if _i = ARGV.index("--dev")
  dev_dir = ARGV[_i+1]
  ARGV.delete "--dev"
  ARGV.delete dev_dir
end

if dev_dir.nil? 
  _s = nil
  ARGV.each_with_index do |s,i|
    if s.match(/^--dev(?:=(.*))?/)
      dev_dir = $1
      _s = s
      next
    end
  end
  ARGV.delete _s if _s
end

if dev_dir.nil? && ENV["SCOUT_DEV"]
  dev_dir = ENV["SCOUT_DEV"]
  ARGV.delete "--dev"
  ARGV.delete dev_dir
end

if dev_dir
  ['scout-*/lib'].each do |pattern|
    Dir.glob(File.join(File.expand_path(dev_dir), pattern)).each do |f|
      $LOAD_PATH.unshift f
    end
  end
  ['rbbt-*/lib'].each do |pattern|
    Dir.glob(File.join(File.expand_path(dev_dir), pattern)).each do |f|
      $LOAD_PATH.unshift f
    end
  end
end

require 'scout'

require 'scout/simple_opt'

options = SOPT.setup <<EOF
Ruby bioinformatics toolkit

$ #{$0} <command> <subcommand> ... -a --arg1 --arg2='value' --arg3 'another-value'


--log*                  #{Log.color :yellow, "Log level from 0 (debug) 6 (errors)"}
--dev*                  #{Log.color :yellow, "Find development libraries in the directory specified"}
--nocolor               #{Log.color :yellow, "Disable colored output"}
--nobar                 #{Log.color :yellow, "Disable progress report"}
--locate_file           #{Log.color :yellow, "Report the location of the script instead of executing it"}
-ck--config_keys*       #{Log.color :yellow, "Override some config keys"}
EOF

Log.nocolor = true if options[:nocolor]

locate = options.delete :locate_file

if options[:log_file]
  Log.logfile(options.delete(:log_file))
end

if options[:log]
  Log.severity = options.delete(:log).to_i
else
  global_severity = Log.get_level(Scout.etc.log_severity.read.strip) if Scout.etc.log_severity.exists?
  if ENV["SCOUT_LOG"]
    Log.severity = ENV["SCOUT_LOG"].to_i 
  else
    global_severity = Log.get_level(Scout.etc.log_severity.read.strip) if Scout.etc.log_severity.exists?
    Log.severity = global_severity.to_i if global_severity
  end
end

if config_keys = options.delete(:config_keys)
  config_keys.split(",").each do |config|
    config = config.strip
    Scout::Config.process_config config
  end
end

$scout_command_dir = Scout.bin.scout
$scout_command_dir.path_maps[:scout_commands] = File.join(File.dirname(__dir__), "{PATH/bin\\/scout/scout_commands}")

SOPT.description =<<EOF
This command controls many aspects of the Scout framework, from configuration tasks to running applications. 

Commands are implemented in separate files under the Scout path '#{$scout_command_dir}'. 
Known locations are: #{([$scout_command_dir] + $scout_command_dir.find_all) * ", " }. 
You can place your own commads at #{$scout_command_dir.find(:user)}.
EOF

if options[:profile]
  require 'ruby-prof'
  RubyProf.start
end


def prev_dir(prev)
    scout_command_dir = $scout_command_dir

    prev.each do |previous_command|
        scout_command_dir = scout_command_dir[previous_command]
    end

    scout_command_dir
end

def commands(prev)
    scout_command_dir = prev_dir(prev)

    command_file_dirs = scout_command_dir.find_all
    command_files = command_file_dirs.collect{|d| d.glob('*') }.flatten
    command_files.collect{|p| File.basename(p) }.uniq.reject{|p| p =~ /\.desc$/}.sort
end

def scout_usage(prev = nil)
  puts SOPT.doc

  if prev
    puts
    puts Log.color :magenta, "## COMMANDS"
    puts
    puts Log.color :magenta, "Command:"
    puts 
    puts "  #{File.basename($0)} #{prev * " "}"
    puts 
    puts Log.color :magenta, "Subcommands:"
    puts 
    prev_dir = prev_dir(prev)
    commands(prev).each do |command|
      directory = File.directory? prev_dir[command].find
      if directory
        puts "  " << Log.color(:blue, command)
      else
        puts "  " << command
      end
    end
  end
  puts
  true
end

alias usage scout_usage 

def print_error(error, backtrace = nil)
  puts Log.color :magenta, "## ERROR"
  puts
  if backtrace
    puts Log.color :red, "Backtrace: "
    puts
    puts Log.color_stack(backtrace.reverse) * "\n"
    puts
  end
  puts Log.color :red, error
  puts
end

def aliases
  @aliases ||= Scout.etc.cmd_alias.exists? ? Scout.etc.cmd_alias.yaml : {}
end

def tokenize_cmd_params(str)
 return str if Array === str
 str.scan(/
          (?:["']([^"']*?)["']) |
          ([^"'\s]+)
          /x).flatten.compact
end

def cmd_alias
  while ARGV[0] && aliases.include?(ARGV[0])
    ARGV.replace tokenize_cmd_params(aliases[ARGV[0]]) + ARGV[1..-1]
  end
end
    
dir = $scout_command_dir
$previous_commands = []

cmd_alias

exit_status = 0
begin
  while ARGV.any?
    $command = ARGV.shift
    case
    when File.directory?(dir[$command].find)
      $previous_commands << $command
      dir = dir[$command]
    when dir[$command].exists?
      if locate
        puts dir[$command].find
        exit_status = 0
        exit exit_status
      else
        load dir[$command].find
        exit_status = 0
        exit exit_status
      end
    when File.exist?($command)
      load $command
      exit_status = 0
      exit exit_status
    else
      error = "Command '#{$command }' not understood"
      scout_usage($previous_commands)
      print_error(error)
      exit_status = -1
      exit exit_status
    end
  end

  scout_usage($previous_commands)
  exit_status = 0

rescue ParameterException
  puts
  scout_usage
  print_error($!.message, $!.backtrace)
  puts
  exit_status = -1
rescue SystemExit,CmdStop
  exit_status = $!.status
rescue Exception
  Log.exception $!
  exit_status = -1
ensure
  if options[:profile]
    result = RubyProf.stop
    printer = RubyProf::FlatPrinter.new(result)
    printer.print(STDOUT, :min_percent => 10)
  end
end

exit exit_status