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

import com.mjh.dom.*;
import com.mjh.switchrmi.*;

import java.io.*;

import java.lang.reflect.*;

import java.net.*;

import java.util.*;

import javax.naming.*;

import javax.xml.parsers.*;
import javax.xml.transform.*;

import org.apache.log4j.Logger;
import org.w3c.dom.*;

public class RmiConfiguration
{
    public static final String SWITCHRMI_JNDI_INITIAL_URL = 
            "switchrmi.jndi.initial.url";
    private static final Logger log = 
            Logger.getLogger(RmiConfiguration.class.getName());
    private final static String FILE_SUFFIX = ".xml";
    private final static String ROOT_TAG = "switchrmi";
    private final static String SERVICE_TAG = "service";
    private final static String CLIENT_TAG = "client";
    private final static String PROTOCOL_TAG = "protocol";
    private final static String TRANSPORT_TAG = "transport";
    private final static String CODEBASE_TAG = "codebase";
    private final static String LIBRARY_TAG = "lib";
    private final static String OBJECT_TAG = "object";
    private final static String REMOTE_TAG = "remote";
    private final static String DESCRIPTION_TAG = "description";
    private final static String JAVA_TAG = "java";
    private final static String SCRIPT_TAG = "script";
    private final static String PROXY_TAG = "proxy";
    private final static String INTERFACE_TAG = "interface";
    private final static String NAME_ATTR = "name";
    private final static String HANDLER_ATTR = "handler";
    private final static String SCOPE_ATTR = "scope";
    private final static String VALUE_ATTR = "value";
    private final static String CLASS_ATTR = "class";
    private final static String SOURCE_ATTR = "source";
    private final static String LANG_ATTR = "language";
    private final static String URL_ATTR = "url";
    private final static String PROTOCOL_ATTR = "protocol";
    private final static String DEFAULT_RESOURCE_NAME = 
            "/com/mjh/switchrmi/RmiConfiguration.xml";
    private HashMap parsers = new HashMap();
    private Context jndiContext;

    public RmiConfiguration(Context ctx)
                     throws Exception
    {
        init();
        this.jndiContext = ctx;
        parseResource(DEFAULT_RESOURCE_NAME);
    }

    public RmiConfiguration(Context ctx, String resourceUrl)
                     throws Exception
    {
        if (log.isDebugEnabled())
        {
            log.debug("2 args constructor resourceUrl  = " + resourceUrl);
        }

        this.jndiContext = ctx;
        init();
        parseResource(DEFAULT_RESOURCE_NAME);

        if (resourceUrl != null)
        {
            parseUrl(new URL(resourceUrl));
        }
    }

    private void init()
    {
        parsers.put(ROOT_TAG, new RootParser(ROOT_TAG));
        parsers.put(SERVICE_TAG, new ServiceParser(SERVICE_TAG));
        parsers.put(CLIENT_TAG, new ClientParser(CLIENT_TAG));

        parsers.put(PROTOCOL_TAG, new TypeParser(PROTOCOL_TAG));
        parsers.put(TRANSPORT_TAG, new TypeParser(TRANSPORT_TAG));

        parsers.put(OBJECT_TAG, new ObjectParser(OBJECT_TAG));
        parsers.put(REMOTE_TAG, new RemoteParser(REMOTE_TAG));
        parsers.put(CODEBASE_TAG, new CodebaseParser(CODEBASE_TAG));
        parsers.put(LIBRARY_TAG, new LibraryParser(LIBRARY_TAG));
        parsers.put(JAVA_TAG, new JavaClassParser(JAVA_TAG));
        parsers.put(SCRIPT_TAG, new ScriptParser(SCRIPT_TAG));
        parsers.put(PROXY_TAG, new ObjectParser(PROXY_TAG));
        parsers.put(INTERFACE_TAG, new InterfaceParser(INTERFACE_TAG));
        parsers.put(DESCRIPTION_TAG, new DescriptionParser(DESCRIPTION_TAG));
    }

    private void parseResource(String resourceName)
                        throws Exception
    {
        URL resourceUrl = RmiConfiguration.class.getResource(resourceName);

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

        parseUrl(resourceUrl);
    }

