class SassC::ImportHandler::ImportCache

def canonicalize(url, context)
  return if context.containing_url.nil?
  containing_url = if context.containing_url.start_with?(Protocol::GLOB)
                     URL.unescape(URL.parse(context.containing_url).fragment)
                   else
                     context.containing_url
                   end
  return unless containing_url.start_with?(Protocol::FILE)
  path = URL.unescape(url)
  parent_path = URL.file_url_to_path(containing_url)
  parent_dir = File.dirname(parent_path)
  if containing_url == context.containing_url
    imports = @importer.imports(path, parent_path)
    imports = [SassC::Importer::Import.new(path)] if imports.nil?
    imports = [imports] unless imports.is_a?(Array)
    canonical_url = imports_to_native(imports, parent_dir, context.from_import, url, context.containing_url)
    if @importer_results.key?(canonical_url)
      canonical_url
    else
      @file_url = canonical_url
      nil
    end
  else
    canonical_url = URL.path_to_file_url(File.absolute_path(path, parent_dir))
    if @importer_results.key?(canonical_url)
      canonical_url
    else
      @file_url = resolve_file_url(path, parent_dir, context.from_import)
      nil
    end
  end
end

def find_file_url(_url, context)
  return if context.containing_url.nil? || @file_url.nil?
  canonical_url = @file_url
  @file_url = nil
  canonical_url
end

def import_to_native(import, parent_dir, from_import, canonicalize)
  if import.source
    canonical_url = URL.path_to_file_url(File.absolute_path(import.path, parent_dir))
    @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
    return canonical_url if canonicalize
  elsif canonicalize
    return resolve_file_url(import.path, parent_dir, from_import)
  end
  URL.escape(import.path)
end

def imports_to_native(imports, parent_dir, from_import, url, containing_url)
  return import_to_native(imports.first, parent_dir, from_import, true) if imports.one?
  canonical_url = "#{Protocol::GLOB}?#{URL.escape(url)}##{URL.escape(containing_url)}"
  @importer_results[canonical_url] = {
    contents: imports.flat_map do |import|
      at_rule = from_import ? '@import' : '@forward'
      url = import_to_native(import, parent_dir, from_import, false)
      "#{at_rule} #{Script::Value::String.quote(url)};"
    end.join("\n"),
    syntax: :scss
  }
  canonical_url
end

def initialize(importer)
  @importer = importer
  @importer_results = {}
  @file_url = nil
  @load_paths = (@importer.options[:load_paths] || []) + SassC.load_paths
end

def load(canonical_url)
  @importer_results.delete(canonical_url)
end

def resolve_file_url(path, parent_dir, from_import)
  [parent_dir].concat(@load_paths).each do |load_path|
    resolved = FileSystemImporter.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