/*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/

package org.jboss.remoting;

import org.jboss.logging.Logger;
import org.jboss.remoting.loading.ClassByteClassLoader;
import org.jboss.remoting.marshal.MarshallLoaderFactory;
import org.jboss.remoting.security.SSLSocketBuilder;
import org.jboss.remoting.serialization.SerializationStreamFactory;
import org.jboss.remoting.socketfactory.CreationListenerSocketFactory;
import org.jboss.remoting.socketfactory.SocketCreationListener;
import org.jboss.remoting.socketfactory.SocketFactoryWrapper;
import org.jboss.remoting.serialization.ClassLoaderUtility;
import org.jboss.remoting.callback.InvokerCallbackHandler;
import org.jboss.util.id.GUID;

import javax.net.SocketFactory;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.HashMap;
import java.util.Map;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;
import java.util.Set;

/**
 * AbstractInvoker is an abstract handler part that contains common methods between both
 * client and server.
 *
 * @author <a href="mailto:jhaynie@vocalocity.net">Jeff Haynie</a>
 * @author <a href="mailto:telrod@e2technologies.net">Tom Elrod</a>
 * @version $Revision: 2784 $
 */
public abstract class AbstractInvoker implements Invoker
{
   protected final static Logger log = Logger.getLogger(AbstractInvoker.class);
   protected ClassByteClassLoader classbyteloader;
   protected InvokerLocator locator;
   protected Map localServerLocators = new HashMap();
   protected String serializationType;
   protected Map configuration = new HashMap();
   protected SocketFactory socketFactory;

   // Indicates if the serverSocketFactory was generated internally.
   protected boolean socketFactoryCreatedFromSSLParameters;

   public AbstractInvoker(InvokerLocator locator)
   {
      this(locator, null);
   }

   public AbstractInvoker(InvokerLocator locator, Map configuration)
   {
	  try
	  {
	      this.classbyteloader = (ClassByteClassLoader)AccessController.doPrivileged( new PrivilegedExceptionAction()
	      {
	         public Object run() throws Exception
	         {
	        	 return new ClassByteClassLoader(this.getClass().getClassLoader());
	         }
	      });
	  }
	  catch (PrivilegedActionException e)
	  {
		  log.error(e.toString(), e);
		  throw new RuntimeException("Can't create a ClassLoader", e);
	  }
      this.locator = locator;

      if (configuration != null)
         this.configuration.putAll(configuration);

      if (locator.getParameters() != null)
         this.configuration.putAll(locator.getParameters());

      try
      {
         InvokerLocator loaderLocator = MarshallLoaderFactory.convertLocator(locator);
         if(loaderLocator != null)
         {
            classbyteloader.setClientInvoker(new Client(loaderLocator));
         }
      }
      catch(Exception e)
      {
         log.error("Could not create remote class loading for invoker.", e);
      }

      if(locator == null || locator.getParameters() == null)
      {
         this.setSerializationType(SerializationStreamFactory.JAVA);
      }
      else
      {
         this.setSerializationType(locator.findSerializationType());
      }
   }

   /**
    * return the locator this Invoker represents
    */
   public InvokerLocator getLocator()
   {
      return locator;
   }

   /**
    * Generates a listener id for the callbackhandler and callback server locator combination
    * @param sessionId
    * @param locator
    */
   public String addClientLocator(String sessionId, InvokerCallbackHandler callbackhandler, InvokerLocator locator)
   {
      String listenerId = null;
      synchronized(localServerLocators)
      {
         Collection holders = localServerLocators.values();
         Iterator itr = holders.iterator();
         while(itr.hasNext())
         {
            CallbackHandlerHolder holder = (CallbackHandlerHolder)itr.next();
            InvokerCallbackHandler holderhandler = holder.getHandler();
            boolean handlersEqual = holderhandler.equals(callbackhandler);
            InvokerLocator handlerLocator = holder.getLocator();
            boolean locatorsEqual = handlerLocator.equals(locator);
            if(handlersEqual && locatorsEqual)
            {
               // the entry already exists for this pair, so return null
               return null;
            }
         }

         // if got this far, the entry does not exist, so need to add it and create a listener id
         CallbackHandlerHolder holder = new CallbackHandlerHolder(callbackhandler, locator);
         listenerId = new GUID().toString();
         String key = listenerId;
         if (sessionId != null)
            key = sessionId + "+" + listenerId;
         localServerLocators.put(key, holder);
      }

      return listenerId;
   }

