/*

 * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.jndi.cosnaming;

import javax.naming.*;

import javax.naming.directory.*;

import javax.naming.spi.*;

import org.omg.CosNaming.*;

import org.omg.CosNaming.NamingContextPackage.*;

import org.omg.CORBA.*;

/**

  * A convenience class to map the COS Naming exceptions to the JNDI exceptions.

  * @author Raj Krishnamurthy

  */

public final class ExceptionMapper {

    private ExceptionMapper() {} // ensure no instance

    private static final boolean debug = false;

    public static final NamingException mapException(Exception e,

        CNCtx ctx, NameComponent[] inputName) throws NamingException {

        if (e instanceof NamingException) {

            return (NamingException)e;

        }

        if (e instanceof RuntimeException) {

            throw (RuntimeException)e;

        }

        NamingException ne;

        if (e instanceof NotFound) {

            if (ctx.federation) {

                return tryFed((NotFound)e, ctx, inputName);

            } else {

                ne = new NameNotFoundException();

            }

        } else if (e instanceof CannotProceed) {

            ne = new CannotProceedException();

            NamingContext nc = ((CannotProceed) e).cxt;

            NameComponent[] rest = ((CannotProceed) e).rest_of_name;

            // %%% We assume that rest returns *all* unprocessed components.

            // Don't' know if that is a good assumption, given

            // NotFound doesn't set rest as expected. -RL

            if (inputName != null && (inputName.length > rest.length)) {

                NameComponent[] resolvedName =

                    new NameComponent[inputName.length - rest.length];

                System.arraycopy(inputName, 0, resolvedName, 0, resolvedName.length);

                // Wrap resolved NamingContext inside a CNCtx

                // Guess that its name (which is relative to ctx)

                // is the part of inputName minus rest_of_name

                ne.setResolvedObj(new CNCtx(ctx._orb, ctx.orbTracker, nc,

                                                ctx._env,

                    ctx.makeFullName(resolvedName)));

            } else {

                ne.setResolvedObj(ctx);

            }

            ne.setRemainingName(CNNameParser.cosNameToName(rest));

        } else if (e instanceof InvalidName) {

            ne = new InvalidNameException();

        } else if (e instanceof AlreadyBound) {

            ne = new NameAlreadyBoundException();

        } else if (e instanceof NotEmpty) {

            ne = new ContextNotEmptyException();

        } else {

            ne = new NamingException("Unknown reasons");

        }

        ne.setRootCause(e);

        return ne;

    }

    private static final NamingException tryFed(NotFound e, CNCtx ctx,

        NameComponent[] inputName) throws NamingException {

        NameComponent[] rest = e.rest_of_name;

        if (debug) {

            System.out.println(e.why.value());

            System.out.println(rest.length);

        }

        // %%% Using 1.2 & 1.3 Sun's tnameserv, 'rest' contains only the first

        // component that failed, not *rest* as advertized. This is useless

        // because what if you have something like aa/aa/aa/aa/aa.

        // If one of those is not found, you get "aa" as 'rest'.

        if (rest.length == 1 && inputName != null) {

            // Check that we're not talking to 1.2/1.3 Sun tnameserv

            NameComponent lastIn = inputName[inputName.length-1];

            if (rest[0].id.equals(lastIn.id) &&

                rest[0].kind != null &&

                rest[0].kind.equals(lastIn.kind)) {

                // Might be legit

                ;

            } else {

                // Due to 1.2/1.3 bug that always returns single-item 'rest'

                NamingException ne = new NameNotFoundException();

                ne.setRemainingName(CNNameParser.cosNameToName(rest));

                ne.setRootCause(e);

                throw ne;

            }

        }

        // Fixed in 1.4; perform calculations based on correct (1.4) behavior

        // Calculate the components of the name that has been resolved

        NameComponent[] resolvedName = null;

        int len = 0;

        if (inputName != null && (inputName.length >= rest.length)) {

            if (e.why == NotFoundReason.not_context) {

                // First component of rest is found but not a context; keep it

                // as part of resolved name

                len = inputName.length - (rest.length - 1);

                // Remove resolved component from rest

                if (rest.length == 1) {

                    // No more remaining

                    rest = null;

                } else {

                    NameComponent[] tmp = new NameComponent[rest.length-1];

                    System.arraycopy(rest, 1, tmp, 0, tmp.length);

                    rest = tmp;

                }

            } else {

                len = inputName.length - rest.length;

            }

            if (len > 0) {

                resolvedName = new NameComponent[len];

                System.arraycopy(inputName, 0, resolvedName, 0, len);

            }

        }

        // Create CPE and set common fields

        CannotProceedException cpe = new CannotProceedException();

        cpe.setRootCause(e);

        if (rest != null && rest.length > 0) {

            cpe.setRemainingName(CNNameParser.cosNameToName(rest));

        }

        cpe.setEnvironment(ctx._env);

        if (debug) {

            System.out.println("rest of name: " + cpe.getRemainingName());

        }

        // Lookup resolved name to get resolved object

        final java.lang.Object resolvedObj =

            (resolvedName != null) ? ctx.callResolve(resolvedName) : ctx;

        if (resolvedObj instanceof javax.naming.Context) {

            // obj is a context and child is not found

            // try getting its nns dynamically by constructing

            // a Reference containing obj.

            RefAddr addr = new RefAddr("nns") {

                public java.lang.Object getContent() {

                    return resolvedObj;

                }

                private static final long serialVersionUID =

                    669984699392133792L;

            };

            Reference ref = new Reference("java.lang.Object", addr);

            // Resolved name has trailing slash to indicate nns

            CompositeName cname = new CompositeName();

            cname.add(""); // add trailing slash

            cpe.setResolvedObj(ref);

            cpe.setAltName(cname);

            cpe.setAltNameCtx((javax.naming.Context)resolvedObj);

            return cpe;

        } else {

            // Not a context, use object factory to transform object.

            Name cname = CNNameParser.cosNameToName(resolvedName);

            java.lang.Object resolvedObj2;

            try {

                resolvedObj2 = NamingManager.getObjectInstance(resolvedObj,

                    cname, ctx, ctx._env);

            } catch (NamingException ge) {

                throw ge;

            } catch (Exception ge) {

                NamingException ne = new NamingException(

                    "problem generating object using object factory");

                ne.setRootCause(ge);

                throw ne;

            }

            // If a context, continue operation with context

            if (resolvedObj2 instanceof javax.naming.Context) {

                cpe.setResolvedObj(resolvedObj2);

            } else {

                // Add trailing slash

                cname.add("");

                cpe.setAltName(cname);

                // Create nns reference

                final java.lang.Object rf2 = resolvedObj2;

                RefAddr addr = new RefAddr("nns") {

                    public java.lang.Object getContent() {

                        return rf2;

                    }

                    private static final long serialVersionUID =

                        -785132553978269772L;

                };

                Reference ref = new Reference("java.lang.Object", addr);

                cpe.setResolvedObj(ref);

                cpe.setAltNameCtx(ctx);

            }

            return cpe;

        }

    }

}