/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * __________________
 *
 *  Copyright 2002 - 2007 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated
 * and its suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/
package flex.messaging.io.amf;

import flex.messaging.MessageException;

import flex.messaging.io.ArrayCollection;
import flex.messaging.io.PagedRowSet;
import flex.messaging.io.PropertyProxy;
import flex.messaging.io.PropertyProxyRegistry;
import flex.messaging.io.SerializationContext;
import flex.messaging.io.SerializationDescriptor;
import flex.messaging.io.StatusInfoProxy;

import java.io.IOException;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;

import javax.sql.RowSet;

/**
 * An Amf0 output object.
 * @exclude
 */
public class Amf0Output extends AbstractAmfOutput implements AmfTypes
{
    /**
     * 3-byte marker for object end; used for faster serialization
     * than a combination of writeUTF("") and writeByte(kObjectEndType).
     * @exclude
     */
    public static final byte[] OBJECT_END_MARKER = {0, 0, kObjectEndType};

    /**
     * A mapping of object instances to their serialization numbers
     * for storing object references on the stream.
     * @exclude
     */
    protected IdentityHashMap serializedObjects;

    /**
     * Number of serialized objects.
     * @exclude
     */
    protected int serializedObjectCount = 0;

    /**
     * AVM+ Encoding.
     * @exclude
     */
    protected boolean avmPlus;

    /**
     * @exclude
     */
    protected Amf3Output avmPlusOutput;

    /**
     * Construct a serializer without connecting it to an output stream.
     * @param context the context to use
     */
    public Amf0Output(SerializationContext context)
    {
        super(context);
        context.supportDatesByReference = false;

        serializedObjects = new IdentityHashMap(64);
    }

    /**
     * Set to true if the AMF0 stream should switch to use AMF3 on encountering
     * the first complex Object during serialization.
     *
     * @param a Whether the client is running in AVMPlus and can handle AMF3 encoding.
     */
    public void setAvmPlus(boolean a)
    {
        avmPlus = a;
    }

    /**
     * Reset all object reference information allowing the class to be used to
     * write a "new" data structure.
     */
    public void reset()
    {
        super.reset();

        serializedObjects.clear();
        serializedObjectCount = 0;

        if (avmPlusOutput != null)
            avmPlusOutput.reset();
    }

    /**
     * Creates a new Amf3Output instance which is initialized with the
     * current SerializationContext, OutputStream and debug trace settings
     * to switch the version of the AMF protocol mid-stream.
     */
    protected void createAMF3Output()
    {
        avmPlusOutput = new Amf3Output(context);
        avmPlusOutput.setOutputStream(out);
        avmPlusOutput.setDebugTrace(trace);
    }

    //
    // java.io.ObjectOutput implementations
    //

