/*
    * #%L
    * MongoDbAuthenticator.java - mongodb-async-driver - Allanbank Consulting, Inc.
    * %%
    * Copyright (C) 2011 - 2014 Allanbank Consulting, Inc.
    * %%
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
   * 
   *      http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * #L%
   */
  
  package com.allanbank.mongodb.client.connection.auth;
  
  import java.nio.ByteBuffer;
  import java.nio.CharBuffer;
  import java.nio.charset.Charset;
  import java.security.MessageDigest;
  import java.security.NoSuchAlgorithmException;
  import java.util.Arrays;
  import java.util.List;
  import java.util.concurrent.ExecutionException;
  
  import com.allanbank.mongodb.Credential;
  import com.allanbank.mongodb.MongoDbException;
  import com.allanbank.mongodb.bson.Document;
  import com.allanbank.mongodb.bson.Element;
  import com.allanbank.mongodb.bson.builder.BuilderFactory;
  import com.allanbank.mongodb.bson.builder.DocumentBuilder;
  import com.allanbank.mongodb.bson.element.StringElement;
  import com.allanbank.mongodb.client.FutureCallback;
  import com.allanbank.mongodb.client.callback.AbstractReplyCallback;
  import com.allanbank.mongodb.client.callback.AbstractValidatingReplyCallback;
  import com.allanbank.mongodb.client.connection.Connection;
  import com.allanbank.mongodb.client.message.Command;
  import com.allanbank.mongodb.client.message.Reply;
  import com.allanbank.mongodb.error.MongoDbAuthenticationException;
  import com.allanbank.mongodb.util.IOUtils;
  
  /**
   * MongoDbAuthenticator provides an authenticator for the legacy, pre-2.4
   * version, of MongoDB authentication.
   * 
   * @copyright 2013-2014, Allanbank Consulting, Inc., All Rights Reserved
   */
  public class MongoDbAuthenticator implements Authenticator {
  
      /** The UTF-8 character encoding. */
      public static final Charset ASCII = Charset.forName("US-ASCII");
  
      /** The result of the Authentication attempt. */
      protected FutureCallback<Boolean> myResults = new FutureCallback<Boolean>();
  
      /**
       * Creates a new MongoDbAuthenticator.
       */
      public MongoDbAuthenticator() {
          super();
      }
  
      /**
       * {@inheritDoc}
       * <p>
       * Overridden to return a new authenticator.
       * </p>
       */
      @Override
      public MongoDbAuthenticator clone() {
          try {
              final MongoDbAuthenticator newAuth = (MongoDbAuthenticator) super
                      .clone();
              newAuth.myResults = new FutureCallback<Boolean>();
  
              return newAuth;
          }
          catch (final CloneNotSupportedException cannotHappen) {
              return new MongoDbAuthenticator();
          }
      }
  
      /**
       * Creates the MongoDB authentication hash of the password.
       * 
       * @param credentials
       *            The credentials to hash.
       * @return The hashed password/myCredential.
       * @throws NoSuchAlgorithmException
       *             On a failure to create a MD5 message digest.
       */
      public String passwordHash(final Credential credentials)
              throws NoSuchAlgorithmException {
         final MessageDigest md5 = MessageDigest.getInstance("MD5");
 
         return passwordHash(md5, credentials);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to returns the results of the authentication, once complete.
      * </p>
      */
     @Override
     public boolean result() throws MongoDbAuthenticationException {
 
         // Clear and restore the threads interrupted state for reconnect cases.
         final boolean interrupted = Thread.interrupted();
         try {
             return myResults.get().booleanValue();
         }
         catch (final InterruptedException e) {
             throw new MongoDbAuthenticationException(e);
         }
         catch (final ExecutionException e) {
             throw new MongoDbAuthenticationException(e);
         }
         finally {
             if (interrupted) {
                 Thread.currentThread().interrupt();
             }
         }
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to authenticate with MongoDB using the native/legacy
      * authentication mechanisms.
      * </p>
      */
     @Override
     public void startAuthentication(final Credential credential,
             final Connection connection) throws MongoDbAuthenticationException {
 
         try {
             final DocumentBuilder builder = BuilderFactory.start();
             builder.addInteger("getnonce", 1);
 
             connection.send(new Command(credential.getDatabase(),
                     Command.COMMAND_COLLECTION, builder.build()),
                     new NonceReplyCallback(credential, connection));
         }
         catch (final MongoDbException errorOnSend) {
             myResults.exception(errorOnSend);
 
             throw errorOnSend;
         }
     }
 
     /**
      * Creates the MongoDB authentication hash of the password.
      * 
      * @param md5
      *            The MD5 digest to compute the hash.
      * @param credentials
      *            The credentials to hash.
      * @return The hashed password/myCredential.
      */
     protected String passwordHash(final MessageDigest md5,
             final Credential credentials) {
 
         final char[] password = credentials.getPassword();
         final ByteBuffer bb = ASCII.encode(CharBuffer.wrap(password));
 
         md5.update((credentials.getUserName() + ":mongo:").getBytes(ASCII));
         md5.update(bb.array(), 0, bb.limit());
 
         Arrays.fill(password, ' ');
         Arrays.fill(bb.array(), (byte) 0);
 
         return IOUtils.toHex(md5.digest());
     }
 
     /**
      * AuthenticateReplyCallback provides the callback for the second step of
      * the authentication.
      * 
      * @copyright 2013, Allanbank Consulting, Inc., All Rights Reserved
      */
     private static class AuthenticateReplyCallback extends
             AbstractReplyCallback<Boolean> {
         /**
          * Creates a new AuthenticateReplyCallback.
          * 
          * @param results
          *            The results to update once the reply is received.
          */
         public AuthenticateReplyCallback(final FutureCallback<Boolean> results) {
             super(results);
         }
 
         /**
          * {@inheritDoc}
          * <p>
          * Overridden to convert the reply to a boolean based on if the
          * authentication worked.
          * </p>
          */
         @Override
         protected Boolean convert(final Reply reply) throws MongoDbException {
             boolean current = false;
             final List<Document> results = reply.getResults();
             if (results.size() == 1) {
                 final Document doc = results.get(0);
                 final Element okElem = doc.get("ok");
                 if (okElem != null) {
                     final int okValue = toInt(okElem);
                     if (okValue == 1) {
                         current = true;
                     }
 
                 }
             }
 
             return Boolean.valueOf(current);
         }
     }
 
     /**
      * NonceReplyCallback provides the callback for the reply to the nonce
      * request.
      * 
      * @copyright 2013-2014, Allanbank Consulting, Inc., All Rights Reserved
      */
     private class NonceReplyCallback extends AbstractValidatingReplyCallback {
 
         /** The connection to authenticate on. */
         private final Connection myConnection;
 
         /** The credentials to use in authentication. */
         private final Credential myCredential;
 
         /**
          * Creates a new NonceReplyCallback.
          * 
          * @param credential
          *            The credentials to use in authentication.
          * @param connection
          *            The connection to authenticate on.
          */
         public NonceReplyCallback(final Credential credential,
                 final Connection connection) {
             myCredential = credential;
             myConnection = connection;
         }
 
         /**
          * {@inheritDoc}
          * <p>
          * Overridden to set the exception on the results for the
          * authentication.
          * </p>
          */
         @Override
         public void exception(final Throwable thrown) {
             myResults.exception(thrown);
         }
 
         /**
          * {@inheritDoc}
          * <p>
          * Overridden to return true to make sure the authentication is
          * processed on a thread we control.
          * </p>
          */
         @Override
         public boolean isLightWeight() {
             return true;
         }
 
         /**
          * {@inheritDoc}
          * <p>
          * Overridden to retrieve the nonce from the reply and request
          * authentication.
          * </p>
          */
         @Override
         protected void handle(final Reply reply) {
 
             StringElement nonce = null;
             if (reply.getResults().size() > 0) {
                 final Document doc = reply.getResults().get(0);
                 nonce = doc.get(StringElement.class, "nonce");
                 if (nonce == null) {
                     // Bad reply. Try again.
                     exception(new MongoDbAuthenticationException(
                             "Bad response from nonce request."));
                     return;
                 }
             }
             else {
                 // Bad reply. Try again.
                 exception(new MongoDbAuthenticationException(
                         "Bad response from nonce request."));
                 return;
             }
 
             // Send an authenticate request.
             try {
                 final MessageDigest md5 = MessageDigest.getInstance("MD5");
                 final String passwordHash = passwordHash(md5, myCredential);
 
                 final String text = nonce.getValue()
                         + myCredential.getUserName() + passwordHash;
 
                 md5.reset();
                 md5.update(text.getBytes(ASCII));
                 final byte[] bytes = md5.digest();
 
                 final DocumentBuilder builder = BuilderFactory.start();
                 builder.addInteger("authenticate", 1);
                 builder.add(nonce);
                 builder.addString("user", myCredential.getUserName());
                 builder.addString("key", IOUtils.toHex(bytes));
 
                 myConnection.send(new Command(myCredential.getDatabase(),
                         Command.COMMAND_COLLECTION, builder.build()),
                         new AuthenticateReplyCallback(myResults));
             }
             catch (final NoSuchAlgorithmException e) {
                 exception(new MongoDbAuthenticationException(e));
             }
             catch (final RuntimeException e) {
                 exception(new MongoDbAuthenticationException(e));
             }
         }
     }
 }