module Sprockets::Transformers

def compose_transformer_list(transformers, preprocessors, postprocessors)
  processors = []
  transformers.each do |processor|
    processors.concat postprocessors[processor.from]
    processors << processor.proc
    processors.concat preprocessors[processor.to]
  end
  if processors.size > 1
    compose_processors(*processors.reverse)
  elsif processors.size == 1
    processors.first
  end
end

def compose_transformers(transformers, types, preprocessors, postprocessors)
  if types.length < 2
    raise ArgumentError, "too few transform types: #{types.inspect}"
  end
  processors = types.each_cons(2).map { |src, dst|
    unless processor = transformers[src][dst]
      raise ArgumentError, "missing transformer for type: #{src} to #{dst}"
    end
    processor
  }
  compose_transformer_list processors, preprocessors, postprocessors
end

def compute_transformers!(registered_transformers)
  preprocessors         = self.config[:preprocessors]
  postprocessors        = self.config[:postprocessors]
  transformers          = Hash.new { {} }
  inverted_transformers = Hash.new { Set.new }
  incoming_edges        = registered_transformers.group_by(&:from)
  registered_transformers.each do |t|
    traversals = dfs_paths([t]) { |k| incoming_edges.fetch(k.to, []) }
    traversals.each do |nodes|
      src, dst = nodes.first.from, nodes.last.to
      processor = compose_transformer_list nodes, preprocessors, postprocessors
      transformers[src] = {} unless transformers.key?(src)
      transformers[src][dst] = processor
      inverted_transformers[dst] = Set.new unless inverted_transformers.key?(dst)
      inverted_transformers[dst] << src
    end
  end
  self.config = hash_reassoc(config, :transformers) { transformers }
  self.config = hash_reassoc(config, :inverted_transformers) { inverted_transformers }
end

def expand_transform_accepts(parsed_accepts)
  accepts = []
  parsed_accepts.each do |(type, q)|
    accepts.push([type, q])
    config[:inverted_transformers][type].each do |subtype|
      accepts.push([subtype, q * 0.8])
    end
  end
  accepts
end

def register_transformer(from, to, proc)
  self.config = hash_reassoc(config, :registered_transformers) do |transformers|
    transformers << Transformer.new(from, to, proc)
  end
  compute_transformers!(self.config[:registered_transformers])
end

def register_transformer_suffix(types, type_format, extname, processor)
  Array(types).each do |type|
    extensions, charset = mime_types[type].values_at(:extensions, :charset)
    parts = type.split('/')
    suffix_type = type_format.sub('\1', parts[0]).sub('\2', parts[1])
    extensions = extensions.map { |ext| "#{ext}#{extname}" }
    register_mime_type(suffix_type, extensions: extensions, charset: charset)
    register_transformer(suffix_type, type, processor)
  end
end

def resolve_transform_type(type, accept)
  find_best_mime_type_match(accept || '*/*', [type].compact + config[:transformers][type].keys)
end

def transformers
  config[:transformers]
end