/*
 * Copyright 1999 by dreamBean Software,
 * All rights reserved.
 */
package smartproxy.proxies;

import java.io.IOException;
import java.lang.reflect.Proxy;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.NoSuchObjectException;
import java.rmi.ServerException;

import net.jini.core.lookup.ServiceTemplate;
import net.jini.core.lookup.ServiceItem;
import net.jini.lookup.LookupCache;
import net.jini.lookup.ServiceDiscoveryManager;
import net.jini.lookup.ServiceDiscoveryListener;
import net.jini.lookup.ServiceDiscoveryEvent;

/**
 *    This is a smart proxy wrapper that looks up the object from a Jini LUS.
 *     
 *    Note that it is not tightly bound to the remote object interface,
 *    and can therefore be reused with any remote object(!)
 *
 *   @author Rickard 謆erg (rickard@dreambean.com)
 *   @version $Revision:$
 */
public class JiniServiceProxy
   implements InvocationHandler, java.io.Serializable, LinkedProxy
{
   Object next;
   ServiceTemplate template;
   
   transient LookupCache serviceCache;
   transient ServiceDiscoveryManager sdm;

   // Constructors --------------------------------------------------
   public JiniServiceProxy(Object next, ServiceTemplate template)
   {
      this.next = next;
      this.template = template;
      
   }
   
   // Public --------------------------------------------------------
   public Object invoke(Object proxy,
                        Method method,
                        Object[] args)
      throws Throwable
   {
      synchronized(this)
      {
         validate();
         try
         {
            return method.invoke(next, args);
         } catch (InvocationTargetException e)
         {
            try
            {
               throw e.getTargetException();
            } catch (RemoteException ex)
            {
               next = null;
               throw ex;
            }
         }
      }
   }
   
   public Object getNext()
   {
      return next;
   }
   
   public void setNext(Object next)
   {
      this.next = next;
   }
   
   protected void validate()
      throws RemoteException
   {
      if (sdm == null)
      {
         try
         {
            // Create Jini service discovery manager
            sdm = new ServiceDiscoveryManager(null, null);
      
            // Initialize service lookup
            serviceCache = sdm.createLookupCache(template, null, new ServiceDiscoveryListenerHelper());
            System.out.println("Jini Lookup started");
         } catch (IOException e)
         {
            throw new ServerException("Could not start service discovery", e);
         }
      }
      
      // Get from cache
      ServiceItem si = serviceCache.lookup(null);
      if (si == null)
      {
         // We might not have received the events just yet; try explicit lookup
         si = sdm.lookup(template, null);
         if (si == null)
         {
            // Check if we already have a reference
            if (next == null) 
            {
               // No service available
               throw new NoSuchObjectException("Service unavailable");
            } else
            {
               // Done; use the old one
               return;
            }
         } else
         {
            // Service found
            next = si.service;
         }
      } else
      {
         next = si.service;
      }

      // Peel off proxies until we reach the Jini proxy
      while (Proxy.isProxyClass(next.getClass()) && 
             Proxy.getInvocationHandler(next) instanceof LinkedProxy &&
             !(Proxy.getInvocationHandler(next) instanceof JiniServiceProxy))
      {
         next = ((LinkedProxy)Proxy.getInvocationHandler(next)).getNext();
      }
      // next is now the Jini proxy - get the next one
      next = ((LinkedProxy)Proxy.getInvocationHandler(next)).getNext();
   }
   
   protected void finalize()
      throws Throwable
   {
      serviceCache.terminate();
   }
   
   class ServiceDiscoveryListenerHelper
      implements ServiceDiscoveryListener 
   {
      public void serviceAdded(ServiceDiscoveryEvent event)
      {
         System.out.println("Service added");
      }
      
      public void serviceRemoved(ServiceDiscoveryEvent event)
      {
         System.out.println("Service removed");
      }
      
      public void serviceChanged(ServiceDiscoveryEvent event)
      {
         // Ignore
         System.out.println("Service changed");
      }
   }
}