# Filter für einfachen Wert mit Wertebereich als Collection
# und Darstellung als Select-Box.
# Der Wertebereich wird dabei über eine FacetSuche ermittelt (per Methode 'list_possible_values' des Searchers)
#
class MultiSolr::SolrFilterCollection < MultiSolr::SolrFilterSimple

  # Constructor des Filters
  # Params:
  #   filter_name: Name des Filters als Symbol
  #   options:     optionale Hash mit den folgenden Optionen (sind alle optional):
  #     :render_value      siehe Optionen bei MultiSolr::SolrFilterSimple.initialize
  #     :solr_query        siehe Optionen bei MultiSolr::SolrFilterSimple.initialize
  #     :collection_data:  Proc, welches den Wertebereich(Array) liefert
  #                        Wenn nicht angegeben, dann wird per 'Searcher.list_possible_values'
  #                        mit den Name des Filters der Wertebereich ermittelt.
  #                        Das Proc bekommt den Such-Context(Hash) als Parameter (enthält i.a. Searcher und force-query-params).
  #                        Beispiel: :collection_data => lambda{|context| (2..10).to_a }
  #     :after_collect:    optionales Proc, welches den Wertebereich(Array) nachbearbeitet
  #                        Das Proc bekommt den Wertebereich(Array) als Parameter
  #                        Beispiel: :after_collect => lambda{|data| MasterData::LockType.cached_find_for_short_names(data).map{|l| [l.full_label, l.short_name] } }
  #
  def initialize filter_name, options={}
    @collection_proc = options.delete(:collection_data)
    @after_collect_proc = options.delete(:after_collect)
    if options[:render_value].nil?
      options[:render_value] = Proc.new{|value| compact_values(value).join(', ') }
    end
    super filter_name, options
  end


  # overwrite super for array handling
  def build_solr_query value
    return super(value) unless value.is_a? Array
    values = compact_values(value)
    return nil if values.empty?
    sani_values = sanitize_values values
    if @solr_query_proc
      q = @solr_query_proc.call(sani_values)
    else
      q = sani_values.map{|val| "#{@field_name}:#{val}"}.join(' OR ')
      if sani_values.size > 1
        q = "(#{q})"
      end
    end
    q
  end




  # Ermittelt den Wertebereich entweder über die bei den Options angegebene Proc
  # oder über list_possible_values des Searchers (mit den Namen des Filters als Parameter)
  # Params:
  #   core_handler:   Instanz des konkreten Solr-CoreHandler (MultiSolr::SingleCoreHandler)
  #   context:        Hash mit dem Such-Context.
  #   search_request: optional bestehendes SearchRequest (für DrillDown-Funktionalität)
  # returns:    Array mit dem Wertebereich
  def collection_data core_handler, context, search_request=nil
    if @collection_proc
      data = @collection_proc.call(context)
    else
      data = core_handler.cached_list_possible_values(@field_name, context, search_request)
    end
    if @after_collect_proc
      data = @after_collect_proc.call(data)
      data.compact!
    end
    data
  end


  # Wandelt angegebenen value in ein Array (wenn es noch keins ist)
  # Bereinigt das Array von leeren Elementen
  def compact_values value
    value = [value] unless value.is_a?(Array)
    value.delete_if(&:blank?)
    value
  end

  # Sanitize solr query value in a array of values
  def sanitize_values values
    values.map{|val| sanitize_value(val) }
  end

end