class SassC::ImportHandler::Importer

def canonicalize(url, context)
  if url.start_with?(Protocol::IMPORT)
    canonical_url = @canonical_urls.delete(url.delete_prefix(Protocol::IMPORT))
    unless @importer_results.key?(canonical_url)
      canonical_url = resolve_file_url(canonical_url, @parent_urls.last, context.from_import)
    end
    @parent_urls.push(canonical_url)
    canonical_url
  elsif url.start_with?(Protocol::FILE)
    path = URL.file_urls_to_relative_path(url, @parent_urls.last)
    parent_path = URL.file_url_to_path(@parent_urls.last)
    imports = @importer.imports(path, parent_path)
    imports = [SassC::Importer::Import.new(path)] if imports.nil?
    imports = [imports] unless imports.is_a?(Array)
    imports.each do |import|
      import.path = File.absolute_path(import.path, File.dirname(parent_path))
    end
    canonical_url = "#{Protocol::IMPORT}#{next_id}"
    @importer_results[canonical_url] = imports_to_native(imports, context.from_import)
    canonical_url
  elsif url.start_with?(Protocol::LOADED)
    canonical_url = Protocol::LOADED
    @parent_urls.pop
    canonical_url
  end
end

def imports_to_native(imports, from_import)
  {
    contents: imports.flat_map do |import|
      id = next_id
      canonical_url = URL.path_to_file_url(import.path)
      @canonical_urls[id] = canonical_url
      if import.source
        @importer_results[canonical_url] = if import.source.is_a?(Hash)
                                             {
                                               contents: import.source[:contents],
                                               syntax: import.source[:syntax],
                                               source_map_url: canonical_url
                                             }
                                           else
                                             {
                                               contents: import.source,
                                               syntax: syntax(import.path),
                                               source_map_url: canonical_url
                                             }
                                           end
      end
      at_rule = from_import ? '@import' : '@forward'
      [
        "#{at_rule} \"#{Protocol::IMPORT}#{id}\";",
        "#{at_rule} \"#{Protocol::LOADED}#{id}\";"
      ]
    end.join("\n"),
    syntax: :scss
  }
end

def initialize(importer)
  @importer = importer
  @canonical_urls = {}
  @id = 0
  @importer_results = {}
  @parent_urls = [URL.path_to_file_url(File.absolute_path(@importer.options[:filename] || 'stdin'))]
end

def load(canonical_url)
  if @importer_results.key?(canonical_url)
    @importer_results.delete(canonical_url)
  elsif canonical_url.start_with?(Protocol::FILE)
    path = URL.file_url_to_path(canonical_url)
    {
      contents: File.read(path),
      syntax: syntax(path),
      source_map_url: canonical_url
    }
  elsif canonical_url.start_with?(Protocol::LOADED)
    {
      contents: '',
      syntax: :scss
    }
  end
end

def load_paths
  @load_paths ||= (@importer.options[:load_paths] || []) + SassC.load_paths
end

def next_id
  id = @id
  @id = id.next
  id.to_s
end

def resolve_file_url(url, parent_url, from_import)
  path = URL.file_urls_to_relative_path(url, parent_url)
  parent_path = URL.file_url_to_path(parent_url)
  [File.dirname(parent_path)].concat(load_paths).each do |load_path|
    resolved = FileImporter.resolve_path(File.absolute_path(path, load_path), from_import)
    return URL.path_to_file_url(resolved) unless resolved.nil?
  end
  nil
end

def syntax(path)
  case File.extname(path)
  when '.sass'
    :indented
  when '.css'
    :css
  else
    :scss
  end
end