class Mercenary::Command

def action(&block)
  @actions << block
end

def add_default_options(opts)
  option "show_help", "-h", "--help", "Show this message"
  option "show_version", "-v", "--version", "Print the name and version"
  option "show_backtrace", "-t", "--trace", "Show the full backtrace when an error occurs"
  opts.on("-v", "--version", "Print the version") do
    puts "#{name} #{version}"
    exit(0)
  end
  opts.on("-t", "--trace", "Show full backtrace if an error occurs") do
    @trace = true
  end
  opts.on_tail("-h", "--help", "Show this message") do
    puts self
    exit
  end
end

def alias(cmd_name)
  logger.debug "adding alias to parent for self: '#{cmd_name}'"
  aliases << cmd_name
  @parent.commands[cmd_name] = self
end

def command(cmd_name)
  cmd = Command.new(cmd_name, self)
  yield cmd
  @commands[cmd_name] = cmd
end

def default_command(command_name = nil)
  if command_name
    if commands.key?(command_name)
      @default_command = commands[command_name] if command_name
      @default_command
    else
      raise ArgumentError, "'#{command_name}' couldn't be found in this command's list of commands."
    end
  else
    @default_command
  end
end

def description(desc = nil)
  @description = desc if desc
  @description
end

def execute(argv = [], config = {})
  if actions.empty? && !default_command.nil?
    default_command.execute
  else
    actions.each { |a| a.call(argv, config) }
  end
end

def full_name
  the_name = []
  the_name << parent.full_name if parent&.full_name
  the_name << name
  the_name.join(" ")
end

def go(argv, opts, config)
  opts.banner = "Usage: #{syntax}"
  process_options(opts, config)
  add_default_options(opts)
  if argv[0] && cmd = commands[argv[0].to_sym]
    logger.debug "Found subcommand '#{cmd.name}'"
    argv.shift
    cmd.go(argv, opts, config)
  else
    logger.debug "No additional command found, time to exec"
    self
  end
end

def has_command?(sub_command)
  commands.key?(sub_command)
end

def ident
  "<Command name=#{identity}>"
end

def identity
  "#{full_name} #{version}".strip
end

def initialize(name, parent = nil)
  @name     = name
  @options  = []
  @commands = {}
  @actions  = []
  @map      = {}
  @parent   = parent
  @trace    = false
  @aliases  = []
end

def logger(level = nil)
  unless @logger
    @logger = Logger.new(STDOUT)
    @logger.level = level || Logger::INFO
    @logger.formatter = proc do |severity, _datetime, _progname, msg|
      "#{identity} | " << "#{severity.downcase.capitalize}:".ljust(7) << " #{msg}\n"
    end
  end
  @logger.level = level unless level.nil?
  @logger
end

def names_and_aliases
  ([name.to_s] + aliases).compact.join(", ")
end

def option(sym, *options)
  new_option = Option.new(sym, options)
  @options << new_option
  @map[new_option] = sym
end

def process_options(opts, config)
  options.each do |option|
    opts.on(*option.for_option_parser) do |x|
      config[map[option]] = x
    end
  end
end

def summarize
  "  #{names_and_aliases.ljust(20)}  #{description}"
end

def syntax(syntax = nil)
  @syntax = syntax if syntax
  syntax_list = []
  syntax_list << parent.syntax.to_s.gsub(%r!<[\w\s-]+>!, "").gsub(%r!\[[\w\s-]+\]!, "").strip if parent
  syntax_list << (@syntax || name.to_s)
  syntax_list.join(" ")
end

def to_s
  Presenter.new(self).print_command
end

def version(version = nil)
  @version = version if version
  @version
end