//
// SwitchRMI  Framework
// Copyright (c) 2000-2002 by Michael J. Henderson & Associates.
//
// Michael Henderson
// http://switchrmi.sf.net
// mailto:mikehenderson@dunelm.org.uk
//
// This library is free software.
//
// You may redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License as published by the Free Software Foundation.
//
// Version 2.1 of the license should be included with this distribution in
// the file LICENSE, as well as License.html. If the license is not
// included with this distribution, you may find a copy at the FSF web
// site at 'www.gnu.org' or 'www.fsf.org', or you may write to the
// Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139 USA.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied waranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// $Id: RmiJavaObjectFactory.java,v 1.1 2002/11/11 22:19:48 mikehenderson Exp $
//
package com.mjh.switchrmi.jndi;

import com.mjh.switchrmi.*;
import com.mjh.util.*;

import java.lang.reflect.*;

import java.net.*;

import java.util.*;

import javax.naming.*;
import javax.naming.spi.*;

import org.apache.log4j.Logger;

public class RmiJavaObjectFactory
    extends RmiObjectFactoryBase
    implements ObjectFactory
{
    private static final Logger log = 
            Logger.getLogger(RmiJavaObjectFactory.class.getName());

    public RmiJavaObjectFactory()
    {
    }

    public Object getObjectInstance(Object obj, Name name, Context ctx, 
                                    Hashtable env)
                             throws Exception
    {
        try
        {
            if (log.isDebugEnabled())
            {
                log.debug("obj = " + obj);
                log.debug("name = " + name);
                log.debug("ctx = " + ctx);
                log.debug("env = " + env);
            }

            Reference ref = (Reference) obj;
            URL[] codebase = getCodebase(name, env);

            if (log.isDebugEnabled())
            {
                log.debug("codebase = " + codebase);
            }

            ClassLoader loader = getClass().getClassLoader();

            if (codebase != null)
            {
                loader = new URLClassLoader(codebase, loader);
            }

            Class clazz = loader.loadClass(getClassName(name, env));
            Object target = clazz.newInstance();
            Class[] interfaces = getInterfaces(name, env, loader);
            JavaInvocationHandler handler = 
                    new JavaInvocationHandler(interfaces, target);

            return Proxy.newProxyInstance(loader, interfaces, handler);
        }
        catch (Exception ex)
        {
            if (log.isDebugEnabled())
            {
                log.debug("Exception: ", ex);
            }

            throw ex;
        }
    }

    private class JavaInvocationHandler
        extends RmiInvocationHandlerBase
    {
        public Object service;
        private ClassLoader loader;

        public JavaInvocationHandler(Class[] interfaces, Object object)
        {
            super(interfaces);
            service = object;
        }

        public Object rmiInvoke(Object target, Method method, Object[] args)
                         throws Throwable
        {
            if (log.isDebugEnabled())
            {
                log.debug("service = " + service);
                log.debug("method = " + method.getName());
                log.debug("method.declaringClass = "
                          + method.getDeclaringClass().getName());
            }

            Object result = null;

            try
            {
                result = method.invoke(service, args);
            }
            catch (Exception ex)
            {
                if (log.isDebugEnabled())
                {
                    log.debug("Exception ", ex);
                }
            }

            return result;
        }
    }
}