class ActiveLdap::Base

def self.class_local_attr_accessor(search_ancestors, *syms)
  syms.flatten.each do |sym|
    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
      def self.#{sym}(search_superclasses=#{search_ancestors})
        @#{sym} ||= nil
        return @#{sym} if @#{sym}
        if search_superclasses
          target = superclass
          value = nil
          loop do
            break nil unless target.respond_to?(:#{sym})
            value = target.#{sym}
            break if value
            target = target.superclass
          end
          value
        else
          nil
        end
      end
      def #{sym}; self.class.#{sym}; end
      def self.#{sym}=(value); @#{sym} = value; end
    EOS
  end
end

def ==(comparison_object)
  comparison_object.equal?(self) or
    (comparison_object.instance_of?(self.class) and
     comparison_object.dn == dn and
     !comparison_object.new_entry?)
end

def [](name, force_array=false)
  if name == "dn"
    array_of(dn, force_array)
  else
    get_attribute(name, force_array)
  end
end

def []=(name, value)
  set_attribute(name, value)
end

def abstract_class?
  defined?(@abstract_class) && @abstract_class
end

def array_of(value, to_a=true)
  case value
  when Array
    if to_a or value.size > 1
      value.collect {|v| array_of(v, false)}.compact
    else
      if value.empty?
        nil
      else
        array_of(value.first, to_a)
      end
    end
  when Hash
    if to_a
      [value]
    else
      result = {}
      value.each {|k, v| result[k] = array_of(v, to_a)}
      result
    end
  else
    to_a ? [value] : value
  end
end

def assign_attributes(new_attributes)
  return if new_attributes.blank?
  _schema = _local_entry_attribute = nil
  targets = sanitize_for_mass_assignment(new_attributes)
  have_dn = false
  dn_value = nil
  targets.each do |key, value|
    setter = "#{key}="
    unless respond_to?(setter)
      _schema ||= schema
      attribute = _schema.attribute(key)
      next if attribute.id.nil?
      _local_entry_attribute ||= local_entry_attribute
      _local_entry_attribute.register(attribute)
    end
    case setter
    when "dn=", "id="
      have_dn = true
      dn_value = value
    else
      send(setter, value)
    end
  end
  self.dn = dn_value if have_dn
end

def attribute_name_resolvable_without_connection?
  @entry_attribute and @local_entry_attribute
end

def attribute_names(normalize=false)
  entry_attribute.names(normalize)
end

def attribute_present?(name)
  values = get_attribute(name, true)
  !values.empty? or values.any? {|x| !(x and x.empty?)}
end

def attributes
  @simplified_data ||= simplify_data(@data)
  @simplified_data.clone
end

def attributes=(new_attributes)
  return if new_attributes.blank?
  assign_attributes(new_attributes)
end

def base
  @base ||= compute_base
end

def base
  @base ||= compute_base
end

def base=(value)
  self.inheritable_base = value
  @base = nil
end

def base=(object_local_base)
  ensure_update_dn
  @dn = nil
  @base = nil
  @base_value = object_local_base
end

def base_class
  if self == Base or superclass == Base
    self
  else
    superclass.base_class
  end
end

def bind(config_or_password={}, config_or_ignore=nil, &block)
  if config_or_password.is_a?(String)
    config = (config_or_ignore || {}).merge(:password => config_or_password)
  else
    config = config_or_password
  end
  config = {:bind_dn => dn, :allow_anonymous => false}.merge(config)
  config[:password_block] ||= block if block_given?
  setup_connection(config)
  before_connection = @connection
  begin
    @connection = nil
    connection.connect
    @connection = connection
    clear_connection_based_cache
    clear_association_cache
  rescue ActiveLdap::Error
    remove_connection
    @connection = before_connection
    raise
  end
  true
end

def class_of_active_ldap_descendant(klass)
  if klass.superclass == Base or klass.superclass.abstract_class?
    klass
  elsif klass.superclass.nil?
    raise Error, _("%s doesn't belong in a hierarchy descending " \
                   "from ActiveLdap") % (name || to_s)
  else
    class_of_active_ldap_descendant(klass.superclass)
  end
end

def clear_connection_based_cache
  @schema = nil
  @local_entry_attribute = nil
  clear_object_class_based_cache
end

def clear_object_class_based_cache
  @entry_attribute = nil
  @real_names = {}
  clear_changes_information
end

def clear_removed_attributes_data(removed_attributes)
  return if removed_attributes.empty?
  removed_entry_attribute = EntryAttribute.new(nil, [])
  removed_attributes.each do |attribute|
    removed_entry_attribute.register(attribute)
  end
  @data.reject! do |key, _|
    removed_entry_attribute.exist?(key)
  end
end

def collect_all_attributes(data)
  dn_attr = dn_attribute
  dn_value = data[dn_attr]
  attributes = []
  attributes.push([dn_attr, dn_value])
  oc_value = data['objectClass']
  attributes.push(['objectClass', oc_value])
  except_keys = ['objectClass', dn_attr].collect(&:downcase)
  data.each do |key, value|
    next if except_keys.include?(key.downcase)
    value = self.class.remove_blank_value(value)
    next if self.class.blank_value?(value)
    attributes.push([key, value])
  end
  attributes
end

def collect_modified_attributes(ldap_data, data)
  klass = self.class
  _dn_attribute = dn_attribute
  new_dn_value = nil
  attributes = []
  # Now that all the options will be treated as unique attributes
  # we can see what's changed and add anything that is brand-spankin'
  # new.
  ldap_data.each do |k, v|
    value = data[k] || []
    next if v == value
    value = klass.remove_blank_value(value) || []
    next if v == value
    if klass.blank_value?(value) and
        schema.attribute(k).binary_required?
      value = [{'binary' => []}]
    end
    if k == _dn_attribute
      new_dn_value = value[0]
    else
      if (v.size == 1 and value.size == 1) or force_replace?(k)
        attributes.push([:replace, k, value])
      else
        removed_values = v - value
        added_values = value - v
        attributes.push([:delete, k, removed_values]) unless removed_values.empty?
        attributes.push([:add, k, added_values]) unless added_values.empty?
      end
    end
  end
  data.each do |k, v|
    value = v || []
    next if ldap_data.has_key?(k)
    value = klass.remove_blank_value(value) || []
    next if klass.blank_value?(value)
    # Detect subtypes and account for them
    # REPLACE will function like ADD, but doesn't hit EQUALITY problems
    # TODO: Added equality(attr) to Schema
    if force_replace?(k)
      attributes.push([:replace, k, value])
    else
      attributes.push([:add, k, value])
    end
  end
  [new_dn_value, attributes]
end

def compute_base
  _base = inheritable_base
  _base = configuration[:base] if _base.nil? and configuration
  if _base.nil?
    target = superclass
    loop do
      break unless target.respond_to?(:base)
      _base = target.base
      break if _base
      target = target.superclass
    end
  end
  _prefix = prefix
  _base ||= connection.naming_contexts.first
  return _prefix if _base.blank?
  _base = DN.parse(_base)
  _base = _prefix + _base if _prefix
  _base
end

def compute_base
  ensure_update_dn
  base_of_class = self.class.base
  if @base_value.nil?
    base_of_class
  else
    base_of_object = DN.parse(@base_value)
    base_of_object += base_of_class if base_of_class
    base_of_object
  end
end

def compute_dn
  return base if @dn_is_base
  ensure_update_dn
  dn_value = id
  if dn_value.nil?
    format = _("%s's DN attribute (%s) isn't set")
    message = format % [self.inspect, dn_attribute]
    raise DistinguishedNameNotSetError.new, message
  end
  dn_value = DN.escape_value(dn_value.to_s)
  _base = base
  _base = nil if _base.blank?
  DN.parse(["#{dn_attribute}=#{dn_value}", _base].compact.join(","))
end

def create(attributes=nil, &block)
  if attributes.is_a?(Array)
    attributes.collect {|attrs| create(attrs, &block)}
  else
    object = new(attributes, &block)
    object.save
    object
  end
end

def default_dn_attribute
  dn_attribute = nil
  parent_class = ancestors[1]
  if parent_class.respond_to?(:dn_attribute)
    dn_attribute = parent_class.dn_attribute
  end
  dn_attribute || "cn"
end

def default_prefix
  if name.blank?
    nil
  else
    "ou=#{name.demodulize.pluralize}"
  end
end

def default_search_attribute
  dn_attribute
end

def default_search_attribute
  self.class.default_search_attribute
end

def delete_all(options={})
  super({:base => dn}.merge(options || {}))
end

def destroy_all(options={})
  super({:base => dn}.merge(options || {}))
end

def dn
  @dn ||= compute_dn
end

def dn=(value)
  set_attribute(dn_attribute_with_fallback, value)
end

def dn_attribute
  ensure_update_dn
  _dn_attribute = @dn_attribute || dn_attribute_of_class
  to_real_attribute_name(_dn_attribute) || _dn_attribute
end

def dn_attribute_with_fallback
  begin
    dn_attribute
  rescue DistinguishedNameInvalid
    _dn_attribute = @dn_attribute || dn_attribute_of_class
    _dn_attribute = to_real_attribute_name(_dn_attribute) || _dn_attribute
    raise if _dn_attribute.nil?
    _dn_attribute
  end
end

def enforce_type(key, value)
  # Enforce attribute value formatting
  normalize_attribute(key, value)[1]
end

def ensure_logger
  @@logger ||= configuration[:logger]
  # Setup default logger to console
  if @@logger.nil?
    require 'logger'
    @@logger = Logger.new(STDERR)
    @@logger.progname = 'ActiveLdap'
    @@logger.level = Logger::ERROR
  end
  configuration[:logger] ||= @@logger
end

def ensure_update_dn
  return unless need_update_dn?
  @mutex.synchronize do
    if @dn_split_value
      update_dn(*@dn_split_value)
      @dn_split_value = nil
    end
  end
end

def entry_attribute
  @entry_attribute ||=
    connection.entry_attribute(find_object_class_values(@data) || [])
end

def eql?(comparison_object)
  self == (comparison_object)
end

def exist?
  self.class.exists?(dn)
end

def extract_object_class!(attributes)
  classes = []
  attributes.keys.each do |key|
    string_key = key.to_s
    if /\Aobject_?class\z/i =~ string_key
      classes.concat(attributes[key].to_a)
      attributes.delete(key)
    end
  end
  classes
end

def find_object_class_values(data)
  data["objectClass"] || data["objectclass"]
end

def find_real_class(object_classes)
  (sub_classes || []).each do |sub_class|
    real_class = sub_class.find_real_class(object_classes)
    return real_class if real_class
  end
  if object_classes.superset?(Set.new(classes))
    self
  else
    nil
  end
end

def force_replace?(k)
  attribute = schema.attribute(k)
  attribute.single_value? or
    attribute.binary? # TODO: this should probably explicitly check for fields with no equality matching rule instead
end

def hash
  return super if @_hashing # workaround for GetText :<
  _dn = nil
  begin
    @_hashing = true
    _dn = dn
  rescue DistinguishedNameInvalid, DistinguishedNameNotSetError
    return super
  ensure
    @_hashing = false
  end
  _dn.hash
end

def have_attribute?(name, except=[])
  real_name = to_real_attribute_name(name)
  !real_name.nil? and !except.include?(real_name)
end

def human_name(options={})
  defaults = self_and_descendants_from_active_ldap.collect do |klass|
    if klass.name.blank?
      nil
    else
      :"#{klass.name.underscore}"
    end
  end
  defaults << name.humanize
  defaults = defaults.compact
  defaults.first || name || to_s
end

def id
  get_attribute(dn_attribute_with_fallback)
end

def inherited(sub_class)
  super
  sub_class.module_eval do
    include GetTextSupport
  end
  (self.sub_classes ||= []) << sub_class
end

def init_base
  init_instance_variables
end

def init_instance_variables
  @mutex = Mutex.new
  @data = {} # where the r/w entry data is stored
  @ldap_data = {} # original ldap entry data
  @dn_attribute = nil
  @base = nil
  @scope = nil
  @dn = nil
  @dn_is_base = false
  @dn_split_value = nil
  @connection ||= nil
  @_hashing = false
  clear_connection_based_cache
end

def initialize(attributes=nil)
  init_base
  @new_entry = true
  initial_classes = required_classes | recommended_classes
  case attributes
  when nil
    self.classes = initial_classes
  when String, Array, DN
    self.classes = initial_classes
    self.dn = attributes
  when Hash
    attributes = attributes.clone
    classes = extract_object_class!(attributes)
    self.classes = classes | initial_classes
    self.attributes = attributes
  else
    format = _("'%s' must be either nil, DN value as ActiveLdap::DN, " \
               "String or Array or attributes as Hash")
    raise ArgumentError, format % attributes.inspect
  end
  yield self if block_given?
  run_callbacks :initialize unless _initialize_callbacks.empty?
end

def initialize_attributes(attributes)
  _schema = _local_entry_attribute = nil
  targets = sanitize_for_mass_assignment(attributes)
  targets.each do |key, value|
    unless have_attribute?(key)
      _schema ||= schema
      attribute = _schema.attribute(key)
      _local_entry_attribute ||= local_entry_attribute
      _local_entry_attribute.register(attribute)
    end
    set_attribute(key, value)
  end
  clear_changes_information
end

def initialize_by_ldap_data(dn, attributes)
  init_base
  dn = Compatible.convert_to_utf8_encoded_object(dn)
  attributes = Compatible.convert_to_utf8_encoded_object(attributes)
  @original_dn = dn.clone
  @dn = dn
  @base = nil
  @base_value = nil
  @new_entry = false
  @dn_is_base = false
  @ldap_data = attributes
  attributes = attributes.clone
  classes = extract_object_class!(attributes)
  self.classes = classes
  self.dn = dn
  remove_dn_attribute!(attributes)
  initialize_attributes(attributes)
  yield self if block_given?
end

def inspect
  if self == Base
    super
  elsif abstract_class?
    "#{super}(abstract)"
  else
    detail = nil
    begin
      must = []
      may = []
      class_names = classes.collect do |object_class|
        must.concat(object_class.must)
        may.concat(object_class.may)
        object_class.name
      end
      detail = ["objectClass:<#{class_names.join(', ')}>",
                "must:<#{inspect_attributes(must)}>",
                "may:<#{inspect_attributes(may)}>"].join(", ")
    rescue ActiveLdap::ConnectionNotSetup
      detail = "not-connected"
    rescue ActiveLdap::Error
      detail = "connection-failure"
    end
    "#{super}(#{detail})"
  end
end

def inspect
  object_classes = entry_attribute.object_classes
  inspected_object_classes = object_classes.collect do |object_class|
    object_class.name
  end.join(', ')
  must_attributes = must.collect(&:name).sort.join(', ')
  may_attributes = may.collect(&:name).sort.join(', ')
  inspected_attributes = attribute_names.sort.collect do |name|
    inspect_attribute(name)
  end.join(', ')
  result = "\#<#{self.class} objectClass:<#{inspected_object_classes}>, "
  result << "must:<#{must_attributes}>, may:<#{may_attributes}>, "
  result << "#{inspected_attributes}>"
  result
end

def inspect_attribute(attribute)
  syntax = attribute.syntax
  result = "#{attribute.name}"
  if syntax and !syntax.description.blank?
    result << ": #{syntax.description}"
  end
  properties = []
  properties << "read-only" if attribute.read_only?
  properties << "binary" if attribute.binary?
  properties << "binary-required" if attribute.binary_required?
  result << "(#{properties.join(', ')})" unless properties.empty?
  result
end

def inspect_attribute(name)
  values = get_attribute(name, true)
  values.collect do |value|
    if value.is_a?(String) and value.length > 50
      "#{value[0, 50]}...".inspect
    elsif value.is_a?(Date) || value.is_a?(Time)
      if value.respond_to?(:to_fs)
        # Support for Rails >= 7.0
        value.to_fs(:db)
      else
        # Support for Rails < 7.0
        value.to_s(:db)
      end
    else
      value.inspect
    end
  end
  "#{name}: #{values.inspect}"
end

def inspect_attributes(attributes)
  inspected_attribute_names = {}
  attributes.collect do |attribute|
    if inspected_attribute_names.has_key?(attribute.name)
      nil
    else
      inspected_attribute_names[attribute.name] = true
      inspect_attribute(attribute)
    end
  end.compact.join(', ')
end

def instantiate(args)
  dn, attributes, options = args
  options ||= {}
  object_classes_raw =
    attributes["objectClass"] ||
    attributes["objectclass"] ||
    []
  if sub_classes.nil? or object_classes_raw.empty?
    real_klass = self
  else
    object_classes = Set.new
    object_classes_raw.each do |object_class_raw|
      object_classes << schema.object_class(object_class_raw)
    end
    real_klass = find_real_class(object_classes) || self
  end
  obj = real_klass.allocate
  conn = options[:connection] || connection
  obj.connection = conn if conn != connection
  obj.instance_eval do
    initialize_by_ldap_data(dn, attributes)
  end
  obj
end

def instantiate(args)
  dn, attributes, options = args
  options ||= {}
  obj = self.class.allocate
  obj.connection = options[:connection] || @connection
  obj.instance_eval do
    initialize_by_ldap_data(dn, attributes)
  end
  obj
end

def ldap_mapping(options={})
  options = options.symbolize_keys
  validate_ldap_mapping_options(options)
  self.dn_attribute = options[:dn_attribute] || default_dn_attribute
  self.dn_attribute = dn_attribute.to_s if dn_attribute.is_a?(Symbol)
  self.prefix = options[:prefix] || default_prefix
  self.scope = options[:scope]
  self.required_classes = options[:classes]
  self.recommended_classes = options[:recommended_classes]
  self.excluded_classes = options[:excluded_classes]
  self.sort_by = options[:sort_by]
  self.order = options[:order]
  public_class_method :new
end

def local_entry_attribute
  @local_entry_attribute ||= connection.entry_attribute([])
end

def may
  entry_attribute.may
end

def must
  entry_attribute.must
end

def need_update_dn?
  not @dn_split_value.nil?
end

def normalize_data(data, except=[])
  _schema = schema
  result = {}
  data.each do |key, values|
    next if except.include?(key)
    real_name = to_real_attribute_name(key)
    next if real_name and except.include?(real_name)
    real_name ||= key
    next if _schema.attribute(real_name).id.nil?
    result[real_name] ||= []
    result[real_name].concat(enforce_type(real_name, values))
  end
  result
end

def prefix
  @prefix ||= inheritable_prefix and DN.parse(inheritable_prefix)
end

def prefix=(value)
  self.inheritable_prefix = value
  @prefix = nil
  @base = nil
end

def prepare_data_for_saving
  # Expand subtypes to real ldap_data attributes
  # We can't reuse @ldap_data because an exception would leave
  # an object in an unknown state
  ldap_data = normalize_data(@ldap_data)
  # Expand subtypes to real data attributes, but leave @data alone
  object_classes = find_object_class_values(@ldap_data) || []
  original_attributes =
    connection.entry_attribute(object_classes).names
  bad_attrs = original_attributes - entry_attribute.names
  data = normalize_data(@data, bad_attrs)
  success = yield(data, ldap_data)
  if success
    @ldap_data = data.clone
    # Delete items disallowed by objectclasses.
    # They should have been removed from ldap.
    bad_attrs.each do |remove_me|
      @ldap_data.delete(remove_me)
    end
    @original_dn = dn.clone
  end
  success
end

def register_new_dn_attribute(name, value)
  @dn = nil
  @dn_is_base = false
  if value.blank?
    @dn_split_value = nil
    [name, nil]
  else
    new_name, new_value, raw_new_value, new_bases = split_dn_value(value)
    @dn_split_value = [new_name, new_value, new_bases]
    if new_name.nil? and new_value.nil?
      new_name, raw_new_value = new_bases[0].to_a[0]
    end
    [to_real_attribute_name(new_name) || name,
     raw_new_value || value]
  end
end

def remove_dn_attribute!(attributes)
  _dn_attribute = dn_attribute
  attributes.keys.each do |key|
    case key
    when "id", :id, "dn", :dn
      attributes.delete(key)
    else
      normalized_key = to_real_attribute_name(key) || key
      if normalized_key == _dn_attribute
        attributes.delete(key)
      end
    end
  end
end

def schema
  @schema ||= super
end

def scope
  @scope || scope_of_class
end

def scope=(scope)
  validate_scope(scope)
  self.scope_without_validation = scope
end

def scope=(scope)
  self.class.validate_scope(scope)
  @scope = scope
end

def self_and_descendants_from_active_ldap
  klass = self
  classes = [klass]
  while klass != klass.base_class
    classes << klass = klass.superclass
  end
  classes
rescue
  [self]
end

def setup_connection(config=nil)
  super
  ensure_logger
  nil
end

def simplify_data(data)
  _schema = schema
  result = {}
  data.each do |key, values|
    attribute = _schema.attribute(key)
    if attribute.single_value? and values.is_a?(Array) and values.size == 1
      values = values[0]
    end
    result[key] = type_cast(attribute, values)
  end
  result
end

def split_dn_value(value)
  dn_value = relative_dn_value = nil
  value = value.first if value.is_a?(Array) and value.size == 1
  dn_value = value if value.is_a?(DN)
  begin
    dn_value ||= DN.parse(value)
  rescue DistinguishedNameInvalid
    begin
      dn_value = DN.parse("#{dn_attribute}=#{value}")
    rescue DistinguishedNameInvalid
      return [nil, value, value, []]
    end
  end
  val = bases = nil
  begin
    relative_dn_value = dn_value
    base_of_class = self.class.base
    relative_dn_value -= base_of_class if base_of_class
    if relative_dn_value.rdns.empty?
      val = []
      bases = dn_value.rdns
    else
      val, *bases = relative_dn_value.rdns
    end
  rescue ArgumentError
    val, *bases = dn_value.rdns
  end
  dn_attribute_name, dn_attribute_value = val.to_a[0]
  escaped_dn_attribute_value = nil
  unless dn_attribute_value.nil?
    escaped_dn_attribute_value = DN.escape_value(dn_attribute_value)
  end
  [dn_attribute_name, escaped_dn_attribute_value,
   dn_attribute_value, bases]
end

def to_key
  [dn]
rescue DistinguishedNameNotSetError
  nil
end

def to_ldif
  Ldif.new([to_ldif_record]).to_s
end

def to_ldif_record
  super(dn, normalize_data(@data))
end

def to_param
  id
end

def to_real_attribute_name(name, allow_normalized_name=true)
  return name if name.nil?
  if allow_normalized_name
    entry_attribute.normalize(name, allow_normalized_name) ||
      local_entry_attribute.normalize(name, allow_normalized_name)
  else
    @real_names[name] ||=
      entry_attribute.normalize(name, false) ||
      local_entry_attribute.normalize(name, false)
  end
end

def to_s
  to_ldif
end

def to_xml(options={})
  options = options.dup
  options[:root] ||= (self.class.name || '').underscore
  options[:root] = 'anonymous' if options[:root].blank?
  [:only, :except].each do |attribute_names_key|
    names = options[attribute_names_key]
    next if names.nil?
    options[attribute_names_key] = names.collect do |name|
      if name.to_s.downcase == "dn"
        "dn"
      else
        to_real_attribute_name(name)
      end
    end.compact
  end
  XML.new(dn, normalize_data(@data), schema).to_s(options)
end

def update_attribute(name, value)
  send("#{name}=", value)
  save
end

def update_attributes(attrs)
  self.attributes = attrs
  save
end

def update_attributes!(attrs)
  self.attributes = attrs
  save!
end

def update_dn(new_name, new_value, bases)
  if new_name.nil? and new_value.nil?
    @dn_is_base = true
    @base = nil
    @base_value = nil
    attr, value = bases[0].to_a[0]
    @dn_attribute = attr
    _ = value # for suppress a warning on Ruby 1.9.3
  else
    new_name ||= @dn_attribute || dn_attribute_of_class
    new_name = to_real_attribute_name(new_name)
    if new_name.nil?
      new_name = @dn_attribute || dn_attribute_of_class
      new_name = to_real_attribute_name(new_name)
    end
    new_bases = bases.empty? ? nil : DN.new(*bases).to_s
    dn_components = ["#{new_name}=#{new_value}",
                     new_bases,
                     self.class.base.to_s]
    dn_components = dn_components.find_all {|component| !component.blank?}
    DN.parse(dn_components.join(','))
    @base = nil
    @base_value = new_bases
    @dn_attribute = new_name
  end
end

def validate_ldap_mapping_options(options)
  options.assert_valid_keys(VALID_LDAP_MAPPING_OPTIONS)
end

def validate_scope(scope)
  scope = scope.to_sym if scope.is_a?(String)
  return if scope.nil? or scope.is_a?(Symbol)
  raise ConfigurationError,
          _("scope '%s' must be a Symbol") % scope.inspect
end