    private void parseUrl(URL url)
                   throws Exception
    {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document doc = (Document) builder.parse(url.toString());

        parse(doc);
    }

    private void parse(Document document)
                throws Exception
    {
        try
        {
            Element root = document.getDocumentElement();
            TagParser parser = (TagParser) parsers.get(root.getTagName());

            parser.parse(root, jndiContext);
        }
        catch (Exception ex)
        {
            if (log.isDebugEnabled())
            {
                log.debug(ex);
            }

            ex.printStackTrace();
            throw ex;
        }
    }

    private TagParser getParser(String tagName)
    {
        return (TagParser) parsers.get(tagName);
    }

    abstract class TagParser
    {
        String tagName;

        public TagParser(String string)
        {
            tagName = string;
        }

        public void parse(NodeList list, Object object)
                   throws Exception
        {
            int length = list.getLength();

            for (int i = 0; i < length; i++)
            {
                parse((Element) list.item(i), object);
            }
        }

        public abstract void parse(Element element, Object object)
                            throws Exception;

        public void parseChildElements(Element element, Object object)
        {
            try
            {
                NodeList children = DomUtil.getChildElements(element);
                int length = children.getLength();

                for (int i = 0; i < length; i++)
                {
                    Element child = (Element) children.item(i);

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

                    getParser(child.getTagName()).parse(child, object);
                }
            }
            catch (Exception ex)
            {
                if (log.isDebugEnabled())
                {
                    log.debug("Exception ", ex);
                }
            }
        }

        protected Context getSubcontext(Context ctx, String name)
            throws Exception
        {
            Context subctx = null;

            try
            {
                subctx = ctx.createSubcontext(name);
            }
            catch (NameAlreadyBoundException ex)
            {
                subctx = (Context) ((JndiContextImpl) ctx)._lookup(name);
            }

            return subctx;
        }
    }

    class RootParser extends TagParser
    {
        public RootParser(String tag)
        {
            super(tag);
        }

        public void parse(Element element, Object object)
                   throws Exception
        {
            Context ctx = (Context) object;

            ctx = getSubcontext(ctx, tagName);
            parseChildElements(element, ctx);
        }
    }

    class ServiceParser extends TagParser
    {
        public ServiceParser(String tagName)
        {
            super(tagName);
        }

        public void parse(Element element, Object object)
                   throws Exception
        {
            Context ctx = (Context) object;

            if (log.isDebugEnabled())
            {
                log.debug("ServiceParser.parse(), tagName = " + tagName);
            }

            ctx = getSubcontext(ctx, tagName);

            parseChildElements(element, ctx);
        }
    }

    class ClientParser extends ServiceParser
    {
        public ClientParser(String tagName)
        {
            super(tagName);
        }
    }

    class TypeParser extends TagParser
    {
        Class typeClazz;

        public TypeParser(String string)
        {
            super(string);
        }

        public void parse(Element element, Object object)
                   throws Exception
        {
            boolean debug = log.isDebugEnabled();

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

            String name = element.getAttribute(NAME_ATTR);
            String className = element.getAttribute(CLASS_ATTR);

            try
            {
                GenericReferenceable ref = new GenericReferenceable(className);

                parseChildElements(element, ref);

                if (debug)
                {
                    log.debug("-------------------------------");
                }

                Context ctx = (Context) object;

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

                ctx = getSubcontext(ctx, tagName);

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

                ctx.rebind(name, ref);

                if (debug)
                {
                    log.debug("ctx = " + ctx);
                    log.debug("ref = " + ref);
                    log.debug("-------------------------------");
                }
            }
            catch (Exception ex)
            {
                if (debug)
                {
                    log.debug(ex);
                }

                throw ex;
            }
        }
    }

    class CodebaseParser extends TagParser
    {
        public CodebaseParser(String tag)
        {
            super(tag);
        }

        public void parse(Element element, Object object)
                   throws Exception
        {
            if (log.isDebugEnabled())
            {
                log.debug("element = " + element.toString());
            }

            GenericReferenceable ref = (GenericReferenceable) object;

            ref.setCodebase(element.getAttribute(URL_ATTR));
        }
    }

    class LibraryParser extends TagParser
    {
        public LibraryParser(String tag)
        {
            super(tag);
        }

