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

import java.util.*;

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

import org.apache.log4j.*;

public class JndiContextImpl implements Context
{
    private static final Logger log = 
            Logger.getLogger(JndiContextImpl.class.getName());
    private static NameParser parser = new NameParserImpl();
    private Name name;
    private Context parent;
    private Map env = new HashMap();
    private Map bindings = new HashMap();

    public JndiContextImpl()
    {
    }

    public JndiContextImpl(Name name)
    {
        this.name = name;
    }

    public Object clone()
    {
        JndiContextImpl ctx = new JndiContextImpl();

        try
        {
            ctx.parent = parent;
            ctx.name = parser.parse(name.toString());
            ctx.env = getEnvironment();
            ctx.bindings = new HashMap(bindings);
        }
        catch (Exception ex)
        {
        }

        return ctx;
    }

    public Object addToEnvironment(String propName, Object propVal)
    {
        Object prevValue = env.get(propName);

        env.put(propName, propVal);

        return prevValue;
    }

    public Object removeFromEnvironment(String propName)
    {
        Object prevValue = env.get(propName);

        env.remove(propName);

        return prevValue;
    }

    public Hashtable getEnvironment()
                             throws NamingException
    {
        return new Hashtable(env);
    }

    public Context getRootContext()
    {
        JndiContextImpl ctx = this;

        while (ctx.parent != null)
        {
            ctx = (JndiContextImpl) ctx.parent;
        }

        return ctx;
    }

    public String getNameInNamespace()
        throws NamingException
    {
        String stringName = (parent == null) ? "" : parent.getNameInNamespace();

        stringName += ((name == null) ? "" : "/" + name.toString());

        return stringName;
    }

    public void bind(Name name, Object obj)
              throws NamingException
    {
        if (obj instanceof Context)
        {
            throw new OperationNotSupportedException("Cannot bind a Context");
        }

        JndiContextImpl pc = _lookupParent(name);
        String relativeName = name.get(name.size() - 1);
        Object prev = pc.get(relativeName);

        if (prev != null)
        {
            throw new NameAlreadyBoundException(name.toString());
        }

        pc.put(relativeName, obj);
    }

    public void bind(String name, Object obj)
              throws NamingException
    {
        bind(parser.parse(name), obj);
    }

    public Context createSubcontext(Name name)
                             throws NamingException
    {
        JndiContextImpl pc = _lookupParent(name);
        String relativeName = name.get(name.size() - 1);
        Object object = pc.get(relativeName);

        if (object != null)
        {
            throw new NameAlreadyBoundException(name.toString());
        }

        JndiContextImpl ctx = new JndiContextImpl(parser.parse(relativeName));

        ctx.parent = pc;
        pc.put(relativeName, ctx);

        return ctx;
    }

    public Context createSubcontext(String name)
                             throws NamingException
    {
        return createSubcontext(parser.parse(name));
    }

    public void destroySubcontext(Name name)
                           throws NamingException
    {
        JndiContextImpl pc = _lookupParent(name);

        String relativeName = name.get(name.size() - 1);
        Object object = pc.get(relativeName);

        if (object == null)
        {
            throw new NameNotFoundException(name.toString());
        }
        else if (object instanceof JndiContextImpl)
        {
            pc.remove(relativeName);
            ((JndiContextImpl) object).close();
        }
        else
        {
            throw new NotContextException(name.toString());
        }
    }

    public void destroySubcontext(String name)
                           throws NamingException
    {
        destroySubcontext(parser.parse(name));
    }

    protected Object _lookup(String name)
                      throws NamingException
    {
        return _lookup(parser.parse(name));
    }

    protected Object _lookup(Name name)
                      throws NamingException
    {
        JndiContextImpl ctx = _lookupParent(name);
        String relativeName = name.get(name.size() - 1);
        Object object = ctx.get(relativeName);

        if (object == null)
        {
            throw new NameNotFoundException(name.toString());
        }

        return object;
    }

    private JndiContextImpl _lookupParent(Name name)
        throws NamingException
    {
        if (log.isDebugEnabled())
        {
            log.debug("name = " + name);
        }

        JndiContextImpl ctx = this;
        int offset = name.size() - 1;

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

        for (int i = 0; i < offset; i++)
        {
            String part = name.get(i);

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

            if (part.length() == 0)
            {
                continue;
            }

            Object object = ctx.get(part);

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

            if (object instanceof JndiContextImpl)
            {
                ctx = (JndiContextImpl) object;
            }
            else
            {
                throw new NameNotFoundException(name.toString());
            }
        }

        return ctx;
    }

    public Object lookup(Name name)
                  throws NamingException
    {
        JndiContextImpl ctx = _lookupParent(name);
        Name childName = name.getSuffix(name.size() - 1);
        Object object = ctx.get(childName);

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

        return convertObject(object, childName, ctx);
    }

