class Pry::CommandSet

def add_command(command)
  commands[command.match] = command
end

def after_command(search, &block)
  cmd = find_command_by_match_or_listing(search)
  cmd.hooks[:after] << block
end

def alias_command(match, action,  options={})
  cmd = find_command(action) or fail "Command: `#{action}` not found"
  original_options = cmd.options.dup
  options = original_options.merge!({
                                      :desc => "Alias for `#{action}`",
                                      :listing => match
                                    }).merge!(options)
  # ensure default description is used if desc is nil
  desc = options.delete(:desc).to_s
  c = block_command match, desc, options do |*args|
    run action, *args
  end
  c.class_eval do
    define_method(:complete) do |input|
      cmd.new(context).complete(input)
    end
  end
  c.group "Aliases"
  c
end

def before_command(search, &block)
  cmd = find_command_by_match_or_listing(search)
  cmd.hooks[:before].unshift block
end

def block_command(match, description="No description.", options={}, &block)
  description, options = ["No description.", description] if description.is_a?(Hash)
  options = Pry::Command.default_options(match).merge!(options)
  commands[match] = Pry::BlockCommand.subclass(match, description, options, helper_module, &block)
end

def complete(search, context={})
  if command = find_command(search)
    command.new(context).complete(search)
  else
    commands.keys.select do |x|
      String === x && x.start_with?(search)
    end.map{ |command| command + " " } + Bond::DefaultMission.completions
  end
end

def create_command(match, description="No description.", options={}, &block)
  description, options = ["No description.", description] if description.is_a?(Hash)
  options = Pry::Command.default_options(match).merge!(options)
  commands[match] = Pry::ClassCommand.subclass(match, description, options, helper_module, &block)
  commands[match].class_eval(&block)
  commands[match]
end

def delete(*searches)
  searches.each do |search|
    cmd = find_command_by_match_or_listing(search)
    commands.delete cmd.match
  end
end

def deprecated_command(name_of_deprecated_command, deprecation_message, matcher=name_of_deprecated_command)
  create_command name_of_deprecated_command do
    match matcher
    description ""
    define_method(:process) do
      output.puts "DEPRECATED: #{deprecation_message}"
    end
  end
end

def desc(search, description=nil)
  cmd = find_command_by_match_or_listing(search)
  return cmd.description if !description
  cmd.description = description
end

def each(&block)
  @commands.each(&block)
end

def find_command(val)
  commands.values.select{ |c| c.matches?(val) }.sort_by{ |c| c.match_score(val) }.last
end

def find_command_by_match_or_listing(match_or_listing)
  cmd = (commands[match_or_listing] ||
    Pry::Helpers::BaseHelpers.find_command(match_or_listing, commands))
  cmd or raise ArgumentError, "Cannot find a command: '#{match_or_listing}'!"
end

def find_command_for_help(search)
  find_command(search) || (begin
    find_command_by_match_or_listing(search)
  rescue ArgumentError
    nil
  end)
end

def helpers(&block)
  helper_module.class_eval(&block)
end

def import(*sets)
  sets.each do |set|
    commands.merge! set.commands
    helper_module.send :include, set.helper_module
  end
  self
end

def import_from(set, *matches)
  helper_module.send :include, set.helper_module
  matches.each do |match|
    cmd = set.find_command_by_match_or_listing(match)
    commands[cmd.match] = cmd
  end
  self
end

def initialize(*imported_sets, &block)
  @commands      = {}
  @helper_module = Module.new
  import(*imported_sets)
  instance_eval(&block) if block
end

def list_commands
  commands.keys
end

def process_line(val, context={})
  if command = find_command(val)
    context = context.merge(:command_set => self)
    retval = command.new(context).process_line(val)
    Result.new(true, retval)
  else
    Result.new(false)
  end
end

def rename_command(new_match, search, options={})
  cmd = find_command_by_match_or_listing(search)
  options = {
    :listing     => new_match,
    :description => cmd.description
  }.merge!(options)
  commands[new_match] = cmd.dup
  commands[new_match].match = new_match
  commands[new_match].description = options.delete(:description)
  commands[new_match].options.merge!(options)
  commands.delete(cmd.match)
end

def run_command(context, match, *args)
  command = commands[match] or raise NoCommandError.new(match, self)
  command.new(context).call_safely(*args)
end

def valid_command?(val)
  !!find_command(val)
end