class Pry::Slop

def [](key)
  option = fetch_option(key)
  option.value if option
end

def add_callback(label, &block)
  (@callbacks[label] ||= []) << block
end

def autocreate(items, index)
  flag = items[index]
  return if fetch_option(flag) || @trash.include?(index)
  option = build_option(Array(flag))
  argument = items[index + 1]
  option.config[:argument] = (argument && argument !~ /\A--?/)
  option.config[:autocreated] = true
  options << option
end

def banner(banner = nil)
  config[:banner] = banner if banner
  config[:banner]
end

def banner=(banner)
  config[:banner] = banner
end

def build_option(objects, &block)
  config = {}
  config[:argument] = true if @config[:arguments]
  config[:optional_argument] = true if @config[:optional_arguments]
  if objects.last.is_a?(Hash)
    config.merge!(objects.last)
    objects.pop
  end
  short = extract_short_flag(objects, config)
  long  = extract_long_flag(objects, config)
  desc  = objects[0].respond_to?(:to_str) ? objects.shift : nil
  Option.new(self, short, long, desc, config, &block)
end

def clean(object)
  object.to_s.sub(/\A--?/, '')
end

def command(command, options = {}, &block)
  @commands[command.to_s] = Pry::Slop.new(options, &block)
end

def commands_to_help
  padding = 0
  @commands.each { |c, _| padding = c.size if c.size > padding }
  @commands.map do |cmd, opts|
    "  #{cmd}#{' ' * (padding - cmd.size)}   #{opts.description}"
  end.join("\n")
end

def description(desc = nil)
  config[:description] = desc if desc
  config[:description]
end

def description=(desc)
  config[:description] = desc
end

def each(&block)
  options.each(&block)
end

def execute_multiple_switches(option, argument, index)
  execute_option(option, nil, index)
  argument.split('').each do |key|
    next unless (opt = fetch_option(key))
    opt.count += 1
    execute_option(opt, nil, index, key)
  end
end

def execute_option(option, argument, index, item = nil)
  unless option
    if config[:multiple_switches] && strict?
      raise InvalidOptionError, "Unknown option -#{item}"
    end
    return
  end
  if argument
    unless item && item.end_with?("=#{argument}")
      @trash << index + 1 unless option.argument_in_value
    end
    option.value = argument
  else
    option.value = option.count > 0
  end
  if option.match? && !argument.match(option.config[:match])
    raise InvalidArgumentError, "#{argument} is an invalid argument"
  end
  option.call(option.value)
end

def extract_long_flag(objects, config)
  flag = objects.first.to_s
  return unless flag =~ /\A(?:--?)?[a-zA-Z][a-zA-Z0-9_-]+\=?\??\z/
  config[:argument] ||= true if flag.end_with?('=')
  config[:optional_argument] = true if flag.end_with?('=?')
  objects.shift
  clean(flag).sub(/\=\??\z/, '')
end

def extract_option(flag)
  option = fetch_option(flag)
  option ||= fetch_option(flag.downcase) if config[:ignore_case]
  option ||= fetch_option(flag.gsub(/([^-])-/, '\1_'))
  unless option
    case flag
    when /\A--?([^=]+)=(.+)\z/, /\A-([a-zA-Z])(.+)\z/, /\A--no-(.+)\z/
      option = fetch_option(Regexp.last_match(1))
      argument = Regexp.last_match(2) || false
      option.argument_in_value = true if option
    end
  end
  [option, argument]
end

def extract_short_flag(objects, config)
  flag = clean(objects.first)
  if flag.size == 2 && flag.end_with?('=')
    config[:argument] ||= true
    flag.chop!
  end
  return unless flag.size == 1
  objects.shift
  flag
end

def fetch_command(command)
  @commands[command.to_s]
end

def fetch_option(key)
  options.find { |option| [option.long, option.short].include?(clean(key)) }
end

def initialize(config = {}, &block)
  @config = DEFAULT_OPTIONS.merge(config)
  @options = []
  @commands = {}
  @trash = []
  @triggered_options = []
  @unknown_options = []
  @callbacks = {}
  @separators = {}
  @runner = nil
  if block_given?
    block.arity == 1 ? yield(self) : instance_eval(&block)
  end
  return unless config[:help]
  on('-h', '--help', 'Display this help message.', tail: true) do
    warn help
  end
end

def method_missing(method, *args, &block)
  meth = method.to_s
  if meth.end_with?('?')
    meth = meth.chop
    present?(meth) || present?(meth.tr('_', '-'))
  else
    super
  end
end

def missing
  (options - @triggered_options).map(&:key)
end

def on(*objects, &block)
  option = build_option(objects, &block)
  options << option
  option
end

