module ActiveLdap::HumanReadable::ClassMethods

def human_attribute_description(attribute_or_name)
  msgid = human_attribute_description_msgid(attribute_or_name)
  return nil if msgid.nil?
  s_(msgid)
end

def human_attribute_description_msgid(attribute_or_name)
  if attribute_or_name.is_a?(Schema::Attribute)
    attribute = attribute_or_name
  else
    attribute = schema.attribute(attribute_or_name.to_s)
    return nil if attribute.nil?
  end
  description = attribute.description
  return nil if description.nil?
  "LDAP|Description|Attribute|#{attribute.name}|#{description}"
end

def human_attribute_name(attribute_or_name, options={})
  logger.warn("options was ignored.") unless options.empty?
  msgid = human_attribute_name_msgid(attribute_or_name)
  msgid ||= human_attribute_name_with_gettext(attribute_or_name)
  s_(msgid)
end

def human_attribute_name_msgid(attribute_or_name)
  if attribute_or_name.is_a?(Schema::Attribute)
    name = attribute_or_name.name
  else
    attribute_name = attribute_or_name.to_s
    attribute = schema.attribute(attribute_name)
    return nil if attribute.id.nil?
    if attribute.name == attribute_name or
        attribute.aliases.include?(attribute_name)
      name = attribute_name
    else
      return nil
    end
  end
  "LDAP|Attribute|#{name}"
end

def human_object_class_description(object_class_or_name)
  msgid = human_object_class_description_msgid(object_class_or_name)
  return nil if msgid.nil?
  s_(msgid)
end

def human_object_class_description_msgid(object_class_or_name)
  if object_class_or_name.is_a?(Schema::ObjectClass)
    object_class = object_class_or_name
  else
    object_class = schema.object_class(object_class_or_name)
    return nil if object_class.nil?
  end
  description = object_class.description
  return nil if description.nil?
  "LDAP|Description|ObjectClass|#{object_class.name}|#{description}"
end

def human_object_class_name(object_class_or_name)
  s_(human_object_class_name_msgid(object_class_or_name))
end

def human_object_class_name_msgid(object_class_or_name)
  if object_class_or_name.is_a?(Schema::ObjectClass)
    name = object_class_or_name.name
  else
    name = object_class_or_name
  end
  "LDAP|ObjectClass|#{name}"
end

def human_readable_format(object)
  case object
  when Array
    "[#{object.collect {|value| human_readable_format(value)}.join(', ')}]"
  when Hash
    formatted_values = []
    object.each do |key, value|
      formatted_values << [human_readable_format(key),
                           human_readable_format(value)].join("=>")
    end
    "{#{formatted_values.join(', ')}}"
  else
    if object.respond_to?(:to_human_readable_format)
      object.to_human_readable_format
    else
      object.inspect
    end
  end
end

def human_syntax_description(syntax_or_id)
  msgid = human_syntax_description_msgid(syntax_or_id)
  return nil if msgid.nil?
  s_(msgid)
end

def human_syntax_description_msgid(syntax_or_id)
  if syntax_or_id.is_a?(Schema::Syntax)
    syntax = syntax_or_id
  else
    syntax = schema.ldap_syntax(syntax_or_id)
    return nil if syntax.nil?
  end
  description = syntax.description
  return nil if description.nil?
  "LDAP|Description|Syntax|#{syntax.id}|#{description}"
end

def human_syntax_name(syntax_or_id)
  s_(human_syntax_name_msgid(syntax_or_id))
end

def human_syntax_name_msgid(syntax_or_id)
  if syntax_or_id.is_a?(Schema::Syntax)
    id = syntax_or_id.id
  else
    id = syntax_or_id
  end
  "LDAP|Syntax|#{id}"
end