class SassC::ImportHandler::ImportCache

def canonicalize(url, context)
  return unless context.containing_url&.start_with?('file:')
  containing_url = context.containing_url
  path = Uri.decode_uri_component(url)
  parent_path = Uri.file_url_to_path(containing_url)
  parent_dir = File.dirname(parent_path)
  if containing_url.include?('?')
    canonical_url = Uri.path_to_file_url(File.absolute_path(path, parent_dir))
    unless @importer_results.key?(canonical_url)
      @file_url = resolve_file_url(path, parent_dir, context.from_import)
      return
    end
  else
    imports = [*@importer.imports(path, parent_path)]
    canonical_url = imports_to_native(imports, parent_dir, context.from_import, url, containing_url)
    unless @importer_results.key?(canonical_url)
      @file_url = canonical_url
      return
    end
  end
  @importer_result = @importer_results.delete(canonical_url)
  canonical_url
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 = Uri.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
  Uri.encode_uri_path_component(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 = "#{containing_url}?url=#{Uri.encode_uri_query_component(url)}&from_import=#{from_import}"
  @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 = {}
  @importer_result = nil
  @file_url = nil
end

def load(_canonical_url)
  importer_result = @importer_result
  @importer_result = nil
  importer_result
end

def resolve_file_url(path, parent_dir, from_import)
  resolved = FileSystemImporter.resolve_path(File.absolute_path(path, parent_dir), from_import)
  Uri.path_to_file_url(resolved) unless resolved.nil?
end

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