class Guard::Dsl

def _cleanup_backtrace(backtrace)
  dirs = { File.realpath(Dir.pwd) => ".", }
  gem_env = ENV["GEM_HOME"] || ""
  dirs[gem_env] = "$GEM_HOME" unless gem_env.empty?
  gem_paths = (ENV["GEM_PATH"] || "").split(File::PATH_SEPARATOR)
  gem_paths.each_with_index do |path, index|
    dirs[path] = "$GEM_PATH[#{index}]"
  end
  backtrace.dup.map do |raw_line|
    path = nil
    symlinked_path = raw_line.split(":").first
    begin
      path = raw_line.sub(symlinked_path, File.realpath(symlinked_path))
      dirs.detect { |dir, name| path.sub!(File.realpath(dir), name) }
      path
    rescue Errno::ENOENT
      path || symlinked_path
    end
  end
end

def callback(*args, &block)
  @plugin_options ||= nil
  fail "callback must be called within a guard block" unless @plugin_options
  block, events = if args.size > 1
                    # block must be the first argument in that case, the
                    # yielded block is ignored
                    args
                  else
                    [block, args[0]]
                  end
  @plugin_options[:callbacks] << { events: events, listener: block }
end

def clearing(on)
  Guard.state.session.clearing(on == :on)
end

def directories(directories)
  directories.each do |dir|
    fail "Directory #{dir.inspect} does not exist!" unless Dir.exist?(dir)
  end
  Guard.state.session.watchdirs = directories
end

def evaluate(contents, filename, lineno) # :nodoc
  instance_eval(contents, filename.to_s, lineno)
rescue StandardError, ScriptError => e
  prefix = "\n\t(dsl)> "
  cleaned_backtrace = _cleanup_backtrace(e.backtrace)
  backtrace = "#{prefix}#{cleaned_backtrace.join(prefix)}"
  msg = "Invalid Guardfile, original error is: \n\n%s, \nbacktrace: %s"
  raise Error, format(msg, e, backtrace)
end

def group(*args)
  options = args.last.is_a?(Hash) ? args.pop : {}
  groups = args
  groups.each do |group|
    next unless group.to_sym == :all
    fail ArgumentError, "'all' is not an allowed group name!"
  end
  if block_given?
    groups.each do |group|
      # TODO: let groups be added *after* evaluation
      Guard.state.session.groups.add(group, options)
    end
    @current_groups ||= []
    @current_groups.push(groups)
    yield
    @current_groups.pop
  else
    UI.error \
      "No Guard plugins found in the group '#{ groups.join(', ') }',"\
      " please add at least one."
  end
end

def guard(name, options = {})
  @plugin_options = options.merge(watchers: [], callbacks: [])
  yield if block_given?
  @current_groups ||= []
  groups = @current_groups && @current_groups.last || [:default]
  groups.each do |group|
    opts = @plugin_options.merge(group: group)
    # TODO: let plugins be added *after* evaluation
    Guard.state.session.plugins.add(name, opts)
  end
  @plugin_options = nil
end

def ignore(*regexps)
  # TODO: use guardfile results class
  Guard.state.session.guardfile_ignore = regexps
end

def ignore!(*regexps)
  @ignore_regexps ||= []
  @ignore_regexps << regexps
  # TODO: use guardfile results class
  Guard.state.session.guardfile_ignore_bang = @ignore_regexps
end

def interactor(options)
  # TODO: remove dependency on Interactor (let session handle this)
  case options
  when :off
    Interactor.enabled = false
  when Hash
    Interactor.options = options
  end
end

def logger(options)
  if options[:level]
    options[:level] = options[:level].to_sym
    unless [:debug, :info, :warn, :error].include? options[:level]
      UI.warning(format(WARN_INVALID_LOG_LEVEL, options[:level]))
      options.delete :level
    end
  end
  if options[:only] && options[:except]
    UI.warning WARN_INVALID_LOG_OPTIONS
    options.delete :only
    options.delete :except
  end
  # Convert the :only and :except options to a regular expression
  [:only, :except].each do |name|
    next unless options[name]
    list = [].push(options[name]).flatten.map do |plugin|
      Regexp.escape(plugin.to_s)
    end
    options[name] = Regexp.new(list.join("|"), Regexp::IGNORECASE)
  end
  UI.options = UI.options.merge(options)
end

def notification(notifier, opts = {})
  Guard.state.session.guardfile_notification = { notifier.to_sym => opts }
end

def scope(scope = {})
  # TODO: use a Guardfile::Results class
  Guard.state.session.guardfile_scope(scope)
end

def watch(pattern, &action)
  # Allow watches in the global scope (to execute arbitrary commands) by
  # building a generic Guard::Plugin.
  @plugin_options ||= nil
  return guard(:plugin) { watch(pattern, &action) } unless @plugin_options
  @plugin_options[:watchers] << Watcher.new(pattern, action)
end