module Thor::Actions

def self.included(base) #:nodoc:
  base.extend ClassMethods
  return unless base.respond_to?(:class_option)
  base.class_option :pretend, :type => :boolean, :aliases => "-p", :group => :runtime,
                              :desc => "Run but do not make any changes"
  base.class_option :force, :type => :boolean, :aliases => "-f", :group => :runtime,
                            :desc => "Overwrite files that already exist"
  base.class_option :skip, :type => :boolean, :aliases => "-s", :group => :runtime,
                           :desc => "Skip files that already exist"
  base.class_option :quiet, :type => :boolean, :aliases => "-q", :group => :runtime,
                            :desc => "Supress status output"
end

def _cleanup_options_and_set(options, key) #:nodoc:
  case options
    when Array
      %w(--force -f --skip -s).each { |i| options.delete(i) }
      options << "--#{key}"
    when Hash
      [:force, :skip, "force", "skip"].each { |i| options.delete(i) }
      options.merge!(key => true)
  end
end

def _shared_configuration #:nodoc:
  super.merge!(:destination_root => self.destination_root)
end

def action(instance) #:nodoc:
  if behavior == :revoke
    instance.revoke!
  else
    instance.invoke!
  end
end

def append_file(path, data=nil, config={}, &block)
  return unless behavior == :invoke
  path = File.expand_path(path, destination_root)
  say_status :append, relative_to_original_destination_root(path), config.fetch(:verbose, true)
  File.open(path, 'ab') { |file| file.write(data || block.call) } unless options[:pretend]
end

def apply(path, config={})
  verbose = config.fetch(:verbose, true)
  path    = find_in_source_paths(path) unless path =~ /^http\:\/\//
  say_status :apply, path, verbose
  shell.padding += 1 if verbose
  instance_eval(open(path).read)
  shell.padding -= 1 if verbose
end

def chmod(path, mode, config={})
  return unless behavior == :invoke
  path = File.expand_path(path, destination_root)
  say_status :chmod, relative_to_original_destination_root(path), config.fetch(:verbose, true)
  FileUtils.chmod_R(mode, path) unless options[:pretend]
end

def copy_file(source, destination=nil, config={})
  destination ||= source
  source = File.expand_path(find_in_source_paths(source.to_s))
  create_file destination, nil, config do
    File.read(source)
  end
end

def create_file(destination, data=nil, config={}, &block)
  action CreateFile.new(self, destination, block || data.to_s, config)
end

def destination_root
  @destination_stack.last
end

def destination_root=(root)
  @destination_stack ||= []
  @destination_stack[0] = File.expand_path(root || '')
end

def directory(source, destination=nil, config={})
  action Directory.new(self, source, destination || source, config)
end

def empty_directory(destination, config={})
  action EmptyDirectory.new(self, destination, config)
end

def find_in_source_paths(file)
  relative_root = relative_to_original_destination_root(destination_root, false)
  source_paths.each do |source|
    source_file = File.expand_path(file, File.join(source, relative_root))
    return source_file if File.exists?(source_file)
  end
  if source_paths.empty?
    raise Error, "You don't have any source path defined for class #{self.class.name}. To fix this, " <<
                 "you can define a source_root in your class."
  else
    raise Error, "Could not find #{file.inspect} in source paths."
  end
end

def get(source, destination=nil, config={}, &block)
  source = File.expand_path(find_in_source_paths(source.to_s)) unless source =~ /^http\:\/\//
  render = open(source).read
  destination ||= if block_given?
    block.arity == 1 ? block.call(render) : block.call
  else
    File.basename(source)
  end
  create_file destination, render, config
end

def gsub_file(path, flag, *args, &block)
  return unless behavior == :invoke
  config = args.last.is_a?(Hash) ? args.pop : {}
  path = File.expand_path(path, destination_root)
  say_status :gsub, relative_to_original_destination_root(path), config.fetch(:verbose, true)
  unless options[:pretend]
    content = File.read(path)
    content.gsub!(flag, *args, &block)
    File.open(path, 'wb') { |file| file.write(content) }
  end
end

def in_root
  inside(@destination_stack.first) { yield }
end

def initialize(args=[], options={}, config={})
  self.behavior = case config[:behavior].to_s
    when "force", "skip"
      _cleanup_options_and_set(options, config[:behavior])
      :invoke
    when "revoke"
      :revoke
    else
      :invoke
  end
  super
  self.destination_root = config[:destination_root]
end

def inject_into_file(destination, *args, &block)
  if block_given?
    data, config = block, args.shift
  else
    data, config = args.shift, args.shift
  end
  log_status = args.empty? || args.pop
  action InjectIntoFile.new(self, destination, data, config)
end

def inside(dir='', config={}, &block)
  verbose = config.fetch(:verbose, false)
  say_status :inside, dir, verbose
  shell.padding += 1 if verbose
  @destination_stack.push File.expand_path(dir, destination_root)
  FileUtils.mkdir_p(destination_root) unless File.exist?(destination_root)
  FileUtils.cd(destination_root) { block.arity == 1 ? yield(destination_root) : yield }
  @destination_stack.pop
  shell.padding -= 1 if verbose
end

def prepend_file(path, data=nil, config={}, &block)
  return unless behavior == :invoke
  path = File.expand_path(path, destination_root)
  say_status :prepend, relative_to_original_destination_root(path), config.fetch(:verbose, true)
  unless options[:pretend]
    content = data || block.call
    content << File.read(path)
    File.open(path, 'wb') { |file| file.write(content) }
  end
end

def relative_to_original_destination_root(path, remove_dot=true)
  path = path.gsub(@destination_stack[0], '.')
  remove_dot ? (path[2..-1] || '') : path
end

def remove_file(path, config={})
  return unless behavior == :invoke
  path  = File.expand_path(path, destination_root)
  say_status :remove, relative_to_original_destination_root(path), config.fetch(:verbose, true)
  ::FileUtils.rm_rf(path) if !options[:pretend] && File.exists?(path)
end

def run(command, config={})
  return unless behavior == :invoke
  destination = relative_to_original_destination_root(destination_root, false)
  desc = "#{command} from #{destination.inspect}"
  if config[:with]
    desc = "#{File.basename(config[:with].to_s)} #{desc}"
    command = "#{config[:with]} #{command}"
  end
  say_status :run, desc, config.fetch(:verbose, true)
  system(command) unless options[:pretend]
end

def run_ruby_script(command, config={})
  return unless behavior == :invoke
  run "#{command}", config.merge(:with => Thor::Util.ruby_command)
end

def source_paths
  @source_paths ||= self.class.source_paths_for_search
end

def template(source, destination=nil, config={})
  destination ||= source
  source  = File.expand_path(find_in_source_paths(source.to_s))
  context = instance_eval('binding')
  create_file destination, nil, config do
    ERB.new(::File.read(source), nil, '-').result(context)
  end
end

def thor(task, *args)
  config  = args.last.is_a?(Hash) ? args.pop : {}
  verbose = config.key?(:verbose) ? config.delete(:verbose) : true
  args.unshift task
  args.push Thor::Options.to_switches(config)
  command = args.join(' ').strip
  run command, :with => :thor, :verbose => verbose
end