module Thor::Actions

def self.included(base) #:nodoc:
  super(base)
  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[: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
  contents = if is_uri
    require "open-uri"
    # for ruby 2.1-2.4
    URI.send(:open, path, "Accept" => "application/x-thor-template", &:read)
  else
    File.open(path, &:read)
  end
  instance_eval(contents, path)
  shell.padding -= 1 if verbose
end

def capture(*args)
  with_output_buffer { yield(*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)
  unless options[:pretend]
    require "fileutils"
    FileUtils.chmod_R(mode, path)
  end
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))
  resulting_destination = create_file destination, nil, config do
    content = File.binread(source)
    content = yield(content) if block
    content
  end
  if config[:mode] == :preserve
    mode = File.stat(source).mode
    chmod(resulting_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)
  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)
  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. ".dup
  unless self.class.source_root
    message << "Please invoke #{self.class.name}.source_root(PATH) with the PATH containing your templates. "
  end
  message << if source_paths.empty?
               "Currently you have no source paths."
             else
               "Your current source paths are: \n#{source_paths.join("\n")}"
             end
  raise Error, message
end

def get(source, *args, &block)
  config = args.last.is_a?(Hash) ? args.pop : {}
  destination = args.first
  render = if source =~ %r{^https?\://}
    require "open-uri"
    URI.send(:open, source) { |input| input.binmode.read }
  else
    source = File.expand_path(find_in_source_paths(source.to_s))
    File.open(source) { |input| input.binmode.read }
  end
  destination ||= if block_given?
    block.arity == 1 ? yield(render) : yield
  else
    File.basename(source)
  end
  create_file destination, render, config
end

def gsub_file(path, flag, *args, &block)
  config = args.last.is_a?(Hash) ? args.pop : {}
  return unless behavior == :invoke || config.fetch(:force, false)
  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[:after] = /class #{klass}\n|class #{klass} .*\n/
  insert_into_file(path, *(args << config), &block)
end

def inject_into_module(path, module_name, *args, &block)
  config = args.last.is_a?(Hash) ? args.pop : {}
  config[:after] = /module #{module_name}\n|module #{module_name} .*\n/
  insert_into_file(path, *(args << config), &block)
end

def insert_into_file(destination, *args, &block)
  data = block_given? ? block : args.shift
  config = args.shift || {}
  config[:after] = /\z/ unless config.key?(:before) || config.key?(:after)
  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 doesn't exist and we're not pretending
  if !File.exist?(destination_root) && !pretend
    require "fileutils"
    FileUtils.mkdir_p(destination_root)
  end
  result = nil
  if pretend
    # In pretend mode, just yield down to the block
    result = block.arity == 1 ? yield(destination_root) : yield
  else
    require "fileutils"
    FileUtils.cd(destination_root) { result = block.arity == 1 ? yield(destination_root) : yield }
  end
  @destination_stack.pop
  shell.padding -= 1 if verbose
  result
end

def link_file(source, *args)
  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[:after] = /\A/
  insert_into_file(path, *(args << config), &block)
end

def relative_to_original_destination_root(path, remove_dot = true)
  root = @destination_stack[0]
  if path.start_with?(root) && [File::SEPARATOR, File::ALT_SEPARATOR, nil, ''].include?(path[root.size..root.size])
    path = path.dup
    path[0...root.size] = '.'
    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)
  if !options[:pretend] && (File.exist?(path) || File.symlink?(path))
    require "fileutils"
    ::FileUtils.rm_rf(path)
  end
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)
  return if options[:pretend]
  env_splat = [config[:env]] if config[:env]
  if config[:capture]
    require "open3"
    result, status = Open3.capture2e(*env_splat, command.to_s)
    success = status.success?
  else
    result = system(*env_splat, command.to_s)
    success = result
  end
  abort if !success && config.fetch(:abort_on_failure, self.class.exit_on_failure?)
  result
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 = config.delete(:context) || instance_eval("binding")
  create_file destination, nil, config do
    match = ERB.version.match(/(\d+\.\d+\.\d+)/)
    capturable_erb = if match && match[1] >= "2.2.0" # Ruby 2.6+
      CapturableERB.new(::File.binread(source), :trim_mode => "-", :eoutvar => "@output_buffer")
    else
      CapturableERB.new(::File.binread(source), nil, "-", "@output_buffer")
    end
    content = capturable_erb.tap do |erb|
      erb.filename = source
    end.result(context)
    content = yield(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 = "".dup) #:nodoc:
  raise ArgumentError, "Buffer can not be a frozen object" if buf.frozen?
  old_buffer = output_buffer
  self.output_buffer = buf
  yield
  output_buffer
ensure
  self.output_buffer = old_buffer
end