    /**
     * Serialize an Object using AMF 0.
     */
    public void writeObject(Object o) throws IOException
    {
        if (o == null)
        {
            writeAMFNull();
            return;
        }

        if (o instanceof String)
        {
            writeAMFString((String)o);
        }
        else if (o instanceof Number)
        {
            if (!context.legacyBigNumbers &&
                (o instanceof BigInteger || o instanceof BigDecimal))
            {
                // Using double to write big numbers such as BigInteger or
                // BigDecimal can result in information loss so we write
                // them as String by default...
                writeAMFString((o).toString());
            }
            else
            {
                writeAMFDouble(((Number)o).doubleValue());
            }
        }
        else if (o instanceof Boolean)
        {
            writeAMFBoolean(((Boolean)o).booleanValue());
        }
        else if (o instanceof Character)
        {
            String s = o.toString();
            writeAMFString(s);
        }
        else if (o instanceof Date)
        {
            // Note that dates are not considered complex types in AMF 0
            writeAMFDate((Date)o);
        }
        else if (o instanceof Calendar)
        {
            writeAMFDate(((Calendar)o).getTime());
        }
        else
        {
            // We have a complex object.

            // If we're using AMF 3, delegate to AVM+ encoding format
            if (avmPlus)
            {
                if (avmPlusOutput == null)
                {
                    createAMF3Output();
                }

                out.writeByte(kAvmPlusObjectType);
                avmPlusOutput.writeObject(o);
            }
            else
            {
                Class cls = o.getClass();

                if (cls.isArray())
                {
                    writeAMFArray(o, cls.getComponentType());
                }
                else if (o instanceof Map && context.legacyMap && !(o instanceof ASObject))
                {
                        writeMapAsECMAArray((Map)o);
                }
                else if (o instanceof Collection)
                {
                    if (context.legacyCollection)
                        writeCollection((Collection)o, null);
                    else
                        writeArrayCollection((Collection)o, null);
                }
                else if (o instanceof org.w3c.dom.Document)
                {
                    out.write(kXMLObjectType);
                    String xml = documentToString(o);
                    if (isDebug)
                        trace.write(xml);

                    writeUTF(xml, true, false);
                }
                else
                {
                    // Special Case: wrap RowSet in PageableRowSet for Serialization
                    if (o instanceof RowSet)
                    {
                        o = new PagedRowSet((RowSet)o, Integer.MAX_VALUE, false);
                    }
                    else if (o instanceof Throwable && context.legacyThrowable)
                    {
                        o = new StatusInfoProxy((Throwable)o);
                    }

                    writeCustomObject(o);
                }
            }
        }
    }

    /**
     * @exclude
     */
    public void writeObjectTraits(TraitsInfo traits) throws IOException
    {
        String className = null;
        if (traits != null)
            className = traits.getClassName();

        if (isDebug)
            trace.startAMFObject(className, serializedObjectCount - 1);

        if (className == null || className.length() == 0)
        {
            out.write(kObjectType);
        }
        else
        {
            out.write(kTypedObjectType);
            out.writeUTF(className);
        }
    }

    /**
     * @exclude
     */
    public void writeObjectProperty(String name, Object value) throws IOException
    {
        if (isDebug)
            trace.namedElement(name);

        out.writeUTF(name);
        writeObject(value);
    }

    /**
     * @exclude
     */
    public void writeObjectEnd() throws IOException
    {
        out.write(OBJECT_END_MARKER, 0, OBJECT_END_MARKER.length);

        if (isDebug)
            trace.endAMFObject();
    }


    //
    // AMF SPECIFIC SERIALIZATION METHODS
    //

    /**
     * @exclude
     */
    protected void writeAMFBoolean(boolean b) throws IOException
    {
        if (isDebug)
            trace.write(b);

        out.write(kBooleanType);

        out.writeBoolean(b);
    }

    /**
     * @exclude
     */
    protected void writeAMFDouble(double d) throws IOException
    {
        if (isDebug)
            trace.write(d);

        out.write(kNumberType);

        out.writeDouble(d);
    }

    /**
     * @exclude
     */
    protected void writeAMFDate(Date d) throws IOException
    {
        if (isDebug)
            trace.write(d);

        out.write(kDateType);
        // Write the time as 64bit value in ms
        out.writeDouble((double)d.getTime());
        int nCurrentTimezoneOffset = TimeZone.getDefault().getRawOffset();
        out.writeShort(nCurrentTimezoneOffset / 60000);
    }

    /**
     * @exclude
     */
    protected void writeAMFArray(Object o, Class componentType) throws IOException
    {
        if (componentType.isPrimitive())
        {
            writePrimitiveArray(o);
        }
        else if (componentType.equals(Character.class))
        {
            writeCharArrayAsString((Character[])o);
        }
        else
        {
            writeObjectArray((Object[])o, null);
        }
    }

    /**
     * @exclude
     */
    protected void writeArrayCollection(Collection col, SerializationDescriptor desc) throws IOException
    {
        if (!serializeAsReference(col))
        {
            ArrayCollection ac;

            if (col instanceof ArrayCollection)
            {
                ac = (ArrayCollection)col;
                // TODO: QUESTION: Pete ignoring the descriptor here... not sure if
                // we should modify the user's AC as that could cause corruption?
            }
            else
            {
                // Wrap any Collection in an ArrayCollection
                ac = new ArrayCollection(col);
                if (desc != null)
                    ac.setDescriptor(desc);
            }

            // Then wrap ArrayCollection in PropertyProxy for bean-like serialization
            PropertyProxy proxy = PropertyProxyRegistry.getProxy(ac);
            writePropertyProxy(proxy, ac);
        }
    }

