//
// 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: RmiScriptObjectFactory.java,v 1.1 2002/11/11 22:19:48 mikehenderson Exp $
//
package com.mjh.switchrmi.jndi;

import com.ibm.bsf.*;
import com.mjh.switchrmi.*;

import java.io.*;

import java.lang.reflect.*;

import java.net.*;

import java.util.*;

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

import org.apache.log4j.Logger;

public class RmiScriptObjectFactory
    extends RmiObjectFactoryBase
    implements ObjectFactory
{
    private static final Logger log = 
            Logger.getLogger(RmiScriptObjectFactory.class.getName());
    private String source;
    private String language;

    public RmiScriptObjectFactory()
    {
    }

    public Object getObjectInstance(Object obj, Name name, Context ctx, 
                                    Hashtable env)
                             throws Exception
    {
        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);

        log.debug("codebase = " + codebase);

        ClassLoader loader = getClass().getClassLoader();

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

        //load interfaces rom loader
        Class[] interfaces = getInterfaces(name, env, loader);
        String source = (String) getTypeInfoValue("source", name, env);
        String language = (String) getTypeInfoValue("language", name, env);

        log.debug("loader = " + loader);
        log.debug("source = " + source);
        log.debug("language = " + language);

        ScriptInvocationHandler handler = 
                new ScriptInvocationHandler(interfaces, source, language, 
                                            loader);

        return Proxy.newProxyInstance(loader, interfaces, handler);
    }

    private class ScriptInvocationHandler
        extends RmiInvocationHandlerBase
    {
        private String script;
        private String language;
        private ClassLoader loader;
        private BSFManager manager;
        private BSFEngine engine;

        public ScriptInvocationHandler(Class[] interfaces, String script, 
                                       String language, ClassLoader cl)
        {
            super(interfaces);
            this.script = script;
            this.language = language;
            this.loader = cl;

            if (log.isDebugEnabled())
            {
                log.debug("script = " + script);
                log.debug("language = [" + language + "]");
            }
        }

        public Object rmiInvoke(Object target, Method method, Object[] args)
                         throws Throwable
        {
            if (manager == null)
            {
                init();
            }

            String scriptMethodName = 
                    convertJavaMethodNameToScriptMethodName(method.getName());
            Object result = engine.call(null, scriptMethodName, args);

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

            return convertResultToMethodReturnType(result, 
                                                   method.getReturnType());
        }

        private void init() throws Exception
        {
            boolean debug = log.isDebugEnabled();

            language = determineScriptLanguage();

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

            manager = new BSFManager();

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

            engine = manager.loadScriptingEngine(language);

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

            manager.exec(language, script, -1, -1, readScript());
        }

        private String readScript()
                           throws Exception
        {
            boolean debug = log.isDebugEnabled();
            StringBuffer sb = new StringBuffer();

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

            java.net.URL url = loader.getResource(script);

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

            InputStream in = loader.getResourceAsStream(script);

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

            BufferedReader reader = 
                    new BufferedReader(new InputStreamReader(in));
            String line = reader.readLine();

            while (line != null)
            {
                sb.append(line);
                sb.append("\n");
                line = reader.readLine();
            }

            String string = sb.toString();

            if (debug)
            {
                log.debug("script text = " + string);
            }

            return string;
        }

        private String determineScriptLanguage()
            throws Exception
        {
            if ((language == null) || (language.length() == 0))
            {
                language = manager.getLangFromFilename(script);
            }

            return language;
        }

        private String convertJavaMethodNameToScriptMethodName(String javaName)
        {
            return javaName;
        }

        private Object convertResultToMethodReturnType(Object value, 
                                                       Class targetType)
        {
            if (targetType == int.class)
            {
                value = new Integer(((Number) value).intValue());
            }

            return value;
        }
    }
}