def optspec(string, config = {})
  config[:banner], optspec = string.split(/^--+$/, 2) if string[/^--+$/]
  lines = optspec.split("\n").reject(&:empty?)
  opts  = Slop.new(config)
  lines.each do |line|
    opt, description = line.split(' ', 2)
    short, long = opt.split(',').map { |s| s.sub(/\A--?/, '') }
    opt = opts.on(short, long, description)
    if long && long.end_with?('=')
      long.sub!(/\=$/, '')
      opt.config[:argument] = true
    end
  end
  opts
end

def parse(items = ARGV, config = {}, &block)
  parse! items.dup, config, &block
end

def parse(items = ARGV, &block)
  parse! items.dup, &block
  items
end

def parse!(items = ARGV, config = {}, &block)
  if items.is_a?(Hash) && config.empty?
    config = items
    items = ARGV
  end
  slop = Pry::Slop.new config, &block
  slop.parse! items
  slop
end

def parse!(items = ARGV, &block)
  if items.empty? && @callbacks[:empty]
    @callbacks[:empty].each { |cb| cb.call(self) }
    return items
  end
  if (cmd = @commands[items[0]])
    return cmd.parse! items[1..-1]
  end
  items.each_with_index do |item, index|
    @trash << index && break if item == '--'
    autocreate(items, index) if config[:autocreate]
    process_item(items, index, &block) unless @trash.include?(index)
  end
  items.reject!.with_index { |_item, index| @trash.include?(index) }
  missing_options = options.select { |opt| opt.required? && opt.count < 1 }
  if missing_options.any?
    raise MissingOptionError,
          "Missing required option(s): #{missing_options.map(&:key).join(', ')}"
  end
  if @unknown_options.any?
    raise InvalidOptionError, "Unknown options #{@unknown_options.join(', ')}"
  end
  if @triggered_options.empty? && @callbacks[:no_options]
    @callbacks[:no_options].each { |cb| cb.call(self) }
  end
  @runner.call(self, items) if @runner.respond_to?(:call)
  items
end

def present?(*keys)
  keys.all? { |key| (opt = fetch_option(key)) && opt.count > 0 }
end

def process_item(items, index, &block)
  return unless (item = items[index])
  option, argument = extract_option(item) if item.start_with?('-')
  if option
    option.count += 1 unless item.start_with?('--no-')
    option.count += 1 if option.key[0, 3] == "no-"
    @trash << index
    @triggered_options << option
    if option.expects_argument?
      argument ||= items.at(index + 1)
      if !argument || argument =~ /\A--?[a-zA-Z][a-zA-Z0-9_-]*\z/
        raise MissingArgumentError, "#{option.key} expects an argument"
      end
      execute_option(option, argument, index, item)
    elsif option.accepts_optional_argument?
      argument ||= items.at(index + 1)
      if argument && argument =~ /\A([^\-?]|-\d)+/
        execute_option(option, argument, index, item)
      else
        option.call(nil)
      end
    elsif config[:multiple_switches] && argument
      execute_multiple_switches(option, argument, index)
    else
      option.value = option.count > 0
      option.call(nil)
    end
  else
    @unknown_options << item if strict? && item =~ /\A--?/
    yield(item) if block && !@trash.include?(index)
  end
end

def respond_to_missing?(method_name, include_all = false)
  options.any? { |o| o.key == method_name.to_s.chop } || super
end

def run(callable = nil, &block)
  @runner = callable || block
  return if @runner.respond_to?(:call)
  raise ArgumentError, "You must specify a callable object or a block to #run"
end

def separator(text)
  if @separators[options.size]
    @separators[options.size] << "\n#{text}"
  else
    @separators[options.size] = text
  end
end

def strict?
  config[:strict]
end

def to_hash(include_commands = false)
  hash = Hash[options.map { |opt| [opt.key.to_sym, opt.value] }]
  if include_commands
    @commands.each { |cmd, opts| hash.merge!(cmd.to_sym => opts.to_hash) }
  end
  hash
end

def to_s
  heads  = options.reject(&:tail?)
  tails  = (options - heads)
  opts = (heads + tails).select(&:help).map(&:to_s)
  optstr = opts.each_with_index.map do |o, i|
    (str = @separators[i + 1]) ? [o, str].join("\n") : o
  end.join("\n")
  if @commands.any?
    optstr << "\n" unless optstr.empty?
    optstr << "\nAvailable commands:\n\n"
    optstr << commands_to_help
    optstr << "\n\nSee `<command> --help` for more information on a specific command."
  end
  banner = config[:banner]
  banner ||= "Usage: #{File.basename($PROGRAM_NAME, '.*')}" \
             "#{' [command]' if @commands.any?} [options]"
  if banner
    "#{banner}\n#{@separators[0] ? "#{@separators[0]}\n" : ''}#{optstr}"
  else
    optstr
  end
end