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

import com.mjh.switchrmi.jndi.*;

import java.lang.reflect.*;

import java.util.*;

import javax.naming.*;

import org.apache.log4j.Logger;

public class RmiHandler
{
    private static HashMap applicationScope = new HashMap();
    private static final Logger log = 
            Logger.getLogger(RmiHandler.class.getName());
    private RmiRequest request;
    private RmiResponse response;

    public RmiHandler()
    {
    }

    public Object clientInvoke(Method method, Object[] args, RmiContext context)
                        throws Exception
    {
        Object result = null;
        RmiProtocol protocol = context.getProtocol();

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

        RmiTransport transport = context.getTransport();

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

        request = protocol.createRequest(method, args, context);
        protocol.writeRequest(request, context);

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

        transport.send(context);
        transport.recv(context);
        response = protocol.readResponse(context);
        result = response.getObject();

        if (result instanceof Throwable)
        {
            throw (Exception) result;
        }

        return result;
    }

    private Object findTarget(RmiContext context, RmiSessionScopeAccess session)
                       throws Exception
    {
        Object result = null;
        Context ctx = (Context) context.lookup("/switchrmi/service/object");

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

        if (ctx != null)
        {
            String name = context.getObjectName();

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

            ObjectReferenceable ref = 
                    (ObjectReferenceable) ctx.getEnvironment().get(name);

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

            if (ref != null)
            {
                String scope = ref.getScope();

                if (scope.equals(RmiScope.APPLICATION))
                {
                    result = applicationScope.get(name);

                    if (result == null)
                    {
                        result = ctx.lookup(name);
                        applicationScope.put(name, result);
                    }
                }
                else if (scope.equals(RmiScope.SESSION))
                {
                    result = session.get(name);

                    if (result == null)
                    {
                        result = ctx.lookup(name);
                        session.put(name, result);
                    }
                }
                else
                {
                    result = ctx.lookup(name);
                }

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

        return result;
    }

    public void serviceInvoke(RmiContext context, RmiSessionScopeAccess session)
    {
        RmiProtocol protocol = null;
        RmiTransport transport = null;

        try
        {
            Object target = findTarget(context, session);

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

            context.setTarget(target);
            protocol = context.getProtocol();
            transport = context.getTransport();

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

            transport.recv(context);
            request = protocol.readRequest(context);

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

            Method method = request.getMethod();

            if (log.isDebugEnabled())
            {
                log.debug("method.getName() = " + method.getName());
                log.debug("method.getDeclaringClass().getName() = "
                          + method.getDeclaringClass().getName());
                log.debug("target = " + target.getClass().getName());
            }

            Object result = method.invoke(target, request.getArguments());

            response = protocol.createResponse(request, result, context);
        }
        catch (InvocationTargetException ex)
        {
            response = protocol.createResponse(request, ex.getTargetException(), 
                                               context);
        }
        catch (UndeclaredThrowableException ex)
        {
            response = protocol.createResponse(request, 
                                               ex.getUndeclaredThrowable(), 
                                               context);
        }
        catch (Exception ex)
        {
            if (log.isDebugEnabled())
            {
                ex.printStackTrace();
            }

            response = protocol.createResponse(request, ex, context);
        }
        finally
        {
            try
            {
                protocol.writeResponse(response, context);
                transport.send(context);
            }
            catch (Exception ex)
            {
                log.debug("Unable to send a response", ex);
            }
        }
    }

    public void reset()
    {
        response = null;
        request = null;
    }

    public void handleFault(Exception ex, RmiContext context)
                     throws Exception
    {
        if (response == null)
        {
            RmiProtocol protocol = context.getProtocol();

            response = protocol.createResponse(request, ex, context);
            protocol.writeResponse(response, context);
        }
    }
}