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

import java.io.Serializable;

import java.lang.reflect.Method;

import java.util.*;

import org.apache.log4j.*;

public class RmiRequestImpl implements Serializable, RmiRequest
{
    private static final Logger log = 
            Logger.getLogger(RmiRequestImpl.class.getName());
    private static HashMap primitives = new HashMap();

    static
    {
        primitives.put("char", char.class);
        primitives.put("boolean", boolean.class);
        primitives.put("byte", byte.class);
        primitives.put("short", short.class);
        primitives.put("int", int.class);
        primitives.put("long", long.class);
        primitives.put("float", float.class);
        primitives.put("double", double.class);
    }

    /**
     *
     *
     */
    private static HashMap signatures = new HashMap();
    private String encodedMethodSignature;
    private Object[] args;
    public transient String interfaceName;
    private transient String methodName;
    private transient Class[] argumentTypes;
    private transient String returnType;
    private transient String[] stringArgumentTypes;

    public RmiRequestImpl()
    {
        interfaceName = "java.lang.Object";
    }

    public RmiRequestImpl(Method method, Object[] mArgs)
    {
        encodedMethodSignature = encodeSignature(method);
        args = mArgs;
    }

    /**
     *
     *
     */
    private static synchronized String lookupMethodSignature(Method m)
    {
        return (String) signatures.get(m);
    }

    /**
     *
     *
     */
    private static synchronized void storeMethodSignature(Method m, 
                                                          String signature)
    {
        signatures.put(m, signature);
    }

    /**
     *
     *
     */
    public void setEncodedMethodSignature(String encoded)
    {
        encodedMethodSignature = encoded;
        decodeSignature(encoded);
    }

    public String getEncodedMethodSignature()
    {
        return encodedMethodSignature;
    }

    public void setArguments(Object[] args)
    {
        this.args = args;
    }

    public Object[] getArguments()
    {
        return args;
    }

    public String getInterfaceName()
    {
        if (interfaceName == null)
        {
            decodeSignature();
        }

        return interfaceName;
    }

    public String getReturnType()
    {
        if (returnType == null)
        {
            decodeSignature();
        }

        return returnType;
    }

    public void setReturnType(String string)
    {
        if (methodName == null)
        {
            decodeSignature();
        }

        returnType = string;
    }

    public String getMethodName()
    {
        if (methodName == null)
        {
            decodeSignature();
        }

        return methodName;
    }

    public Class[] getArgumentTypes()
    {
        if (argumentTypes == null)
        {
            decodeSignature();
        }

        return argumentTypes;
    }

    public String[] getStringArgumentTypes()
    {
        if (stringArgumentTypes == null)
        {
            decodeSignature();
        }

        return stringArgumentTypes;
    }

    public Method getMethod()
    {
        Method method = null;

        try
        {
            log.debug("interfaceName = " + getInterfaceName());

            Class interfaze = Class.forName(getInterfaceName());

            log.debug("interfaze = " + interfaze);
            log.debug("methodName = " + getMethodName());
            log.debug("argumentTypes = " + getArgumentTypes());
            method = interfaze.getDeclaredMethod(getMethodName(), 
                                                 getArgumentTypes());
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
            log.debug(ex);
        }

        return method;
    }

    private void debug(String msg)
    {
        log.debug(msg);
    }

    /**
     *
     *
     */
    protected String encodeSignature(Method method)
    {
        String signature = lookupMethodSignature(method);

        if (signature == null)
        {
            Class declaringClass = method.getDeclaringClass();
            Class returnType = method.getReturnType();
            Class[] methodArgTypes = method.getParameterTypes();

            StringBuffer sb = new StringBuffer(declaringClass.getName());

            sb.append(":");
            sb.append(returnType.getName());
            sb.append(":");
            sb.append(method.getName());
            sb.append(":");

            int i = 0;

            if (methodArgTypes.length > 0)
            {
                for (; i < (methodArgTypes.length - 1); i++)
                {
                    sb.append(methodArgTypes[i].getName());
                    sb.append(":");
                }

                sb.append(methodArgTypes[i].getName());
            }

            signature = sb.toString();
            storeMethodSignature(method, signature);
        }

        return signature;
    }

    private void decodeSignature()
    {
        decodeSignature(encodedMethodSignature);
    }

    /**
     *
     *
     */
    protected void decodeSignature(String encoded)
    {
        try
        {
            debug("decode: encoded = " + encoded);

            StringTokenizer tokenizer = new StringTokenizer(encoded, ":");

            interfaceName = tokenizer.nextToken();
            debug("decode: interfaceName = " + interfaceName);
            returnType = tokenizer.nextToken();
            debug("decode: returnType = " + returnType);
            methodName = tokenizer.nextToken();
            debug("decode: methodName = " + methodName);

            if (tokenizer.hasMoreTokens())
            {
                ArrayList list = new ArrayList();

                while (tokenizer.hasMoreTokens())
                {
                    list.add(tokenizer.nextToken());
                }

                Object[] array = list.toArray();

                stringArgumentTypes = new String[array.length];
                argumentTypes = new Class[array.length];

                for (int i = 0; i < array.length; i++)
                {
                    stringArgumentTypes[i] = (String) array[i];
                    argumentTypes[i] = (Class) primitives.get(array[i]);

                    if (argumentTypes[i] == null)
                    {
                        argumentTypes[i] = Class.forName(stringArgumentTypes[i]);
                    }

                    debug("decode: argumentTypes[i] = " + argumentTypes[i]);
                }
            }
        }
        catch (Exception ex)
        {
            log.debug("Exception", ex);
        }
    }
}