/*
    * #%L
    * AuthenticatingConnection.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.util.Collection;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  
  import com.allanbank.mongodb.Credential;
  import com.allanbank.mongodb.MongoClientConfiguration;
  import com.allanbank.mongodb.MongoDbException;
  import com.allanbank.mongodb.client.Message;
  import com.allanbank.mongodb.client.callback.ReplyCallback;
  import com.allanbank.mongodb.client.connection.Connection;
  import com.allanbank.mongodb.client.connection.proxy.AbstractProxyConnection;
  import com.allanbank.mongodb.error.MongoDbAuthenticationException;
  import com.allanbank.mongodb.util.log.Log;
  import com.allanbank.mongodb.util.log.LogFactory;
  
  /**
   * AuthenticatingConnection provides a connection that authenticated with the
   * server for each database before it is used.
   * 
   * @api.no This class is <b>NOT</b> part of the drivers API. This class may be
   *         mutated in incompatible ways between any two releases of the driver.
   * @copyright 2012-2014, Allanbank Consulting, Inc., All Rights Reserved
   */
  public class AuthenticatingConnection extends AbstractProxyConnection {
  
      /** The name of the administration database. */
      public static final String ADMIN_DB_NAME = MongoClientConfiguration.ADMIN_DB_NAME;
  
      /** The logger for the authenticator. */
      public static final Log LOG = LogFactory
              .getLog(AuthenticatingConnection.class);
  
      /** Map of the authenticators. */
      private final Map<String, Authenticator> myAuthenticators;
  
      /** Set of the databases with authentication failures. */
      private final Map<String, MongoDbException> myFailures;
  
      /**
       * Creates a new AuthenticatingConnection.
       * 
       * @param connection
       *            The connection to ensure gets authenticated as needed.
       * @param config
       *            The MongoDB client configuration.
       */
      public AuthenticatingConnection(final Connection connection,
              final MongoClientConfiguration config) {
          super(connection);
  
          myAuthenticators = new ConcurrentHashMap<String, Authenticator>();
          myFailures = new ConcurrentHashMap<String, MongoDbException>();
  
          // With the advent of delegated credentials we must now authenticate
          // with all available credentials immediately.
          final Collection<Credential> credentials = config.getCredentials();
          for (final Credential credential : credentials) {
              final Authenticator authenticator = credential.authenticator();
  
              authenticator.startAuthentication(credential, connection);
  
              // Boo! MongoDB does not support concurrent authentication attempts.
              // Block here for the results if more than 1 credential. Boo!
              if (credentials.size() > 1) {
                  try {
                      if (!authenticator.result()) {
                          myFailures.put(credential.getDatabase(),
                                  new MongoDbAuthenticationException(
                                          "Authentication failed for the "
                                                  + credential.getDatabase()
                                                  + " database."));
                      }
                  }
                  catch (final MongoDbException error) {
                      myFailures.put(credential.getDatabase(), error);
                  }
             }
             else {
                 myAuthenticators.put(credential.getDatabase(), authenticator);
             }
         }
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Makes sure the connection is authenticated for the current database
      * before forwarding to the proxied connection.
      * </p>
      */
     @Override
     public void send(final Message message1, final Message message2,
             final ReplyCallback replyCallback) throws MongoDbException {
         ensureAuthenticated(message1);
         ensureAuthenticated(message2);
 
         super.send(message1, message2, replyCallback);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Makes sure the connection is authenticated for the current database
      * before forwarding to the proxied connection.
      * </p>
      */
     @Override
     public void send(final Message message, final ReplyCallback replyCallback)
             throws MongoDbException {
         ensureAuthenticated(message);
 
         super.send(message, replyCallback);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to return the socket information.
      * </p>
      */
     @Override
     public String toString() {
         return "Auth(" + getProxiedConnection() + ")";
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to give access to the proxied connections to tests.
      * </p>
      */
     @Override
     protected Connection getProxiedConnection() {
         final Connection proxied = super.getProxiedConnection();
 
         return proxied;
     }
 
     /**
      * Ensures the connection has either already authenticated with the server
      * or completes the authentication.
      * 
      * @param message
      *            The message to authenticate for.
      * @throws MongoDbAuthenticationException
      *             On a failure to authenticate with the MongDB server.
      */
     private void ensureAuthenticated(final Message message)
             throws MongoDbAuthenticationException {
         // Check the authentication results are done.
         if (!myAuthenticators.isEmpty()) {
             final Iterator<Map.Entry<String, Authenticator>> iter = myAuthenticators
                     .entrySet().iterator();
             while (iter.hasNext()) {
                 final Map.Entry<String, Authenticator> authenticator = iter
                         .next();
                 try {
                     if (!authenticator.getValue().result()) {
                         myFailures.put(authenticator.getKey(),
                                 new MongoDbAuthenticationException(
                                         "Authentication failed for the "
                                                 + authenticator.getKey()
                                                 + " database."));
                     }
                 }
                 catch (final MongoDbException error) {
                     // Just log the error here.
                     LOG.warn(error, "Authentication failed: []",
                             error.getMessage());
                     // Re-throw if our DB.
                     myFailures.put(authenticator.getKey(), error);
                 }
                 finally {
                     iter.remove();
                 }
             }
         }
 
         if (myFailures.containsKey(message.getDatabaseName())) {
             throw new MongoDbAuthenticationException(myFailures.get(message
                     .getDatabaseName()));
         }
     }
 }