        public void parse(Element element, Object object)
                   throws Exception
        {
            if (log.isDebugEnabled())
            {
                log.debug("element = " + element.toString());
            }

            GenericReferenceable ref = (GenericReferenceable) object;

            ref.addLibrary(element.getAttribute(NAME_ATTR));
        }
    }

    class DescriptionParser extends TagParser
    {
        public DescriptionParser(String tag)
        {
            super(tag);
        }

        public void parse(Element element, Object object)
                   throws Exception
        {
            if (log.isDebugEnabled())
            {
                log.debug("element = " + element.toString());
            }

            Text text = (Text) element.getFirstChild();
            GenericReferenceable ref = (GenericReferenceable) object;

            ref.setDescription(text.getData());
        }
    }

    class ObjectParser extends TagParser
    {
        public ObjectParser(String tag)
        {
            super(tag);
        }

        public void parse(Element element, Object object)
                   throws Exception
        {
            log.debug("element = " + element.toString());

            try
            {
                String name = element.getAttribute(NAME_ATTR);
                String scope = element.getAttribute(SCOPE_ATTR);
                ObjectReferenceable ref = new ObjectReferenceable();

                ref.setName(name);
                ref.setScope(scope);
                parseChildElements(element, ref);

                Context ctx = (Context) object;

                ctx = getSubcontext(ctx, tagName);
                ctx.rebind(name, ref);
                ctx.addToEnvironment(name, ref);

                if (log.isDebugEnabled())
                {
                    log.debug("ref = " + ref);
                    log.debug("ctx = " + ctx);
                }
            }
            catch (Exception ex)
            {
                if (log.isDebugEnabled())
                {
                    log.debug("Exception ", ex);
                }

                throw ex;
            }
        }
    }

    class InterfaceParser extends TagParser
    {
        public InterfaceParser(String tag)
        {
            super(tag);
        }

        public void parse(Element element, Object object)
                   throws Exception
        {
            if (log.isDebugEnabled())
            {
                log.debug("element = " + element.toString());
            }

            ObjectReferenceable ref = (ObjectReferenceable) object;

            ref.addInterface(element.getAttribute(CLASS_ATTR));
        }
    }

    class JavaClassParser extends TagParser
    {
        public JavaClassParser(String tag)
        {
            super(tag);
        }

        public void parse(Element element, Object object)
                   throws Exception
        {
            if (log.isDebugEnabled())
            {
                log.debug("element = " + element.toString());
            }

            ObjectReferenceable ref = (ObjectReferenceable) object;
            String className = element.getAttribute(CLASS_ATTR);

            ref.setClassName(className);
            ref.setType(tagName);

            Map map = new HashMap();

            map.put(CLASS_ATTR, className);
            ref.setTypeInfo(map);
        }
    }

    class ScriptParser extends TagParser
    {
        public ScriptParser(String tag)
        {
            super(tag);
        }

        public void parse(Element element, Object object)
                   throws Exception
        {
            if (log.isDebugEnabled())
            {
                log.debug("element = " + element.toString());
            }

            ObjectReferenceable ref = (ObjectReferenceable) object;
            String source = element.getAttribute(SOURCE_ATTR);
            String language = element.getAttribute(LANG_ATTR);

            ref.setType(tagName);

            Map map = new HashMap();

            map.put(SOURCE_ATTR, source);
            map.put(LANG_ATTR, language);

            ref.setTypeInfo(map);
        }
    }

    class RemoteParser extends TagParser
    {
        public RemoteParser(String tag)
        {
            super(tag);
        }

        public void parse(Element element, Object object)
                   throws Exception
        {
            if (log.isDebugEnabled())
            {
                log.debug("element = " + element.toString());
            }

            ObjectReferenceable ref = (ObjectReferenceable) object;

            parseChildElements(element, ref);

            String url = element.getAttribute(URL_ATTR);
            String protocol = element.getAttribute(PROTOCOL_ATTR);

            ref.setType(tagName);

            Map map = new HashMap();

            map.put(URL_ATTR, url);
            map.put(PROTOCOL_ATTR, protocol);

            ref.setTypeInfo(map);
        }
    }
}