/* (c) Copyright 2003 Caleigo AB, All rights reserved. 
    * 
    * This library 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 library 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 library; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   *  
   */
  
  package org.caleigo.toolkit.tunnel;
  
  
  import java.lang.reflect.*;
  import java.util.*;
  
  import org.caleigo.toolkit.log.*;
  
  /***
   *
   * @author  Mattias Hagstrand
   * @version 1.00
   * 
   *//* 
   *
   * WHEN        WHO               WHY & WHAT
   * -----------------------------------------------------------------------------
   * 2002-07-11  Mattias Hagstrand    Creation
   */
  public class DynamicRemoteProxy implements InvocationHandler, java.io.Serializable
  {
      // Data members ------------------------------------------------------------
      protected int mID;
      protected transient ProxyHandler mProxyHandler;
      protected transient boolean mIsLocalProxy;
      protected List mArgumentProxies;
      protected String[] mInterfaceClasses;
      
      // Constructors ------------------------------------------------------------
      DynamicRemoteProxy(int id, ProxyHandler proxyHandler, Class[] interfaceClasses)
      {
          mID = id;
          mIsLocalProxy = true;
          mProxyHandler = proxyHandler;
          mArgumentProxies = new ArrayList();
          mInterfaceClasses = new String[interfaceClasses.length];
          for (int i = 0; i < mInterfaceClasses.length; i++)
              mInterfaceClasses[i] = interfaceClasses[i].getName();
      }
      
      // InvocationHandler implementation ----------------------------------------
      public Object invoke(Object proxy, Method method, Object[] args)
          throws Throwable
      {
          Log.print(this, "invoke: " + method.getName());
          
          if (method.getName().compareTo("hashCode") == 0)
          {
              int hashCode = 0;
              for (int i = 0; i < mInterfaceClasses.length; i++)
                  hashCode += mInterfaceClasses[i].hashCode();
              return new Integer(hashCode);
          }
          if (method.getName().compareTo("equals") == 0)
          {
              boolean equals = true;
              for (int i = 0; i < mInterfaceClasses.length && equals; i++)
                  equals = mInterfaceClasses[i].equals(args[0]);
              return new Boolean(equals);
          }
          if (method.getName().compareTo("toString") == 0)
          {
              String interfaceClassNames = "";
              for (int i = 0; i < mInterfaceClasses.length; i++)
              {
                  interfaceClassNames = mInterfaceClasses[i];
                  if (i < mInterfaceClasses.length - 1)
                      interfaceClassNames += ", ";
              }
              return "DynamicRemoteProxy: " + interfaceClassNames;
          }
          
          // Convert all arguments that are IDistributables to proxies
          for (int i = 0; args != null && i < args.length; i++)
              if (args[i] instanceof IDistributable)
              {
                  Object argProxy = mProxyHandler.createProxy(args[i]);
                  mArgumentProxies.add(argProxy);
                  args[i] = argProxy;
              }
          
         // Send invocation message to server
         Log.print(this, "Sending message");
         Object returnMessage = mProxyHandler.getTunnel().ask(new DefaultProxyInvocationMessage(mInterfaceClasses, method.getName(), args, mID));
         Log.print(this, "Answer received");
         
         // Finish all argument proxies for this proxy
         Iterator argumentProxies = mArgumentProxies.iterator();
         while (argumentProxies.hasNext())
         {
             mProxyHandler.finishProxy(argumentProxies.next());
             argumentProxies.remove();
         }
         
         // Handle return message
         if (returnMessage instanceof IProxyReturnMessage)
         {
             Object returnValue = ((IProxyReturnMessage) returnMessage).getReturnValue();
             if (returnValue != null && Proxy.isProxyClass(returnValue.getClass()))
                 ((DynamicRemoteProxy) Proxy.getInvocationHandler(returnValue)).setProxyHandler(mProxyHandler);
             return returnValue;
         }
         else
             throw (Throwable) ((IProxyExceptionMessage) returnMessage).getExceptionClass().getConstructor(new Class[] {String.class}).newInstance(new Object[] {((IProxyExceptionMessage) returnMessage).getMessage()});
     }
     
     // Superclass overrides ----------------------------------------------------
     protected void finalize() throws Throwable
     {
         super.finalize();
         
         if (!mIsLocalProxy)
             mProxyHandler.getTunnel().send(new DefaultProxyCleanUpMessage(mID));
     }
     
     // Access methods ----------------------------------------------------------
     public void setProxyHandler(ProxyHandler proxyHandler)
     {
         mProxyHandler = proxyHandler;
     }
     
     public int getID()
     {
         return mID;
     }
     
     // Nested classes ----------------------------------------------------------
     interface IProxyInvocationMessage extends java.io.Serializable
     {
         // Methods -------------------------------------------------------------
         public String[] getInterfaceClassNames();
         public String getMethodName();
         public Object[] getArguments();
         public int getProxyID();
     }
     
     interface IProxyReturnMessage extends java.io.Serializable
     {
         public Object getReturnValue();
     }
     
     interface IProxyExceptionMessage extends java.io.Serializable
     {
         public Class getExceptionClass();
         public String getMessage();
     }
     
     interface IProxyCleanUpMessage extends java.io.Serializable
     {
         public int getProxyID();
     }
     
     protected static final class DefaultProxyInvocationMessage implements IProxyInvocationMessage
     {
         // Data members --------------------------------------------------------
         protected String[] mInterfaceClassNames;
         protected String mMethodName;
         protected Object[] mArguments;
         protected int mProxyID;
         
         // Constructors --------------------------------------------------------
         public DefaultProxyInvocationMessage(String[] interfaceClassNames, String methodName, Object[] arguments, int proxyID)
         {
             mInterfaceClassNames = interfaceClassNames;
             mMethodName = methodName;
             mArguments = arguments;
             mProxyID = proxyID;
         }
         
         // IProxyInvocationMessage implementation ------------------------------
         public String[] getInterfaceClassNames()
         {
             return mInterfaceClassNames;
         }
         
         public String getMethodName()
         {
             return mMethodName;
         }
         
         public Object[] getArguments()
         {
             return mArguments;
         }
         
         public int getProxyID()
         {
             return mProxyID;
         }
     }
     
     protected static final class DefaultProxyReturnMessage implements IProxyReturnMessage
     {
         // Data members --------------------------------------------------------
         protected Object mReturnValue;
         
         // Constructors --------------------------------------------------------
         public DefaultProxyReturnMessage(Object returnValue)
         {
             mReturnValue = returnValue;
         }
         
         // IProxyReturnMessage implementation ----------------------------------
         public Object getReturnValue()
         {
             return mReturnValue;
         }
     }
     
     protected static final class DefaultProxyExceptionMessage implements IProxyExceptionMessage
     {
         // Data members --------------------------------------------------------
         protected Class mExceptionClass;
         protected String mMessage;
         
         // Constructors --------------------------------------------------------
         public DefaultProxyExceptionMessage(Class exceptionClass, String message)
         {
             mExceptionClass = exceptionClass;
             mMessage = message;
         }
         
         // IProxyExceptionMessage implementation -------------------------------
         public Class getExceptionClass()
         {
             return mExceptionClass;
         }
         
         public String getMessage()
         {
             return mMessage;
         }
     }
     
     protected static final class DefaultProxyCleanUpMessage implements IProxyCleanUpMessage
     {
         // Data members --------------------------------------------------------
         protected int mID;
         
         // Constructors --------------------------------------------------------
         public DefaultProxyCleanUpMessage(int id)
         {
             mID = id;
         }
         
         // IProxyCleanUpMessage implementation ---------------------------------
         public int getProxyID()
         {
             return mID;
         }
     }
 }