module Thor::Actions

def self.included(base) #:nodoc:
  base.extend ClassMethods
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 => destination_root)
end

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

def append_to_file(path, *args, &block)
  config = args.last.is_a?(Hash) ? args.pop : {}
  config.merge!(:before => /\z/)
  insert_into_file(path, *(args << config), &block)
end

def apply(path, config = {})
  verbose = config.fetch(:verbose, true)
  is_uri  = path =~ %r{^https?\://}
  path    = find_in_source_paths(path) unless is_uri
  say_status :apply, path, verbose
  shell.padding += 1 if verbose
  if is_uri
    contents = open(path, "Accept" => "application/x-thor-template") { |io| io.read }
  else
    contents = open(path) { |io| io.read }
  end
  instance_eval(contents, path)
  shell.padding -= 1 if verbose
end

def capture(*args, &block)
  with_output_buffer { block.call(*args) }
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 comment_lines(path, flag, *args)
  flag = flag.respond_to?(:source) ? flag.source : flag
  gsub_file(path, /^(\s*)([^#|\n]*#{flag})/, '\1# \2', *args)
end

def concat(string)
  @output_buffer.concat(string)
end

def copy_file(source, *args, &block)
  config = args.last.is_a?(Hash) ? args.pop : {}
  destination = args.first || source
  source = File.expand_path(find_in_source_paths(source.to_s))
  create_file destination, nil, config do
    content = File.binread(source)
    content = block.call(content) if block
    content
  end
  if config[:mode] == :preserve
    mode = File.stat(source).mode
    chmod(destination, mode, config)
  end
end

def create_file(destination, *args, &block)
  config = args.last.is_a?(Hash) ? args.pop : {}
  data = args.first
  action CreateFile.new(self, destination, block || data.to_s, config)
end

def create_link(destination, *args, &block)
  config = args.last.is_a?(Hash) ? args.pop : {}
  source = args.first
  action CreateLink.new(self, destination, source, 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, *args, &block)
  config = args.last.is_a?(Hash) ? args.pop : {}
  destination = args.first || source
  action Directory.new(self, source, destination || source, config, &block)
end

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

def find_in_source_paths(file) # rubocop:disable MethodLength
  possible_files = [file, file + TEMPLATE_EXTNAME]
  relative_root = relative_to_original_destination_root(destination_root, false)
  source_paths.each do |source|
    possible_files.each do |f|
      source_file = File.expand_path(f, File.join(source, relative_root))
      return source_file if File.exist?(source_file)
    end
  end
  message = "Could not find #{file.inspect} in any of your source paths. "
  unless self.class.source_root
    message << "Please invoke #{self.class.name}.source_root(PATH) with the PATH containing your templates. "
  end
  if source_paths.empty?
    message << "Currently you have no source paths."
  else
    message << "Your current source paths are: \n#{source_paths.join("\n")}"
  end
  fail Error, message
end

def get(source, *args, &block)
  config = args.last.is_a?(Hash) ? args.pop : {}
  destination = args.first
  source = File.expand_path(find_in_source_paths(source.to_s)) unless source =~ %r{^https?\://}
  render = open(source) { |input| input.binmode.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.binread(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_class(path, klass, *args, &block)
  config = args.last.is_a?(Hash) ? args.pop : {}
  config.merge!(:after => /class #{klass}\n|class #{klass} .*\n/)
  insert_into_file(path, *(args << config), &block)
end

def insert_into_file(destination, *args, &block)
  if block_given?
    data, config = block, args.shift
  else
    data, config = args.shift, args.shift
  end
  action InjectIntoFile.new(self, destination, data, config)
end

def inside(dir = "", config = {}, &block)
  verbose = config.fetch(:verbose, false)
  pretend = options[:pretend]
  say_status :inside, dir, verbose
  shell.padding += 1 if verbose
  @destination_stack.push File.expand_path(dir, destination_root)
  # If the directory doesnt exist and we're not pretending
  if !File.exist?(destination_root) && !pretend
    FileUtils.mkdir_p(destination_root)
  end
  if pretend
    # In pretend mode, just yield down to the block
    block.arity == 1 ? yield(destination_root) : yield
  else
    FileUtils.cd(destination_root) { block.arity == 1 ? yield(destination_root) : yield }
  end
  @destination_stack.pop
  shell.padding -= 1 if verbose
end

def link_file(source, *args, &block)
  config = args.last.is_a?(Hash) ? args.pop : {}
  destination = args.first || source
  source = File.expand_path(find_in_source_paths(source.to_s))
  create_link destination, source, config
end

def prepend_to_file(path, *args, &block)
  config = args.last.is_a?(Hash) ? args.pop : {}
  config.merge!(:after => /\A/)
  insert_into_file(path, *(args << config), &block)
end

def relative_to_original_destination_root(path, remove_dot = true)
  path = path.dup
  if path.gsub!(@destination_stack[0], ".")
    remove_dot ? (path[2..-1] || "") : path
  else
    path
  end
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.exist?(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)
  unless options[:pretend]
    config[:capture] ? `#{command}` : system("#{command}")
  end
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, *args, &block)
  config = args.last.is_a?(Hash) ? args.pop : {}
  destination = args.first || source.sub(/#{TEMPLATE_EXTNAME}$/, "")
  source  = File.expand_path(find_in_source_paths(source.to_s))
  context = instance_eval("binding")
  create_file destination, nil, config do
    content = ERB.new(::File.binread(source), nil, "-", "@output_buffer").result(context)
    content = block.call(content) if block
    content
  end
end

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

def uncomment_lines(path, flag, *args)
  flag = flag.respond_to?(:source) ? flag.source : flag
  gsub_file(path, /^(\s*)#[[:blank:]]*(.*#{flag})/, '\1\2', *args)
end

def with_output_buffer(buf = "") #:nodoc:
  self.output_buffer, old_buffer = buf, output_buffer
  yield
  output_buffer
ensure
  self.output_buffer = old_buffer
end