    /**
     * @exclude
     */
    protected void writeCustomObject(Object o) throws IOException
    {
        PropertyProxy proxy = null;

        if (o instanceof PropertyProxy)
        {
            proxy = (PropertyProxy)o;
            o = proxy.getDefaultInstance();

            // The proxy may wrap a null default instance, if so, short circuit here.
            if (o == null)
            {
                writeAMFNull();
                return;
            }
            // HACK: Short circuit and unwrap if PropertyProxy is wrapping an Array
            // or Collection type since we don't yet have the ability to proxy multiple
            // AMF types. We write an AMF Array directly instead of an AMF Object
            else if (o instanceof Collection)
            {
                if (context.legacyCollection)
                    writeCollection((Collection)o, proxy.getDescriptor());
                else
                    writeArrayCollection((Collection)o, proxy.getDescriptor());
                return;
            }
            else if (o.getClass().isArray())
            {
                writeObjectArray((Object[])o, proxy.getDescriptor());
                return;
            }
            else if (context.legacyMap && o instanceof Map && !(o instanceof ASObject))
            {
                writeMapAsECMAArray((Map)o);
                return;
            }
        }

        if (!serializeAsReference(o))
        {
            if (proxy == null)
            {
                proxy = PropertyProxyRegistry.getProxyAndRegister(o);
            }

            writePropertyProxy(proxy, o);
        }
    }

    /**
     * @exclude
     */
    protected void writePropertyProxy(PropertyProxy pp, Object instance) throws IOException
    {
        /*
         * At this point we substitute the instance we want to serialize.
         */
        Object newInst = pp.getInstanceToSerialize(instance);
        if (newInst != instance)
        {
            // We can't use writeAMFNull here I think since we already added this object
            // to the object table on the server side.  The player won't have any way
            // of knowing we have this reference mapped to null.
            if (newInst == null)
                throw new MessageException("PropertyProxy.getInstanceToSerialize class: " + pp.getClass() + " returned null for instance class: " + instance.getClass().getName());

            // Grab a new proxy if necessary for the new instance
            pp = PropertyProxyRegistry.getProxyAndRegister(newInst);
            instance = newInst;
        }

        //FIXME: Throw exception or use unsupported type for externalizable as it's not supported in AMF 0?
        boolean externalizable = false; //sp.isExternalizable(instance);
        List propertyNames = pp.getPropertyNames(instance);

        TraitsInfo ti = new TraitsInfo(pp.getAlias(instance), pp.isDynamic(), externalizable, propertyNames);
        writeObjectTraits(ti);

        if (propertyNames != null)
        {
            Iterator it = propertyNames.iterator();
            while (it.hasNext())
            {
                String propName = (String)it.next();
                Object value = pp.getValue(instance, propName);
                writeObjectProperty(propName, value);
            }
        }

        writeObjectEnd();
    }

    /**
     * @exclude
     */
    protected void writeMapAsECMAArray(Map m) throws IOException
    {
        if (!serializeAsReference(m))
        {
            if (isDebug)
                trace.startECMAArray(serializedObjectCount - 1);

            out.write(kECMAArrayType);
            out.writeInt(0);

            Iterator it = m.keySet().iterator();
            while (it.hasNext())
            {
                Object key = it.next();
                Object value = m.get(key);
                writeObjectProperty(key.toString(), value);
            }

            writeObjectEnd();
        }
    }

    /**
     * @exclude
     */
    protected void writeAMFNull() throws IOException
    {
        if (isDebug)
            trace.writeNull();

        out.write(kNullType);
    }

    /**
     * @exclude
     */
    protected void writeAMFString(String str) throws IOException
    {
        if (isDebug)
            trace.writeString(str);

        writeUTF(str, false, true);
    }

