module Sprockets::Processing

def build_processors_uri(type, file_type, engine_extnames, skip_bundle)
  engines = engine_extnames.join(',') if engine_extnames.any?
  query = encode_uri_query_params(
    type: type,
    file_type: file_type,
    engines: engines,
    skip_bundle: skip_bundle
  )
  "processors:#{query}"
end

def bundle_processors
  config[:bundle_processors]
end

def bundle_reducers
  config[:bundle_reducers]
end

def load_bundle_reducers(mime_type)
  self.bundle_reducers['*/*'].merge(self.bundle_reducers[mime_type])
end

def postprocessors
  config[:postprocessors]
end

def preprocessors
  config[:preprocessors]
end

def process_bundle_reducers(assets, reducers)
  initial = {}
  reducers.each do |k, (v, _)|
    initial[k] = v if v
  end
  assets.reduce(initial) do |h, asset|
    reducers.each do |k, (_, block)|
      value = k == :data ? asset.source : asset.metadata[k]
      h[k]  = h.key?(k) ? block.call(h[k], value) : value
    end
    h
  end
end

def processors_for(type, file_type, engine_extnames, skip_bundle)
  processors = []
  bundled_processors = skip_bundle ? [] : config[:bundle_processors][type]
  if bundled_processors.any?
    processors.concat bundled_processors
  else
    processors.concat config[:postprocessors][type]
    if type != file_type && processor = transformers[file_type][type]
      processors << processor
    end
    processors.concat engine_extnames.map { |ext| engines[ext] }
    processors.concat config[:preprocessors][file_type]
  end
  if processors.any? || mime_type_charset_detecter(type)
    processors << FileReader
  end
  processors
end

def register_bundle_metadata_reducer(mime_type, key, *args, &block)
  case args.size
  when 0
    reducer = block
  when 1
    if block_given?
      initial = args[0]
      reducer = block
    else
      initial = nil
      reducer = args[0].to_proc
    end
  when 2
    initial = args[0]
    reducer = args[1].to_proc
  else
    raise ArgumentError, "wrong number of arguments (#{args.size} for 0..2)"
  end
  self.config = hash_reassoc(config, :bundle_reducers, mime_type) do |reducers|
    reducers.merge(key => [initial, reducer])
  end
end

def register_bundle_processor(*args, &block)
  register_config_processor(:bundle_processors, *args, &block)
end

def register_config_processor(type, mime_type, klass, proc = nil, &block)
  proc ||= block
  processor = wrap_processor(klass, proc)
  self.config = hash_reassoc(config, type, mime_type) do |processors|
    processors.unshift(processor)
    processors
  end
  compute_transformers!
end

def register_postprocessor(*args, &block)
  register_config_processor(:postprocessors, *args, &block)
end

def register_preprocessor(*args, &block)
  register_config_processor(:preprocessors, *args, &block)
end

def resolve_processors_cache_key_uri(uri)
  params = parse_uri_query_params(uri[11..-1])
  params[:engine_extnames] = params[:engines] ? params[:engines].split(',') : []
  processors = processors_for(params[:type], params[:file_type], params[:engine_extnames], params[:skip_bundle])
  processors_cache_keys(processors)
end

def unregister_bundle_processor(*args)
  unregister_config_processor(:bundle_processors, *args)
end

def unregister_config_processor(type, mime_type, klass)
  if klass.is_a?(String) || klass.is_a?(Symbol)
    klass = config[type][mime_type].detect do |cls|
      cls.respond_to?(:name) && cls.name == "Sprockets::LegacyProcProcessor (#{klass})"
    end
  end
  self.config = hash_reassoc(config, type, mime_type) do |processors|
    processors.delete(klass)
    processors
  end
  compute_transformers!
end

def unregister_postprocessor(*args)
  unregister_config_processor(:postprocessors, *args)
end

def unregister_preprocessor(*args)
  unregister_config_processor(:preprocessors, *args)
end

def wrap_processor(klass, proc)
  if !proc
    if klass.class == Sprockets::AutoloadProcessor || klass.respond_to?(:call)
      klass
    else
      LegacyTiltProcessor.new(klass)
    end
  elsif proc.respond_to?(:arity) && proc.arity == 2
    LegacyProcProcessor.new(klass.to_s, proc)
  else
    proc
  end
end