class LSolr

# File lib/lsolr.rb, line 114
def build(params)
  case params
  when Hash then params.map { |f, v| build_query(f, v) }.reduce { |a, e| a.and(e) }
  when String then build_raw_query(params)
  else raise TypeError, "Could not build solr query. Please specify a Hash or String value. `#{params}` given."
  end
rescue TypeError => e
  raise ArgumentError, "#{e.message} It is not a supported type."
end

# File lib/lsolr.rb, line 165
def initialize(field_name = nil)
  if field_name.nil?
    @field = ''
  else
    field(field_name)
  end

  @expr_not = @value = @range_first = @range_last = @boost = @constant_score = @raw = ''
  @left_parentheses = []
  @right_parentheses = []
end

# File lib/lsolr.rb, line 138
def build_array_query(field, values)
  values.empty? ? new(field) : new(field).match_in(values)
end

# File lib/lsolr.rb, line 150
def build_enumerator_query(field, values)
  last = nil
  values.each { |v| last = v }
  new(field).greater_than_or_equal_to(values.first).less_than_or_equal_to(last)
end

# File lib/lsolr.rb, line 126
def build_query(field, value) # rubocop:disable Metrics/CyclomaticComplexity
  case value
  when String, Symbol, Integer, Float, true, false then new(field).match(value)
  when Date, Time then new(field).date_time_match(value)
  when LSolr then value
  when Array then build_array_query(field, value)
  when Range then build_range_query(field, value)
  when Enumerator then build_enumerator_query(field, value)
  else raise TypeError, "Could not build solr query. field: `#{field}`, value: `#{value}` given."
  end
end

# File lib/lsolr.rb, line 142
def build_range_query(field, value)
  if value.exclude_end?
    new(field).greater_than_or_equal_to(value.first).less_than(value.last)
  else
    new(field).greater_than_or_equal_to(value.first).less_than_or_equal_to(value.last)
  end
end

# File lib/lsolr.rb, line 156
def build_raw_query(query)
  query.empty? ? new : new.raw(query)
end

# File lib/lsolr.rb, line 448
def and(another)
  link(another, AND)
end

# File lib/lsolr.rb, line 202
def blank?
  managed_query_absence = @field.empty? || (@value.empty? && (@range_first.empty? || @range_last.empty?))
  managed_query_absence && @raw.empty?
end

# File lib/lsolr.rb, line 274
def boost(factor)
  raise ArgumentError, "The boost factor must be a positive number. `#{factor}` given." unless valid_boost_factor?(factor)

  @boost = "#{BOOST}#{factor}"
  self
end

# File lib/lsolr.rb, line 290
def constant_score(score)
  raise ArgumentError, "The constant score must be a number. `#{score}` given." unless valid_score?(score)

  @constant_score = "#{CONSTANT_SCORE}#{score}"
  self
end

# File lib/lsolr.rb, line 342
def date_time_match(value)
  value = stringify(value, symbols: RESERVED_SYMBOLS - %w[- : . / +])
  @value = %("#{value}")
  self
end

# File lib/lsolr.rb, line 221
def field(name)
  raise ArgumentError, "The field name must be a not empty string value. `#{name}` given." unless present_string?(name)

  @field = name.to_s
  self
end

# File lib/lsolr.rb, line 386
def fuzzy_match(value, distance: 2.0)
  raise ArgumentError, "Out of #{RANGE_FUZZY_MATCH_DISTANCE}. `#{distance}` given." unless valid_fuzzy_match_distance?(distance)

  @value = "#{clean(value).split.join}#{PROXIMITY}#{distance}"
  self
end

# File lib/lsolr.rb, line 400
def greater_than(value)
  @range_first = "#{GREATER_THAN}#{stringify(value)}"
  self
end

# File lib/lsolr.rb, line 424
def greater_than_or_equal_to(value)
  @range_first = "#{GREATER_THAN_OR_EQUAL_TO}#{stringify(value)}"
  self
end

# File lib/lsolr.rb, line 466
def head
  if present_query?(prev)
    prev.head
  else
    self
  end
end

# File lib/lsolr.rb, line 193
def inspect
  format(FORMAT_INSPECT, class: self.class.name,
                         object: object_id << 1,
                         query: present? ? to_s : '')
end

# File lib/lsolr.rb, line 412
def less_than(value)
  @range_last = "#{stringify(value)}#{LESS_THAN}"
  self
end

# File lib/lsolr.rb, line 436
def less_than_or_equal_to(value)
  @range_last = "#{stringify(value)}#{LESS_THAN_OR_EQUAL_TO}"
  self
end

# File lib/lsolr.rb, line 304
def match(value)
  raise ArgumentError, "`#{value}` given. It must be a not empty value." unless present_string?(value.to_s)
  return match_in(value) if value.is_a?(Array)
  return date_time_match(value) if value.is_a?(Date) || value.is_a?(Time)

  values = clean(value).split

  if values.size > 1
    phrase_match(values)
  else
    @value = values.join
    self
  end
end

# File lib/lsolr.rb, line 326
def match_in(values)
  raise ArgumentError, "`#{values}` given. It must be a not empty array." unless present_array?(values)
  return match(values.first) if values.size == 1

  values = values.map { |v| clean(v) }
  @value = "(#{values.join(DELIMITER_SPACE)})"
  self
