package org.argeo.naming;
   
   import static org.argeo.naming.LdapAttrs.DN;
   import static org.argeo.naming.LdapAttrs.member;
   import static org.argeo.naming.LdapAttrs.objectClass;
   import static org.argeo.naming.LdapAttrs.uniqueMember;
   
   import java.io.IOException;
   import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.Writer;
  import java.nio.charset.Charset;
  import java.nio.charset.StandardCharsets;
  import java.util.Base64;
  import java.util.Map;
  import java.util.SortedSet;
  import java.util.TreeSet;
  
  import javax.naming.NamingEnumeration;
  import javax.naming.NamingException;
  import javax.naming.directory.Attribute;
  import javax.naming.directory.Attributes;
  import javax.naming.ldap.LdapName;
  import javax.naming.ldap.Rdn;
  
  import org.argeo.osgi.useradmin.UserDirectoryException;
  
  /** Basic LDIF writer */
  public class LdifWriter {
  	private final static Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;
  	private final Writer writer;
  
  	/** Writer must be closed by caller */
  	public LdifWriter(Writer writer) {
  		this.writer = writer;
  	}
  
  	/** Stream must be closed by caller */
  	public LdifWriter(OutputStream out) {
  		this(new OutputStreamWriter(out, DEFAULT_CHARSET));
  	}
  
  	public void writeEntry(LdapName name, Attributes attributes) throws IOException {
  		try {
  			// check consistency
  			Rdn nameRdn = name.getRdn(name.size() - 1);
  			Attribute nameAttr = attributes.get(nameRdn.getType());
  			if (!nameAttr.get().equals(nameRdn.getValue()))
  				throw new UserDirectoryException(
  						"Attribute " + nameAttr.getID() + "=" + nameAttr.get() + " not consistent with DN " + name);
  
  			writer.append(DN + ": ").append(name.toString()).append('\n');
  			Attribute objectClassAttr = attributes.get(objectClass.name());
  			if (objectClassAttr != null)
  				writeAttribute(objectClassAttr);
  			attributes: for (NamingEnumeration<? extends Attribute> attrs = attributes.getAll(); attrs.hasMore();) {
  				Attribute attribute = attrs.next();
  				if (attribute.getID().equals(DN) || attribute.getID().equals(objectClass.name()))
  					continue attributes;// skip DN attribute
  				if (attribute.getID().equals(member.name()) || attribute.getID().equals(uniqueMember.name()))
  					continue attributes;// skip member and uniqueMember attributes, so that they are always written last
  				writeAttribute(attribute);
  			}
  			// write member and uniqueMember attributes last
  			for (NamingEnumeration<? extends Attribute> attrs = attributes.getAll(); attrs.hasMore();) {
  				Attribute attribute = attrs.next();
  				if (attribute.getID().equals(member.name()) || attribute.getID().equals(uniqueMember.name()))
  					writeMemberAttribute(attribute);
  			}
  			writer.append('\n');
  			writer.flush();
  		} catch (NamingException e) {
  			throw new UserDirectoryException("Cannot write LDIF", e);
  		}
  	}
  
  	public void write(Map<LdapName, Attributes> entries) throws IOException {
  		for (LdapName dn : entries.keySet())
  			writeEntry(dn, entries.get(dn));
  	}
  
  	protected void writeAttribute(Attribute attribute) throws NamingException, IOException {
  		for (NamingEnumeration<?> attrValues = attribute.getAll(); attrValues.hasMore();) {
  			Object value = attrValues.next();
  			if (value instanceof byte[]) {
  				String encoded = Base64.getEncoder().encodeToString((byte[]) value);
  				writer.append(attribute.getID()).append(":: ").append(encoded).append('\n');
  			} else {
  				writer.append(attribute.getID()).append(": ").append(value.toString()).append('\n');
  			}
  		}
  	}
  
  	protected void writeMemberAttribute(Attribute attribute) throws NamingException, IOException {
  		// Note: duplicate entries will be swallowed
  		SortedSet<String> values = new TreeSet<>();
  		for (NamingEnumeration<?> attrValues = attribute.getAll(); attrValues.hasMore();) {
  			String value = attrValues.next().toString();
  			values.add(value);
 		}
 
 		for (String value : values) {
 			writer.append(attribute.getID()).append(": ").append(value).append('\n');
 		}
 	}
 }