class Thor::Shell::Basic

def answer_match(possibilities, answer, case_insensitive)
  if case_insensitive
    possibilities.detect{ |possibility| possibility.downcase == answer.downcase }
  else
    possibilities.detect{ |possibility| possibility == answer }
  end
end

def ask(statement, *args)
  options = args.last.is_a?(Hash) ? args.pop : {}
  color = args.first
  if options[:limited_to]
    ask_filtered(statement, color, options)
  else
    ask_simply(statement, color, options)
  end
end

def ask_filtered(statement, color, options)
  answer_set = options[:limited_to]
  case_insensitive = options.fetch(:case_insensitive, false)
  correct_answer = nil
  until correct_answer
    answers = answer_set.join(", ")
    answer = ask_simply("#{statement} [#{answers}]", color, options)
    correct_answer = answer_match(answer_set, answer, case_insensitive)
    say("Your response must be one of: [#{answers}]. Please try again.") unless correct_answer
  end
  correct_answer
end

def ask_simply(statement, color, options)
  default = options[:default]
  message = [statement, ("(#{default})" if default), nil].uniq.join(" ")
  message = prepare_message(message, *color)
  result = Thor::LineEditor.readline(message, options)
  return unless result
  result = result.strip
  if default && result == ""
    default
  else
    result
  end
end

def can_display_colors?
  false
end

def error(statement)
  stderr.puts statement
end

def file_collision(destination)
  return true if @always_force
  options = block_given? ? "[Ynaqdhm]" : "[Ynaqh]"
  loop do
    answer = ask(
      %[Overwrite #{destination}? (enter "h" for help) #{options}],
      add_to_history: false
    )
    case answer
    when nil
      say ""
      return true
    when is?(:yes), is?(:force), ""
      return true
    when is?(:no), is?(:skip)
      return false
    when is?(:always)
      return @always_force = true
    when is?(:quit)
      say "Aborting..."
      raise SystemExit
    when is?(:diff)
      show_diff(destination, yield) if block_given?
      say "Retrying..."
    when is?(:merge)
      if block_given? && !merge_tool.empty?
        merge(destination, yield)
        return nil
      end
      say "Please specify merge tool to `THOR_MERGE` env."
    else
      say file_collision_help(block_given?)
    end
  end
end

def file_collision_help(block_given) #:nodoc:
  help = <<-HELP
  Y - yes, overwrite
  n - no, do not overwrite
  a - all, overwrite this and all others
  q - quit, abort
  h - help, show this help
  HELP
  if block_given
    help << <<-HELP
  d - diff, show the differences between the old and the new
  m - merge, run merge tool
    HELP
  end
  help
end

def git_merge_tool #:nodoc:
  `git config merge.tool`.rstrip rescue ""
end

def indent(count = 1)
  orig_padding = padding
  self.padding = padding + count
  yield
  self.padding = orig_padding
end

def initialize #:nodoc:
  @base = nil
  @mute = false
  @padding = 0
  @always_force = false
end

def is?(value) #:nodoc:
  value = value.to_s
  if value.size == 1
    /\A#{value}\z/i
  else
    /\A(#{value}|#{value[0, 1]})\z/i
  end
end

def lookup_color(color)
  return color unless color.is_a?(Symbol)
  self.class.const_get(color.to_s.upcase)
end

def merge(destination, content) #:nodoc:
  require "tempfile"
  Tempfile.open([File.basename(destination), File.extname(destination)], File.dirname(destination)) do |temp|
    temp.write content
    temp.rewind
    system %(#{merge_tool} "#{temp.path}" "#{destination}")
  end
end

def merge_tool #:nodoc:
  @merge_tool ||= ENV["THOR_MERGE"] || git_merge_tool
end

def mute
  @mute = true
  yield
ensure
  @mute = false
end

def mute?
  @mute
end

def no?(statement, color = nil)
  !!(ask(statement, color, add_to_history: false) =~ is?(:no))
end

def padding=(value)
  @padding = [0, value].max
end

def prepare_message(message, *color)
  spaces = "  " * padding
  spaces + set_color(message.to_s, *color)
end

def print_in_columns(array)
  printer = ColumnPrinter.new(stdout)
  printer.print(array)
end

def print_table(array, options = {}) # rubocop:disable Metrics/MethodLength
  printer = TablePrinter.new(stdout, options)
  printer.print(array)
end

def print_wrapped(message, options = {})
  printer = WrappedPrinter.new(stdout, options)
  printer.print(message)
end

def quiet? #:nodoc:
  mute? || (base && base.options[:quiet])
end

def say(message = "", color = nil, force_new_line = (message.to_s !~ /( |\t)\Z/))
  return if quiet?
  buffer = prepare_message(message, *color)
  buffer << "\n" if force_new_line && !message.to_s.end_with?("\n")
  stdout.print(buffer)
  stdout.flush
end

def say_error(message = "", color = nil, force_new_line = (message.to_s !~ /( |\t)\Z/))
  return if quiet?
  buffer = prepare_message(message, *color)
  buffer << "\n" if force_new_line && !message.to_s.end_with?("\n")
  stderr.print(buffer)
  stderr.flush
end

def say_status(status, message, log_status = true)
  return if quiet? || log_status == false
  spaces = "  " * (padding + 1)
  status = status.to_s.rjust(12)
  margin = " " * status.length + spaces
  color  = log_status.is_a?(Symbol) ? log_status : :green
  status = set_color status, color, true if color
  message = message.to_s.chomp.gsub(/(?<!\A)^/, margin)
  buffer = "#{status}#{spaces}#{message}\n"
  stdout.print(buffer)
  stdout.flush
end

def set_color(string, *) #:nodoc:
  string
end

def show_diff(destination, content) #:nodoc:
  diff_cmd = ENV["THOR_DIFF"] || ENV["RAILS_DIFF"] || "diff -u"
  require "tempfile"
  Tempfile.open(File.basename(destination), File.dirname(destination)) do |temp|
    temp.write content
    temp.rewind
    system %(#{diff_cmd} "#{destination}" "#{temp.path}")
  end
end

def stderr
  $stderr
end

def stdout
  $stdout
end

def unix?
  Terminal.unix?
end

def yes?(statement, color = nil)
  !!(ask(statement, color, add_to_history: false) =~ is?(:yes))
end