class Net::LDAP::Filter

def le(attribute, value)
  new(:le, attribute, value)
end

def match(entry)
  case @op
  when :eq
    if @right == "*"
      l = entry[@left] and l.length > 0
    else
      l = entry[@left] and l = Array(l) and l.index(@right)
    end
  else
    raise Net::LDAP::FilterTypeUnknownError, "Unknown filter type in match: #{@op}"
  end
end

def ne(attribute, value)
  new(:ne, attribute, value)
end

def negate(filter)
  new(:not, filter, nil)
end

def parse_ber(ber)
  case ber.ber_identifier
  when 0xa0 # context-specific constructed 0, "and"
    ber.map { |b| parse_ber(b) }.inject { |memo, obj| memo & obj }
  when 0xa1 # context-specific constructed 1, "or"
    ber.map { |b| parse_ber(b) }.inject { |memo, obj| memo | obj }
  when 0xa2 # context-specific constructed 2, "not"
    ~parse_ber(ber.first)
  when 0xa3 # context-specific constructed 3, "equalityMatch"
    if ber.last == "*"
    else
      eq(ber.first, ber.last)
    end
  when 0xa4 # context-specific constructed 4, "substring"
    str = ""
    final = false
    ber.last.each do |b|
      case b.ber_identifier
      when 0x80 # context-specific primitive 0, SubstringFilter "initial"
        raise Net::LDAP::SubstringFilterError, "Unrecognized substring filter; bad initial value." if str.length > 0
        str += escape(b)
      when 0x81 # context-specific primitive 0, SubstringFilter "any"
        str += "*#{escape(b)}"
      when 0x82 # context-specific primitive 0, SubstringFilter "final"
        str += "*#{escape(b)}"
        final = true
      end
    end
    str += "*" unless final
    eq(ber.first.to_s, str)
  when 0xa5 # context-specific constructed 5, "greaterOrEqual"
    ge(ber.first.to_s, ber.last.to_s)
  when 0xa6 # context-specific constructed 6, "lessOrEqual"
    le(ber.first.to_s, ber.last.to_s)
  when 0x87 # context-specific primitive 7, "present"
    # call to_s to get rid of the BER-identifiedness of the incoming string.
    present?(ber.to_s)
  when 0xa9 # context-specific constructed 9, "extensible comparison"
    raise Net::LDAP::SearchFilterError, "Invalid extensible search filter, should be at least two elements" if ber.size < 2
    # Reassembles the extensible filter parts
    # (["sn", "2.4.6.8.10", "Barbara Jones", '1'])
    type = value = dn = rule = nil
    ber.each do |element|
      case element.ber_identifier
        when 0x81 then rule=element
        when 0x82 then type=element
        when 0x83 then value=element
        when 0x84 then dn='dn'
      end
    end
    attribute = ''
    attribute << type if type
    attribute << ":#{dn}" if dn
    attribute << ":#{rule}" if rule
    ex(attribute, value)
  else
    raise Net::LDAP::BERInvalidError, "Invalid BER tag-value (#{ber.ber_identifier}) in search filter."
  end
end

def parse_ldap_filter(obj)
  case obj.ber_identifier
  when 0x87 # present. context-specific primitive 7.
    eq(obj.to_s, "*")
  when 0xa3 # equalityMatch. context-specific constructed 3.
    eq(obj[0], obj[1])
  else
    raise Net::LDAP::SearchFilterTypeUnknownError, "Unknown LDAP search-filter type: #{obj.ber_identifier}"
  end
end

def present?(attribute)
  eq(attribute, "*")
end

def to_ber
  case @op
  when :eq
    if @right == "*" # presence test
      @left.to_s.to_ber_contextspecific(7)
    elsif @right.to_s =~ /[*]/ # substring
      # Parsing substrings is a little tricky. We use String#split to
      # break a string into substrings delimited by the * (star)
      # character. But we also need to know whether there is a star at the
      # head and tail of the string, so we use a limit parameter value of
      # -1: "If negative, there is no limit to the number of fields
      # returned, and trailing null fields are not suppressed."
      #
      # 20100320 AZ: This is much simpler than the previous verison. Also,
      # unnecessary regex escaping has been removed.
      ary = @right.split(/[*]+/, -1)
      if ary.first.empty?
        first = nil
        ary.shift
      else
        first = unescape(ary.shift).to_ber_contextspecific(0)
      end
      if ary.last.empty?
        last = nil
        ary.pop
      else
        last = unescape(ary.pop).to_ber_contextspecific(2)
      end
      seq = ary.map { |e| unescape(e).to_ber_contextspecific(1) }
      seq.unshift first if first
      seq.push last if last
      [@left.to_s.to_ber, seq.to_ber].to_ber_contextspecific(4)
    else # equality
      [@left.to_s.to_ber, unescape(@right).to_ber].to_ber_contextspecific(3)
    end
  when :bineq
    # make sure data is not forced to UTF-8
    [@left.to_s.to_ber, unescape(@right).to_ber_bin].to_ber_contextspecific(3)
  when :ex
    seq = []
    unless @left =~ /^([-;\w]*)(:dn)?(:(\w+|[.\w]+))?$/
      raise Net::LDAP::BadAttributeError, "Bad attribute #{@left}"
    end
    type, dn, rule = $1, $2, $4
    seq << rule.to_ber_contextspecific(1) unless rule.to_s.empty? # matchingRule
    seq << type.to_ber_contextspecific(2) unless type.to_s.empty? # type
    seq << unescape(@right).to_ber_contextspecific(3) # matchingValue
    seq << "1".to_ber_contextspecific(4) unless dn.to_s.empty? # dnAttributes
    seq.to_ber_contextspecific(9)
  when :ge
    [@left.to_s.to_ber, unescape(@right).to_ber].to_ber_contextspecific(5)
  when :le
    [@left.to_s.to_ber, unescape(@right).to_ber].to_ber_contextspecific(6)
  when :ne
    [self.class.eq(@left, @right).to_ber].to_ber_contextspecific(2)
  when :and
    ary = [@left.coalesce(:and), @right.coalesce(:and)].flatten
    ary.map(&:to_ber).to_ber_contextspecific(0)
  when :or
    ary = [@left.coalesce(:or), @right.coalesce(:or)].flatten
    ary.map(&:to_ber).to_ber_contextspecific(1)
  when :not
    [@left.to_ber].to_ber_contextspecific(2)
  end
end

def to_raw_rfc2254
  case @op
  when :ne
    "!(#{@left}=#{@right})"
  when :eq, :bineq
    "#{@left}=#{@right}"
  when :ex
    "#{@left}:=#{@right}"
  when :ge
    "#{@left}>=#{@right}"
  when :le
    "#{@left}<=#{@right}"
  when :and
    "&(#{@left.to_raw_rfc2254})(#{@right.to_raw_rfc2254})"
  when :or
    "|(#{@left.to_raw_rfc2254})(#{@right.to_raw_rfc2254})"
  when :not
    "!(#{@left.to_raw_rfc2254})"
  end
end

def to_rfc2254
  "(#{to_raw_rfc2254})"
end

def to_s
  to_rfc2254
end

def unescape(right)
  right = right.to_s
  if right.length == 16 && right.encoding == Encoding::BINARY
    right
  else
    right.to_s.gsub(/\\([a-fA-F\d]{2})/) { [$1.hex].pack("U") }
  end
end

def |(filter)
  self.class.intersect(self, filter)
end

def ~@
  self.class.negate(self)
end