    /**
     * @exclude
     */
    protected void writeObjectArray(Object[] values, SerializationDescriptor descriptor) throws IOException
    {
        if (!serializeAsReference(values))
        {
            if (isDebug)
                trace.startAMFArray(serializedObjectCount - 1);

            out.write(kStrictArrayType);
            out.writeInt(values.length);
            for (int i = 0; i < values.length; ++i)
            {
                if (isDebug)
                    trace.arrayElement(i);

                Object item = values[i];
                if (item != null && descriptor != null && !(item instanceof String)
                        && !(item instanceof Number) && !(item instanceof Boolean)
                        && !(item instanceof Character))
                {

                    PropertyProxy proxy = PropertyProxyRegistry.getProxy(item);
                    proxy = (PropertyProxy)proxy.clone();
                    proxy.setDescriptor(descriptor);
                    item = proxy;
                }
                writeObject(item);
            }

            if (isDebug)
                trace.endAMFArray();
        }
    }

    /**
     * Serialize a Collection.
     *
     * @param c Collection to be serialized as an array.
     * @throws java.io.IOException The exception can be generated by the output stream
     * @exclude
     */
    protected void writeCollection(Collection c, SerializationDescriptor descriptor) throws IOException
    {
        if (!serializeAsReference(c))
        {
            if (isDebug)
                trace.startAMFArray(serializedObjectCount - 1);

            out.write(kStrictArrayType);
            out.writeInt(c.size());
            Iterator it = c.iterator();
            int i = 0;
            while (it.hasNext())
            {
                if (isDebug)
                    trace.arrayElement(i++);

                Object item = it.next();
                if (item != null && descriptor != null && !(item instanceof String)
                        && !(item instanceof Number) && !(item instanceof Boolean)
                        && !(item instanceof Character))
                {
                    PropertyProxy proxy = PropertyProxyRegistry.getProxy(item);
                    proxy = (PropertyProxy)proxy.clone();
                    proxy.setDescriptor(descriptor);
                    item = proxy;
                }
                writeObject(item);
            }

            if (isDebug)
                trace.endAMFArray();
        }
    }

    /**
     * Serialize an array of primitives.
     * <p>
     * Primitives include the following:
     * boolean, char, double, float, long, int, short, byte
     * </p>
     * @param obj An array of primitives
     * @exclude
     */
    protected void writePrimitiveArray(Object obj) throws IOException
    {
        Class aType = obj.getClass().getComponentType();

        //Treat char[] as a String
        if (aType.equals(Character.TYPE))
        {
            char[] c = (char[])obj;
            writeCharArrayAsString(c);
        }
        else if (!serializeAsReference(obj))
        {
            if (aType.equals(Boolean.TYPE))
            {
                out.write(kStrictArrayType);

                boolean[] b = (boolean[])obj;
                out.writeInt(b.length);

                if (isDebug)
                {
                    trace.startAMFArray(serializedObjectCount - 1);

                    for (int i = 0; i < b.length; i++)
                    {
                        trace.arrayElement(i);
                        writeAMFBoolean(b[i]);
                    }

                    trace.endAMFArray();
                }
                else
                {
                    for (int i = 0; i < b.length; i++)
                    {
                        writeAMFBoolean(b[i]);
                    }
                }
            }
            else
            {
                //We have a primitive number, either a double, float, long, int, short or byte.
                //We write all of these as doubles...
                out.write(kStrictArrayType);

                int length = Array.getLength(obj);
                out.writeInt(length);

                if (isDebug)
                {
                    trace.startAMFArray(serializedObjectCount - 1);

                    for (int i = 0; i < length; i++)
                    {
                        trace.arrayElement(i);
                        double v = Array.getDouble(obj, i);
                        writeAMFDouble(v);
                    }

                    trace.endAMFArray();
                }
                else
                {
                    for (int i = 0; i < length; i++)
                    {
                        double v = Array.getDouble(obj, i);
                        writeAMFDouble(v);
                    }
                }
            }
        }
    }

