module Sass::Plugin

def add_template_location(template_location, css_location = options[:css_location])
  normalize_template_location!
  template_location_array << [template_location, css_location]
end

def check_for_updates
  return unless !Sass::Plugin.checked_for_updates ||
      Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
  update_stylesheets
end

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.dup.merge(additional_options)
  opts[:load_paths] = load_paths(opts)
  opts
end

def forbid_update?(name)
  name.sub(/^.*\//, '')[0] == ?_
end

def force_update_stylesheets(individual_files = [])
  old_options = options
  self.options = options.dup
  options[:never_update] = false
  options[:always_update] = true
  options[:cache] = false
  update_stylesheets(individual_files)
ensure
  self.options = old_options
end

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

def normalize_template_location!
  return if options[:template_location].is_a?(Array)
  options[:template_location] =
    case options[:template_location]
    when nil; [[File.join(options[:css_location], 'sass'), options[:css_location]]]
    when String; [[options[:template_location], options[:css_location]]]
    else; options[:template_location].to_a
    end
end

def options=(value)
  @options.merge!(value)
end

def remove_template_location(template_location, css_location = options[:css_location])
  normalize_template_location!
  template_location_array.delete([template_location, css_location])
end

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

def template_location_array
  old_template_location = options[:template_location]
  normalize_template_location!
  options[:template_location]
ensure
  options[:template_location] = old_template_location
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
    result = Sass::Files.tree_for(filename, engine_options(:css_filename => css, :filename => filename)).render
  rescue Exception => e
    run_compilation_error e, filename, css
    result = Sass::SyntaxError.exception_to_css(e, options)
  else
    run_updating_stylesheet filename, css
  end
  # Finally, write the file
  flag = 'w'
  flag = 'wb' if RbConfig::CONFIG['host_os'] =~ /mswin|windows/i && options[:unix_newlines]
  File.open(css, flag) {|file| file.print(result)}
end

def update_stylesheets(individual_files = [])
  return if options[:never_update]
  run_updating_stylesheets individual_files
  individual_files.each {|t, c| update_stylesheet(t, c)}
  @checked_for_updates = true
  staleness_checker = StalenessChecker.new
  template_location_array.each do |template_location, css_location|
    Dir.glob(File.join(template_location, "**", "*.s[ca]ss")).each do |file|
      # Get the relative path to the file
      name = file.sub(template_location.sub(/\/*$/, '/'), "")
      css = css_filename(name, css_location)
      next if forbid_update?(name)
      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
end

def watch(individual_files = [])
  update_stylesheets(individual_files)
  begin
    require 'fssm'
  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 fssm" to get it.'
      end
    raise e
  end
  unless individual_files.empty? && FSSM::Backends::Default.name == "FSSM::Backends::FSEvents"
    # As of FSSM 0.1.4, it doesn't support FSevents on individual files,
    # but it also isn't smart enough to switch to polling itself.
    require 'fssm/backends/polling'
    Haml::Util.silence_warnings do
      FSSM::Backends.const_set(:Default, FSSM::Backends::Polling)
    end
  end
  # TODO: Keep better track of what depends on what
  # so we don't have to run a global update every time anything changes.
  FSSM.monitor do |mon|
    template_location_array.each do |template_location, css_location|
      mon.path template_location do |path|
        path.glob '**/*.s[ac]ss'
        path.update do |base, relative|
          run_template_modified File.join(base, relative)
          update_stylesheets(individual_files)
        end
        path.create do |base, relative|
          run_template_created File.join(base, relative)
          update_stylesheets(individual_files)
        end
        path.delete do |base, relative|
          run_template_deleted File.join(base, relative)
          css = File.join(css_location, relative.gsub(/\.s[ac]ss$/, '.css'))
          try_delete_css css
          update_stylesheets(individual_files)
        end
      end
    end
    individual_files.each do |template, css|
      mon.file template do |path|
        path.update do
          run_template_modified template
          update_stylesheets(individual_files)
        end
        path.create do
          run_template_created template
          update_stylesheets(individual_files)
        end
        path.delete do
          run_template_deleted template
          try_delete_css css
          update_stylesheets(individual_files)
        end
      end
    end
  end
end