   /**
    * Gets the client locator.  This locator will be used by the server side
    * to make callbacks to the handler for this locator.
    */
   public InvokerLocator getClientLocator(String listenerId)
   {
      InvokerLocator locator = null;
      if(listenerId != null)
      {
         CallbackHandlerHolder holder = (CallbackHandlerHolder) localServerLocators.get(listenerId);
         if(holder != null)
         {
            locator = holder.getLocator();
         }
      }
      return locator;
   }

   public List getClientLocators(String sessionId, InvokerCallbackHandler handler)
   {
      List holderList = new ArrayList();
      if(handler != null)
      {
         synchronized(localServerLocators)
         {
            Set entries = localServerLocators.entrySet();
            Iterator itr = entries.iterator();
            while(itr.hasNext())
            {
               Map.Entry entry = (Map.Entry) itr.next();
               String listenerId = (String) entry.getKey();
               int index = listenerId.indexOf('+');
               String prefix = listenerId.substring(0, index);
               if (!sessionId.equals(prefix))
                  continue;
               if (index >= 0)
                  listenerId = listenerId.substring(index + 1);
               CallbackHandlerHolder holder = (CallbackHandlerHolder) entry.getValue();
               InvokerCallbackHandler holderHandler = holder.getHandler();
               if(holderHandler.equals(handler))
               {
                  CallbackLocatorHolder locatorHolder = new CallbackLocatorHolder(listenerId, holder.getLocator());
                  holderList.add(locatorHolder);
               }
            }
            // now remove holders
            if(holderList.size() > 0)
            {
               for(int x = 0; x < holderList.size(); x++)
               {
                  String listenerId = ((CallbackLocatorHolder)holderList.get(x)).getListenerId();
                  String key = sessionId + "+" + listenerId;
                  localServerLocators.remove(key);
               }
            }
         }
      }
         return holderList;
   }

   /**
    * set the classloader to use internally
    *
    * @param classloader
    */
   public synchronized void setClassLoader(ClassLoader classloader)
   {
	  try
	  {
	      this.classbyteloader = (ClassByteClassLoader)AccessController.doPrivileged( new PrivilegedExceptionAction()
	      {
	         public Object run() throws Exception
	         {
	        	 return new ClassByteClassLoader(this.getClass().getClassLoader());
	         }
	      });
	  }
	  catch (PrivilegedActionException e)
	  {
		  log.error(e.toString(), e);
		  throw new RuntimeException("Can't create a ClassLoader", e);
	  }
   }

   public synchronized ClassLoader getClassLoader()
   {
      return classbyteloader;
   }

   public String getSerializationType()
   {
      return serializationType;
   }

   public void setSerializationType(String serializationType)
   {
      this.serializationType = serializationType;
   }

   public SocketFactory getSocketFactory()
   {
      return socketFactory;
   }

   public void setSocketFactory(SocketFactory socketFactory)
   {
      this.socketFactory = socketFactory;
   }

   public boolean isSocketFactoryCreatedFromSSLParameters()
   {
      return socketFactoryCreatedFromSSLParameters;
   }