    /**
     * @exclude
     */
    protected void writeCharArrayAsString(Character[] ca) throws IOException
    {
        int length = ca.length;
        char[] chars = new char[length];

        for (int i = 0; i < length; i++)
        {
            Character c = ca[i];
            if (c == null)
                chars[i] = 0;
            else
                chars[i] = ca[i].charValue();
        }
        writeCharArrayAsString(chars);
    }

    /**
     * @exclude
     */
    protected void writeCharArrayAsString(char[] ca) throws IOException
    {
        writeAMFString(new String(ca));
    }

    /**
     * @exclude
     */
    protected void writeUTF(String str, boolean forceLong, boolean writeType) throws IOException
    {
        int strlen = str.length();
        int utflen = 0;
        int c, count = 0;

        char[] charr = getTempCharArray(strlen);
        str.getChars(0, strlen, charr, 0);

        for (int i = 0; i < strlen; i++)
        {
            c = charr[i];
            if (c <= 0x007F)
            {
                utflen++;
            }
            else if (c > 0x07FF)
            {
                utflen += 3;
            }
            else
            {
                utflen += 2;
            }
        }

        int type;
        if (forceLong)
        {
            type = kLongStringType;
        }
        else
        {
            if (utflen <= 65535)
                type = kStringType;
            else
                type = kLongStringType;
        }

        byte[] bytearr;
        if (writeType)
        {
            bytearr = getTempByteArray(utflen + (type == kStringType ? 3 : 5));
            bytearr[count++] = (byte)(type);
        }
        else
            bytearr = getTempByteArray(utflen + (type == kStringType ? 2 : 4));

        if (type == kLongStringType)
        {
            bytearr[count++] = (byte)((utflen >>> 24) & 0xFF);
            bytearr[count++] = (byte)((utflen >>> 16) & 0xFF);
        }
        bytearr[count++] = (byte)((utflen >>> 8) & 0xFF);
        bytearr[count++] = (byte)((utflen) & 0xFF);
        for (int i = 0; i < strlen; i++)
        {
            c = charr[i];
            if (c <= 0x007F)
            {
                bytearr[count++] = (byte)c;
            }
            else if (c > 0x07FF)
            {
                bytearr[count++] = (byte)(0xE0 | ((c >> 12) & 0x0F));
                bytearr[count++] = (byte)(0x80 | ((c >> 6) & 0x3F));
                bytearr[count++] = (byte)(0x80 | ((c) & 0x3F));
            }
            else
            {
                bytearr[count++] = (byte)(0xC0 | ((c >> 6) & 0x1F));
                bytearr[count++] = (byte)(0x80 | ((c) & 0x3F));
            }
        }
        out.write(bytearr, 0, count);
    }

    /**
     * Remember the object's serialization number so that it can be referred to
     * as a reference later. Only complex ojects should be stored as references.
     *
     * @exclude
     */
    protected void rememberObjectReference(Object obj)
    {
        serializedObjects.put(obj, new Integer(serializedObjectCount++));
    }

    /**
     * Attempts to serialize the object as a reference.
     * If the object cannot be serialized as a reference, it is stored
     * in the reference collection for potential future encounter.
     *
     * @return Success/failure indicator as to whether the object could be
     *         serialized as a reference.
     * @exclude
     */
    protected boolean serializeAsReference(Object obj) throws IOException
    {
        Object ref = serializedObjects.get(obj);
        if (ref != null)
        {
            try
            {
                int refNum = ((Integer)ref).intValue();
                out.write(kReferenceType);
                out.writeShort(refNum);

                if (isDebug)
                    trace.writeRef(refNum);
            }
            catch (ClassCastException e)
            {
                throw new IOException("Object reference value is not an Integer");
            }
        }
        else
        {
            rememberObjectReference(obj);
        }
        return (ref != null);
    }

    /**
    protected void writeUnsupported() throws IOException
    {
        if (isDebug)
            trace.write("UNSUPPORTED");

        out.write(kUnsupportedType);
    }
    */
}