class Sass::Plugin::Compiler

def css_filename(name, path)
  "#{path}/#{name}".gsub(/\.s[ac]ss$/, '.css')
end

def css_locations
  template_location_array.to_a.map {|l| l.last}
end

def engine_options(additional_options = {})
  opts = options.merge(additional_options)
  opts[:load_paths] = load_paths(opts)
  opts
end

def initialize(options = {})
  self.options.merge!(options)
end

def load_listen!
  if defined?(gem)
    begin
      gem 'listen', '~> 0.7'
      require 'listen'
    rescue Gem::LoadError
      dir = Sass::Util.scope("vendor/listen/lib")
      $LOAD_PATH.unshift dir
      begin
        require 'listen'
      rescue LoadError => e
        e.message << "\n" <<
          if File.exists?(scope(".git"))
            'Run "git submodule update --init" to get the recommended version.'
          else
            'Run "gem install listen" to get it.'
          end
        raise e
      end
    end
  else
    begin
      require 'listen'
    rescue LoadError => e
      dir = Sass::Util.scope("vendor/listen/lib")
      if $LOAD_PATH.include?(dir)
        raise e unless File.exists?(scope(".git"))
        e.message << "\n" <<
          'Run "git submodule update --init" to get the recommended version.'
      else
        $LOAD_PATH.unshift dir
        retry
      end
    end
  end
end

def load_paths(opts = options)
  (opts[:load_paths] || []) + template_locations
end

def on_updating_stylesheet_with_deprecation_warning(&block)
  Sass::Util.sass_warn("Sass::Compiler#on_updating_stylesheet callback is deprecated and will be removed in a future release. Use Sass::Compiler#on_updated_stylesheet instead, which is run after stylesheet compilation.")
  on_updating_stylesheet_without_deprecation_warning(&block)
end

def stylesheet_needs_update?(css_file, template_file)
  StalenessChecker.stylesheet_needs_update?(css_file, template_file)
end

def template_locations
  template_location_array.to_a.map {|l| l.first}
end

def try_delete_css(css)
  return unless File.exists?(css)
  run_deleting_css css
  File.delete css
end

def update_stylesheet(filename, css)
  dir = File.dirname(css)
  unless File.exists?(dir)
    run_creating_directory dir
    FileUtils.mkdir_p dir
  end
  begin
    File.read(filename) unless File.readable?(filename) # triggers an error for handling
    engine_opts = engine_options(:css_filename => css, :filename => filename)
    result = Sass::Engine.for_file(filename, engine_opts).render
  rescue Exception => e
    compilation_error_occured = true
    run_compilation_error e, filename, css
    result = Sass::SyntaxError.exception_to_css(e, options)
  else
    run_updating_stylesheet filename, css
  end
  write_file(css, result)
  run_updated_stylesheet(filename, css) unless compilation_error_occured
end

def update_stylesheets(individual_files = [])
  individual_files = individual_files.dup
  Sass::Plugin.checked_for_updates = true
  staleness_checker = StalenessChecker.new(engine_options)
  template_location_array.each do |template_location, css_location|
    Sass::Util.glob(File.join(template_location, "**", "[^_]*.s[ca]ss")).sort.each do |file|
      # Get the relative path to the file
      name = file.sub(template_location.to_s.sub(/\/*$/, '/'), "")
      css = css_filename(name, css_location)
      individual_files << [file, css]
    end
  end
  run_updating_stylesheets individual_files
  individual_files.each do |file, css|
    if options[:always_update] || staleness_checker.stylesheet_needs_update?(css, file)
      update_stylesheet(file, css)
    else
      run_not_updating_stylesheet(file, css)
    end
  end
end

def watch(individual_files = [])
  update_stylesheets(individual_files)
  load_listen!
  template_paths = template_locations # cache the locations
  individual_files_hash = individual_files.inject({}) do |h, files|
    parent = File.dirname(files.first)
    (h[parent] ||= []) << files unless template_paths.include?(parent)
    h
  end
  directories = template_paths + individual_files_hash.keys +
    [{:relative_paths => true}]
  # TODO: Keep better track of what depends on what
  # so we don't have to run a global update every time anything changes.
  listener = Listen::MultiListener.new(*directories) do |modified, added, removed|
    modified.each do |f|
      parent = File.dirname(f)
      if files = individual_files_hash[parent]
        next unless files.first == f
      else
        next unless f =~ /\.s[ac]ss$/
      end
      run_template_modified(f)
    end
    added.each do |f|
      parent = File.dirname(f)
      if files = individual_files_hash[parent]
        next unless files.first == f
      else
        next unless f =~ /\.s[ac]ss$/
      end
      run_template_created(f)
    end
    removed.each do |f|
      parent = File.dirname(f)
      if files = individual_files_hash[parent]
        next unless files.first == f
        try_delete_css files[1]
      else
        next unless f =~ /\.s[ac]ss$/
        try_delete_css f.gsub(/\.s[ac]ss$/, '.css')
      end
      run_template_deleted(f)
    end
    update_stylesheets(individual_files)
  end
  # The native windows listener is much slower than the polling
  # option, according to https://github.com/nex3/sass/commit/a3031856b22bc834a5417dedecb038b7be9b9e3e#commitcomment-1295118
  listener.force_polling(true) if @options[:poll] || Sass::Util.windows?
  begin
    listener.start
  rescue Exception => e
    raise e unless e.is_a?(Interrupt)
  end
end

def write_file(css, content)
  flag = 'w'
  flag = 'wb' if Sass::Util.windows? && options[:unix_newlines]
  File.open(css, flag) do |file|
    file.set_encoding(content.encoding) unless Sass::Util.ruby1_8?
    file.print(content)
  end
end