   /**
    * If any configuration parameters relate to the construction of a SSLSocketBuilder, create one.
    */
   protected SocketFactory createSocketFactory(Map configuration)
   {
      if (configuration == null)
         return null;

      if (socketFactory != null)
         return socketFactory;

      SocketFactory factory = null;

      Object obj = configuration.get(Remoting.CUSTOM_SOCKET_FACTORY);
      if (obj != null)
      {
         if (obj instanceof SocketFactory)
         {
            factory = (SocketFactory) obj;
         }
         else
         {
            throw new RuntimeException("Can not set custom socket factory (" + obj + ") as is not of type javax.net.SocketFactory");
         }
      }

      if(factory == null)
      {
         String socketFactoryString = (String)configuration.get(Remoting.SOCKET_FACTORY_NAME);
         if(socketFactoryString != null && socketFactoryString.length() > 0)
         {
            try
            {
               Class cl = ClassLoaderUtility.loadClass(socketFactoryString,  getClass());

               Constructor socketFactoryConstructor = null;
               socketFactoryConstructor = cl.getConstructor(new Class[]{});
               factory = (SocketFactory)socketFactoryConstructor.newInstance(new Object[] {});
               log.trace("SocketFactory (" + socketFactoryString + ") loaded");
            }
            catch(Exception e)
            {
               log.debug("Could not create socket factory by classname (" + socketFactoryString + ").  Error message: " + e.getMessage());
            }
         }
      }

      if (factory == null && needsCustomSSLConfiguration(configuration))
      {
         try
         {
            SSLSocketBuilder socketBuilder = new SSLSocketBuilder(configuration);
            socketBuilder.setUseSSLSocketFactory( false );
            factory = socketBuilder.createSSLSocketFactory();
            socketFactoryCreatedFromSSLParameters = true;
         }
         catch (IOException e)
         {
            throw new RuntimeException("Unable to create customized SSL socket factory", e);
         }
      }

      return wrapSocketFactory(factory, configuration);
   }
   
   
   static public SocketFactory wrapSocketFactory(SocketFactory socketFactory, Map config)
   {
      if (config == null)
         return socketFactory;
      
      Object o = config.get(Remoting.SOCKET_CREATION_CLIENT_LISTENER);
      
      if (o == null)
         return socketFactory;
      
      if (o instanceof SocketCreationListener)
      {
         SocketCreationListener listener = (SocketCreationListener) o;
         return new CreationListenerSocketFactory(socketFactory, listener);
      }
      else if (o instanceof String)
      {
         try
         {
            Class c = ClassLoaderUtility.loadClass((String) o, AbstractInvoker.class);
            SocketCreationListener listener = (SocketCreationListener) c.newInstance();
            return new CreationListenerSocketFactory(socketFactory, listener);
         }
         catch (Exception e)
         {
            log.error("unable to instantiate class: " + o, e);
            return socketFactory;
         }
      }
      else
      {
         log.error("unrecognized type for socket creation client listener: " + o);
         return socketFactory;
      }
   }
   
   
   static public boolean isCompleteSocketFactory(SocketFactory sf)
   {
      if (sf != null)
      {
         if (!(sf instanceof SocketFactoryWrapper) ||
             ((SocketFactoryWrapper)sf).getSocketFactory() != null)
            return true;
      }
      return false;
   }


   public static boolean needsCustomSSLConfiguration(Map configuration)
   {
      if (configuration.get(SSLSocketBuilder.REMOTING_KEY_ALIAS) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_CLIENT_AUTH_MODE) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_SERVER_AUTH_MODE) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_SSL_PROTOCOL) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_SSL_PROVIDER_NAME) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_SERVER_SOCKET_USE_CLIENT_MODE) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_SOCKET_USE_CLIENT_MODE) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_KEY_PASSWORD) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_KEY_STORE_ALGORITHM) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_KEY_STORE_FILE_PATH) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_KEY_STORE_PASSWORD) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_KEY_STORE_TYPE) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_TRUST_STORE_ALGORITHM) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_TRUST_STORE_FILE_PATH) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_TRUST_STORE_PASSWORD) != null ||
            configuration.get(SSLSocketBuilder.REMOTING_TRUST_STORE_TYPE) != null
      )
         return true;
      else
         return false;
   }

   private class CallbackHandlerHolder
   {
      private InvokerCallbackHandler handler;
      private InvokerLocator locator;

      private CallbackHandlerHolder(InvokerCallbackHandler handler, InvokerLocator locator)
      {
         this.handler = handler;
         this.locator = locator;
      }

      public InvokerCallbackHandler getHandler()
      {
         return handler;
      }

      public InvokerLocator getLocator()
      {
         return locator;
      }
   }

   public class CallbackLocatorHolder
   {
      private InvokerLocator locator;
      private String listenerId;

      public CallbackLocatorHolder(String listenerId, InvokerLocator locator)
      {
         this.listenerId = listenerId;
         this.locator = locator;
      }

      public String getListenerId()
      {
         return listenerId;
      }

      public InvokerLocator getLocator()
      {
         return locator;
      }
   }
}
