class Thor::Shell::Basic

def as_unicode
  yield
end

def as_unicode
  old, $KCODE = $KCODE, "U"
  yield
ensure
  $KCODE = old
end

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

def ask_filtered(statement, answer_set, *args)
  correct_answer = nil
  until correct_answer
    answer = ask_simply("#{statement} #{answer_set.inspect}", *args)
    correct_answer = answer_set.include?(answer) ? answer : nil
    answers = answer_set.map(&:inspect).join(", ")
    say("Your response must be one of: [#{answers}]. Please try again.") unless correct_answer
  end
  correct_answer
end

def ask_simply(statement, color = nil)
  say("#{statement} ", color)
  stdin.gets.strip
end

def dynamic_width
  @dynamic_width ||= (dynamic_width_stty.nonzero? || dynamic_width_tput)
end

def dynamic_width_stty
  %x{stty size 2>/dev/null}.split[1].to_i
end

def dynamic_width_tput
  %x{tput cols 2>/dev/null}.to_i
end

def error(statement)
  stderr.puts statement
end

def file_collision(destination)
  return true if @always_force
  options = block_given? ? "[Ynaqdh]" : "[Ynaqh]"
  while true
    answer = ask %[Overwrite #{destination}? (enter "h" for help) #{options}]
    case answer
      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...'
      else
        say file_collision_help
    end
  end
end

def file_collision_help #:nodoc:
 overwrite
do not overwrite
 overwrite this and all others
, abort
, show the differences between the old and the new
, show this help
end

def initialize #:nodoc:
  @base, @mute, @padding = nil, false, 0
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 mute
  @mute = true
  yield
ensure
  @mute = false
end

def mute?
  @mute ||= false
end

def no?(statement, color=nil)
  !yes?(statement, color)
end

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

def print_table(table, options={})
  return if table.empty?
  formats, indent, colwidth = [], options[:indent].to_i, options[:colwidth]
  options[:truncate] = terminal_width if options[:truncate] == true
  formats << "%-#{colwidth + 2}s" if colwidth
  start = colwidth ? 1 : 0
  colcount = table.max{|a,b| a.size <=> b.size }.size
  maximas = []
  start.upto(colcount - 1) do |i|
    maxima = table.map {|row| row[i] ? row[i].to_s.size : 0 }.max
    maximas << maxima
    if i == colcount -1
      # Don't output 2 trailing spaces when printing the last column
      formats << "%-s"
    else
      formats << "%-#{maxima + 2}s"
    end
  end
  formats[0] = formats[0].insert(0, " " * indent)
  formats << "%s"
  table.each do |row|
    sentence = ""
    row.each_with_index do |column, i|
      maxima = maximas[i]
      if column.is_a?(Numeric)
        if i == row.size - 1
          # Don't output 2 trailing spaces when printing the last column
          f = "%#{maxima}s"
        else
          f = "%#{maxima}s  "
        end
      else
        f = formats[i]
      end
      sentence << f % column.to_s
    end
    sentence = truncate(sentence, options[:truncate]) if options[:truncate]
    stdout.puts sentence
  end
end

def print_wrapped(message, options={})
  indent = options[:indent] || 0
  width = terminal_width - indent
  paras = message.split("\n\n")
  paras.map! do |unwrapped|
    unwrapped.strip.gsub(/\n/, " ").squeeze(" ").
    gsub(/.{1,#{width}}(?:\s|\Z)/){($& + 5.chr).
    gsub(/\n\005/,"\n").gsub(/\005/,"\n")}
  end
  paras.each do |para|
    para.split("\n").each do |line|
      stdout.puts line.insert(0, " " * indent)
    end
    stdout.puts unless para == paras.last
  end
end

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

def say(message="", color=nil, force_new_line=(message.to_s !~ /( |\t)$/))
  message = message.to_s
  message = set_color(message, *color) if color
  spaces = "  " * padding
  if force_new_line
    stdout.puts(spaces + message)
  else
    stdout.print(spaces + message)
  end
  stdout.flush
end

def say_status(status, message, log_status=true)
  return if quiet? || log_status == false
  spaces = "  " * (padding + 1)
  color  = log_status.is_a?(Symbol) ? log_status : :green
  status = status.to_s.rjust(12)
  status = set_color status, color, true if color
  stdout.puts "#{status}#{spaces}#{message}"
  stdout.flush
end

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

def show_diff(destination, content) #:nodoc:
  diff_cmd = ENV['THOR_DIFF'] || ENV['RAILS_DIFF'] || 'diff -u'
  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 stdin
  $stdin
end

def stdout
  $stdout
end

def terminal_width
  if ENV['THOR_COLUMNS']
    result = ENV['THOR_COLUMNS'].to_i
  else
    result = unix? ? dynamic_width : 80
  end
  (result < 10) ? 80 : result
rescue
  80
end

def truncate(string, width)
  as_unicode do
    chars = string.chars.to_a
    if chars.length <= width
      chars.join
    else
      ( chars[0, width-3].join ) + "..."
    end
  end
end

def unix?
  RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
end

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