/*
 * @(#)ServiceContexts.java	1.20 03/01/23
 *
 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package com.sun.corba.se.internal.core;

import java.util.*;
import org.omg.CORBA.OctetSeqHelper;
import org.omg.CORBA.SystemException;
import org.omg.CORBA.INTERNAL;
import org.omg.CORBA.CompletionStatus;
import org.omg.CORBA_2_3.portable.OutputStream ;
import org.omg.CORBA_2_3.portable.InputStream ;
import com.sun.org.omg.SendingContext.CodeBase;
import com.sun.corba.se.internal.corba.ORB ;
import com.sun.corba.se.internal.util.Utility ;
import com.sun.corba.se.internal.orbutil.ORBUtility ;
import com.sun.corba.se.internal.core.ServiceContext ;
import com.sun.corba.se.internal.core.ServiceContextRegistry ;
import com.sun.corba.se.internal.core.ServiceContextData ;
import com.sun.corba.se.internal.core.UnknownServiceContext ;
import com.sun.corba.se.internal.core.NoSuchServiceContext ;
import com.sun.corba.se.internal.core.DuplicateServiceContext ;
import com.sun.corba.se.internal.corba.EncapsInputStream ;
import com.sun.corba.se.internal.iiop.CDRInputStream ;
import com.sun.corba.se.internal.iiop.CDROutputStream ;
import com.sun.corba.se.internal.orbutil.MinorCodes ;
import com.sun.corba.se.internal.corba.EncapsInputStream ;
import java.lang.reflect.InvocationTargetException ;
import java.lang.reflect.Modifier ;
import java.lang.reflect.Field ;
import java.lang.reflect.Constructor ;

public class ServiceContexts {
    private static boolean isDebugging( OutputStream os )
    {
	CDROutputStream cos = (CDROutputStream)os ;
	ORB orb = (ORB)(cos.orb()) ;
	if (orb==null)
	    return false ;
	return orb.serviceContextDebugFlag ;
    }

    private static boolean isDebugging( InputStream is )
    {
	CDRInputStream cis = (CDRInputStream)is ;
	ORB orb = (ORB)(cis.orb()) ;
	if (orb==null) 
	    return false ;
	return orb.serviceContextDebugFlag ;
    }

    private void dprint( String msg ) 
    {
	ORBUtility.dprint( this, msg ) ;
    }

    public static void writeNullServiceContext( OutputStream os ) 
    {
	if (isDebugging(os))
	    ORBUtility.dprint( "ServiceContexts", "Writing null service context" ) ;
	os.write_long( 0 ) ;
    }

    /**
     * Given the input stream, this fills our service
     * context map.  See the definition of scMap for
     * details.  Creates a HashMap.
     *
     * Note that we don't actually unmarshal the
     * bytes of the service contexts here.  That is
     * done when they are actually requested via
     * get(int).
     */
    private void createMapFromInputStream(InputStream is)
    {
        if (orb.serviceContextDebugFlag)
            dprint( "Constructing ServiceContexts from input stream" ) ;

        int numValid = is.read_long() ;

        if (orb.serviceContextDebugFlag)
            dprint("Number of service contexts = " + numValid);

        scMap = new HashMap(numValid);

        for (int ctr = 0; ctr < numValid; ctr++) {
            int scId = is.read_long();

            if (orb.serviceContextDebugFlag)
                dprint("Reading service context id " + scId);

            byte[] data = OctetSeqHelper.read(is);

            if (orb.serviceContextDebugFlag)
                dprint("Service context" + scId + " length: " + data.length);

            scMap.put(new Integer(scId), data);
        }
    }

    /** 
     * Read the Service contexts from the input stream.
     */
    public ServiceContexts(InputStream s)
    {
        addAlignmentOnWrite = false ;

        orb = (com.sun.corba.se.internal.corba.ORB)(s.orb());

        // We need to store this so that we can have access
        // to the CodeBase for unmarshaling possible
        // RMI-IIOP valuetype data within an encapsulation.
        // (Known case: UnknownExceptionInfo)
        codeBase = ((CDRInputStream)s).getCodeBase();

        // See REVISIT below concerning giopVersion.
        giopVersion = ((CDRInputStream)s).getGIOPVersion();

        createMapFromInputStream(s);
    }

    /**
     * Find the ServiceContextData for a given scId and unmarshal
     * the bytes.
     */
    private ServiceContext unmarshal(Integer scId, byte[] data) {

        ServiceContextRegistry scr = orb.getServiceContextRegistry();

        ServiceContextData scd = scr.findServiceContextData(scId.intValue());
        ServiceContext sc = null;

        if (scd == null) {
            if (orb.serviceContextDebugFlag) {
                dprint("Could not find ServiceContextData for "
                       + scId
                       + " using UnknownServiceContext");
            }

            sc = new UnknownServiceContext(scId.intValue(), data);

        } else {

            if (orb.serviceContextDebugFlag) {
                dprint("Found " + scd);
            }

            // REVISIT.  GIOP version should be specified as
            // part of a service context's definition, so should
            // be accessible from ServiceContextData via
            // its ServiceContext implementation class.
            //
            // Since we don't have that, yet, I'm using the GIOP
            // version of the input stream, presuming that someone
            // can't send a service context of a later GIOP
            // version than its stream version.
            //
            // Note:  As of Jan 2001, no standard OMG or Sun service contexts
            // ship wchar data or are defined as using anything but GIOP 1.0 CDR.
            EncapsInputStream eis 
                = new EncapsInputStream(orb,
                                        data,
                                        data.length,
                                        giopVersion,
                                        codeBase);
            eis.consumeEndian();

            try {

                // Now the input stream passed to a ServiceContext
                // constructor is already the encapsulation input
                // stream with the endianness read off, so the
                // service context should just unmarshal its own
                // data.
                sc = scd.makeServiceContext(eis, 
                                            giopVersion);

            } catch (NoSuchServiceContext nssc) {
                throw new INTERNAL(nssc.toString(),
                                   MinorCodes.SVCCTX_UNMARSHAL_ERROR,
                                   CompletionStatus.COMPLETED_MAYBE);
            }
        }

        return sc;
    }

    public ServiceContexts( ORB orb )
    {
	this.orb = orb ;
        scMap = new HashMap();
	addAlignmentOnWrite = false ;

        // Use the GIOP version of the ORB.  Should
        // be specified in ServiceContext.  See REVISIT.
        giopVersion = orb.getGIOPVersion();
    }

    public void addAlignmentPadding() 
    {
	// Make service context 12 bytes longer by adding 
	// JAVAIDL_ALIGN_SERVICE_ID service context at end.
	// The exact length
	// must be >8 (minimum service context size) and 
	// =4 mod 8, so 12 is the minimum.
	addAlignmentOnWrite = true ;
    }

    /** 
     * Hopefully unused scid:  This should be changed to a proper
     * VMCID aligned value.  REVISIT!
     */
    private static final int JAVAIDL_ALIGN_SERVICE_ID = 0xbe1345cd ;

    /** 
     * Write the service contexts to the output stream.
     *
     * If they haven't been unmarshaled, we don't have to
     * unmarshal them.
     */
    public void write(OutputStream os, GIOPVersion gv)
    {
	if (isDebugging(os)) {
	    dprint( "Writing service contexts to output stream" ) ;
	    Utility.printStackTrace() ;
  	}

	int numsc = scMap.size();

	if (addAlignmentOnWrite) {
	    if (isDebugging(os))
		dprint( "Adding alignment padding" ) ;

	    numsc++ ;
	}

	if (isDebugging(os))
	    dprint( "Service context has " + numsc + " components"  ) ;

	os.write_long( numsc ) ;

        writeServiceContextsInOrder(os, gv);

	if (addAlignmentOnWrite) {
	    if (isDebugging(os))
		dprint( "Writing alignment padding" ) ;

	    os.write_long( JAVAIDL_ALIGN_SERVICE_ID ) ;
	    os.write_long( 4 ) ;
	    os.write_octet( (byte)0 ) ;
	    os.write_octet( (byte)0 ) ;
	    os.write_octet( (byte)0 ) ;
	    os.write_octet( (byte)0 ) ;
	}

	if (isDebugging(os))
	    dprint( "Service context writing complete" ) ;
    }

    /**
     * Write the service contexts in scMap in a desired order.
     * Right now, the only special case we have is UnknownExceptionInfo,
     * so I'm merely writing it last if present.
     */
    private void writeServiceContextsInOrder(OutputStream os, GIOPVersion gv) {

        // Temporarily remove this rather than check it per iteration
        Integer ueInfoId
            = new Integer(UEInfoServiceContext.SERVICE_CONTEXT_ID);

        Object unknownExceptionInfo = scMap.remove(ueInfoId);

	Iterator iter = scMap.keySet().iterator();

	while (iter.hasNext()) {
            Integer id = (Integer)iter.next();

            writeMapEntry(os, id, scMap.get(id), gv);
        }

        // Write the UnknownExceptionInfo service context last
        // (so it will be after the CodeBase) and restore it in
        // the map.
        if (unknownExceptionInfo != null) {
            writeMapEntry(os, ueInfoId, unknownExceptionInfo, gv);

            scMap.put(ueInfoId, unknownExceptionInfo);
        }
    }

    /**
     * Write the given entry from the scMap to the OutputStream.
     * See note on giopVersion.  The service context should
     * know the GIOP version it is meant for.
     */
    private void writeMapEntry(OutputStream os, Integer id, Object scObj, GIOPVersion gv) {

        // If it's still in byte[] form, we don't need to
        // unmarshal it here, just copy the bytes into
        // the new stream.

        if (Byte.TYPE.equals(scObj.getClass().getComponentType())) {
            if (isDebugging(os))
                dprint( "Writing service context bytes for id " + id);

            OctetSeqHelper.write(os, (byte[])scObj);

        } else {

            // We actually unmarshaled it into a ServiceContext
            // at some point.
            ServiceContext sc = (ServiceContext)scObj;

            if (isDebugging(os))
                dprint( "Writing service context " + sc ) ;

            sc.write(os, gv);
        }
    }

    /** Add a service context to the stream, if there is not already
     * a service context in this object with the same id as sc.
     * If there is already such a service context, throw the 
     * DuplicateServiceContext exception.
     */
    public void put( ServiceContext sc ) throws DuplicateServiceContext
    {
        Integer id = new Integer(sc.getId());

        Object result = scMap.get(id);

        if (result != null)
            throw new DuplicateServiceContext(id.toString());

        scMap.put(id, sc);
    }

    public void delete( int scId ) throws NoSuchServiceContext {
        this.delete(new Integer(scId));
    }

    public void delete(Integer id) throws NoSuchServiceContext 
    {
        if (scMap.remove(id) == null)
            throw new NoSuchServiceContext(id.toString());
    }

    public ServiceContext get(int scId) throws NoSuchServiceContext {
        return this.get(new Integer(scId));
    }

    public ServiceContext get(Integer id) throws NoSuchServiceContext
    {
        Object result = scMap.get(id);

        // REVISIT.  We should probably just return null here.
        if (result == null)
            throw new NoSuchServiceContext();

        // Lazy unmarshaling on first use.
        if (Byte.TYPE.equals(result.getClass().getComponentType())) {

            ServiceContext sc = unmarshal(id, (byte[])result);

            scMap.put(id, sc);

            return sc;
        } else {
            return (ServiceContext)result;
        }
    }

    private ORB orb ;

    /** 
     * Map of all ServiceContext objects in this container.
     *
     * Keys are java.lang.Integers for service context IDs.
     * Values are either instances of ServiceContext or the
     * unmarshaled byte arrays (unmarshaled on first use).
     *
     * This provides a mild optimization if we don't happen to
     * use a given service context, but it's main advantage is
     * that it allows us to change the order in which we
     * unmarshal them.  We need to do the UnknownExceptionInfo service 
     * context after the SendingContextRunTime service context so that we can
     * get the CodeBase if necessary.
     */
    private Map scMap;

    /** 
     * If true, write out a special alignment service context to force the
     * correct alignment on re-marshalling.
     */
    private boolean addAlignmentOnWrite ;

    private CodeBase codeBase;
    private GIOPVersion giopVersion;

}