    public Object lookup(String name)
                  throws NamingException
    {
        return lookup(parser.parse(name));
    }

    private Object convertObject(Object object, Name name, Context ctx)
                          throws NamingException
    {
        Reference reference = null;
        Object result = object;

        try
        {
            if (object instanceof JndiContextImpl)
            {
                result = ((JndiContextImpl) object).clone();
            }
            else if (object instanceof Referenceable)
            {
                reference = ((Referenceable) object).getReference();
            }
            else if (object instanceof Reference)
            {
                reference = (Reference) object;
            }

            if (reference != null)
            {
                if (log.isDebugEnabled())
                {
                    log.debug("the object is a reference: " + reference);
                }

                result = NamingManager.getObjectInstance(reference, name, ctx, 
                                                         ctx.getEnvironment());

                if (log.isDebugEnabled())
                {
                    log.debug("the result is: " + result);
                }
            }
        }
        catch (NamingException nex)
        {
            if (log.isDebugEnabled())
            {
                log.debug("Exception: ", nex);
            }

            throw nex;
        }
        catch (Exception ex)
        {
            if (log.isDebugEnabled())
            {
                log.debug("Exception: ", ex);
            }

            result = null;
        }

        return result;
    }

    private Object get(String string)
    {
        return bindings.get(string);
    }

    private Object get(Name name)
    {
        return get(name.get(0));
    }

    private void put(String string, Object object)
    {
        bindings.put(string, object);
    }

    private void put(Name name, Object object)
    {
        put(name.get(0), object);
    }

    private void remove(String string)
    {
        bindings.remove(string);
    }

    private void remove(Name name)
    {
        remove(name.get(0));
    }

    public Object lookupLink(Name name)
                      throws NamingException
    {
        throw new OperationNotSupportedException("lookupLink()");
    }

    public Object lookupLink(String name)
                      throws NamingException
    {
        return lookupLink(parser.parse(name));
    }

    public void rebind(Name name, Object obj)
                throws NamingException
    {
        Object object = null;

        try
        {
            object = _lookup(name);
        }
        catch (Exception ex)
        {
        }

        if (object != null)
        {
            unbind(name);
        }

        bind(name, obj);
    }

    public void rebind(String name, Object obj)
                throws NamingException
    {
        rebind(parser.parse(name), obj);
    }

    public void unbind(Name name)
                throws NamingException
    {
        JndiContextImpl pc = _lookupParent(name);
        String relativeName = name.get(name.size() - 1);
        Object object = pc.get(relativeName);

        if (object == null)
        {
            throw new NameNotFoundException(name.toString());
        }
        else if (object instanceof JndiContextImpl)
        {
            destroySubcontext(name);
        }
        else
        {
            pc.remove(relativeName);
        }
    }

    public void unbind(String name)
                throws NamingException
    {
        unbind(parser.parse(name));
    }

    public NamingEnumeration list(Name name)
                           throws NamingException
    {
        throw new OperationNotSupportedException("list()");
    }

    public NamingEnumeration list(String name)
                           throws NamingException
    {
        return list(parser.parse(name));
    }

    public NamingEnumeration listBindings(Name name)
        throws NamingException
    {
        throw new OperationNotSupportedException("listBindings()");
    }

    public NamingEnumeration listBindings(String name)
        throws NamingException
    {
        return listBindings(parser.parse(name));
    }

    public void rename(Name oldName, Name newName)
                throws NamingException
    {
        Object obj = _lookup(oldName);

        unbind(oldName);
        bind(newName, obj);
    }

    public void rename(String oldName, String newName)
                throws NamingException
    {
        rename(parser.parse(oldName), parser.parse(newName));
    }

    public Name composeName(Name oldName, Name newName)
                     throws NamingException
    {
        throw new OperationNotSupportedException("composeName()");
    }

    public String composeName(String oldName, String newName)
                       throws NamingException
    {
        return composeName(parser.parse(oldName), parser.parse(newName))
                   .toString();
    }

    public NameParser getNameParser(Name name)
                             throws NamingException
    {
        return parser;
    }

    public NameParser getNameParser(String name)
                             throws NamingException
    {
        return parser;
    }

    public void close() throws NamingException
    {
        env = null;
        bindings = null;
    }

    public String toString()
    {
        StringBuffer sb = new StringBuffer();

        sb.append("<JndiContextImpl>\n");
        sb.append(" <name>" + name + "</name>");
        sb.append(" <env>" + env + "</env>");
        sb.append(" <bindings>" + bindings + "</bindings>");
        sb.append("</JndiContextImpl>");

        return sb.toString();
    }

    static class NameParserImpl
        implements NameParser
    {
        private static final String SEPARATOR = "/";

        public NameParserImpl()
        {
        }

        public Name parse(String string)
                   throws NamingException
        {
            return new CompositeName(string);
        }
    }
}