end

# File lib/lsolr.rb, line 259
def not
  this = dup
  this.head.expr_not = "#{NOT} "
  this
end

# File lib/lsolr.rb, line 459
def or(another)
  link(another, OR)
end

# File lib/lsolr.rb, line 369
def phrase_match(values, distance: 0)
  value = values.map { |v| clean(v).split }.flatten.join(DELIMITER_SPACE)
  proximity_match = distance.to_s.to_i > 0 ? "#{PROXIMITY}#{distance}" : ''
  @value = %("#{value}"#{proximity_match})
  self
end

# File lib/lsolr.rb, line 355
def prefix_match(value)
  @value = clean(value, symbols: RESERVED_SYMBOLS - %w[* ?]).split.join(WILD_CARD)
  self
end

# File lib/lsolr.rb, line 210
def present?
  !blank?
end

# File lib/lsolr.rb, line 235
def raw(query)
  raise ArgumentError, "The raw query must be a not empty string value. `#{query}` given." unless present_string?(query)

  @raw = query.to_s
  self
end

# File lib/lsolr.rb, line 182
def to_s
  raise IncompleteQueryError, 'Please specify a term of search.' if blank?

  decorate_linked_expressions_if_needed(build_expression)
end

# File lib/lsolr.rb, line 247
def wrap
  this = dup
  this.head.left_parentheses << PARENTHESIS_LEFT
  this.right_parentheses << PARENTHESIS_RIGHT
  this
end

# File lib/lsolr.rb, line 558
def build_expression
  if raw?
    @raw
  elsif range_search?
    "#{@field}:#{@range_first} #{TO} #{@range_last}"
  else
    "#{@field}:#{@value}"
  end
end

# File lib/lsolr.rb, line 551
def build_instance_if_needed(another)
  case another
  when self.class then another
  when Hash, String then self.class.build(another)
  end
end

# File lib/lsolr.rb, line 514
def clean(value, symbols: RESERVED_SYMBOLS)
  value.to_s
       .tr(symbols.join, REPLACEMENT_CHAR)
       .gsub(RESERVED_WORDS) { |match| "\\#{match}" }
end

# File lib/lsolr.rb, line 568
def decorate_linked_expressions_if_needed(expr)
  expr = "#{expr_not}#{left_parentheses.join}#{expr}#{right_parentheses.join}"
  expr = "#{prev} #{operator} #{expr}" if present_query?(prev)
  scoring = present_string?(@constant_score) ? @constant_score : @boost
  "#{expr}#{scoring}"
end

# File lib/lsolr.rb, line 528
def format_date(date)
  msec_str = case date
             when Date then date.strftime(FORMAT_MILLISECOND_FOR_DATE_TYPE).gsub(date.strftime(FORMAT_SECOND), '')
             when Time then date.strftime(FORMAT_MILLISECOND_FOR_TIME_TYPE)
             else raise TypeError, "Could not format dates or times. `#{date}` given."
             end

  return date.strftime(FORMAT_DATE_TIME) if msec_str == '000'

  "#{date.strftime('%Y-%m-%dT%H:%M:%S')}.#{msec_str}Z"
end

# File lib/lsolr.rb, line 476
def initialize_copy(obj)
  obj.prev = obj.prev.dup if present_query?(obj.prev)
  obj.left_parentheses = obj.left_parentheses.dup
  obj.right_parentheses = obj.right_parentheses.dup
end

# File lib/lsolr.rb, line 540
def link(another, operator)
  another = build_instance_if_needed(another)
  return self unless present_query?(another)

  another = another.dup
  head = another.head
  head.prev = dup
  head.operator = operator
  another
end

# File lib/lsolr.rb, line 494
def present_array?(val)
  !val.nil? && val.is_a?(Array) && !val.compact.empty? && val.map(&:to_s).map(&:empty?).none?
end

# File lib/lsolr.rb, line 498
def present_query?(val)
  !val.nil? && val.present?
end

# File lib/lsolr.rb, line 490
def present_string?(val)
  !val.nil? && (val.is_a?(String) || val.is_a?(Symbol)) && !val.empty?
end

# File lib/lsolr.rb, line 482
def range_search?
  @value.empty? && !@range_first.empty? && !@range_last.empty?
end

# File lib/lsolr.rb, line 486
def raw?
  !@raw.empty?
end

# File lib/lsolr.rb, line 520
def stringify(value, symbols: RESERVED_SYMBOLS - %w[- : . / + *])
  if value.is_a?(Date) || value.is_a?(Time)
    format_date(value)
  else
    clean(value, symbols: symbols)
  end
end

# File lib/lsolr.rb, line 502
def valid_boost_factor?(val)
  (val.is_a?(Float) || val.is_a?(Integer)) && val > 0
end

# File lib/lsolr.rb, line 510
def valid_fuzzy_match_distance?(val)
  (val.is_a?(Float) || val.is_a?(Integer)) && RANGE_FUZZY_MATCH_DISTANCE.member?(val)
end

# File lib/lsolr.rb, line 506
def valid_score?(val)
  val.is_a?(Float) || val.is_a?(Integer)
end