/*
 * Copyright (c) 2009-2010 jMonkeyEngine, Java Game Networking
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
 *   may be used to endorse or promote products derived from this software
 *   without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package com.jme3.network.serializing.serializers;

import com.jme3.network.serializing.Serializer;
import java.io.IOException;
import java.lang.reflect.Array;
import java.lang.reflect.Modifier;
import java.nio.ByteBuffer;

/**
 * Array serializer
 *
 * @author Nathan Sweet
 */
@SuppressWarnings("unchecked")
public class ArraySerializer extends Serializer {
    private int[] getDimensions (Object array) {
        int depth = 0;
        Class nextClass = array.getClass().getComponentType();
        while (nextClass != null) {
            depth++;
            nextClass = nextClass.getComponentType();
        }
        int[] dimensions = new int[depth];
        dimensions[0] = Array.getLength(array);
        if (depth > 1) collectDimensions(array, 1, dimensions);
        return dimensions;
    }

    private void collectDimensions (Object array, int dimension, int[] dimensions) {
        boolean elementsAreArrays = dimension < dimensions.length - 1;
        for (int i = 0, s = Array.getLength(array); i < s; i++) {
            Object element = Array.get(array, i);
            if (element == null) continue;
            dimensions[dimension] = Math.max(dimensions[dimension], Array.getLength(element));
            if (elementsAreArrays) collectDimensions(element, dimension + 1, dimensions);
        }
    }

    public <T> T readObject(ByteBuffer data, Class<T> c) throws IOException {
        byte dimensionCount = data.get();
        if (dimensionCount == 0)
            return null;

        int[] dimensions = new int[dimensionCount];
        for (int i = 0; i < dimensionCount; i++)
                dimensions[i] = data.getInt();

        Serializer elementSerializer = null;

        Class elementClass = c;
        while (elementClass.getComponentType() != null)
            elementClass = elementClass.getComponentType();

        if (Modifier.isFinal(elementClass.getModifiers())) elementSerializer = Serializer.getSerializer(elementClass);
        // Create array and read in the data.
        T array = (T)Array.newInstance(elementClass, dimensions);
        readArray(elementSerializer, elementClass, data, array, 0, dimensions);
        return array;
    }

    public void writeObject(ByteBuffer buffer, Object object) throws IOException {
        if (object == null){
            buffer.put((byte)0);
            return;
        }

        int[] dimensions = getDimensions(object);
        buffer.put((byte)dimensions.length);
        for (int dimension : dimensions) buffer.putInt(dimension);
        Serializer elementSerializer = null;

        Class elementClass = object.getClass();
        while (elementClass.getComponentType() != null) {
            elementClass = elementClass.getComponentType();
        }

        if (Modifier.isFinal(elementClass.getModifiers())) elementSerializer = Serializer.getSerializer(elementClass);
        writeArray(elementSerializer, buffer, object, 0, dimensions.length);
    }

    private void writeArray(Serializer elementSerializer, ByteBuffer buffer, Object array, int dimension, int dimensionCount) throws IOException {
        int length = Array.getLength(array);
        if (dimension > 0) {
            buffer.putInt(length);
        }
        // Write array data.
        boolean elementsAreArrays = dimension < dimensionCount - 1;
        for (int i = 0; i < length; i++) {
            Object element = Array.get(array, i);
            if (elementsAreArrays) {
                if (element != null) writeArray(elementSerializer, buffer, element, dimension + 1, dimensionCount);
            } else if (elementSerializer != null) {
                elementSerializer.writeObject(buffer, element);
            } else {
                // Each element could be a different type. Store the class with the object.
                Serializer.writeClassAndObject(buffer, element);
            }
        }
    }

    private void readArray (Serializer elementSerializer, Class elementClass, ByteBuffer buffer, Object array, int dimension, int[] dimensions) throws IOException {
        boolean elementsAreArrays = dimension < dimensions.length - 1;
        int length;
        if (dimension == 0) {
            length = dimensions[0];
        } else {
            length = buffer.getInt();
        }
        for (int i = 0; i < length; i++) {
            if (elementsAreArrays) {
                // Nested array.
                Object element = Array.get(array, i);
                if (element != null) readArray(elementSerializer, elementClass, buffer, element, dimension + 1, dimensions);
            } else if (elementSerializer != null) {
                // Use same converter (and class) for all elements.
                Array.set(array, i, elementSerializer.readObject(buffer, elementClass));
            } else {
                // Each element could be a different type. Look up the class with the object.
                Array.set(array, i, Serializer.readClassAndObject(buffer));
            }
        }
    }
}