/* $Id$ 
 * 
 * Licensed to the Apache Software Foundation (ASF) under one or more 
 * contributor license agreements. See the NOTICE file distributed with  
 * this work for additional information regarding copyright ownership. 
 * The ASF licenses this file to you under the Apache License, Version  
 * 2.0 (the "License"); you may not use this file except in compliance  
 * with the License. You may obtain a copy of the License at 
 * 
 * http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */ 

/**
 * etch_nativearray.c  
 * etch_nativearray implementation
 * does allocation and subscripting for n-dimensional arrays stored as a single
 * byte vector, to overcome the well-known C compiler issues with passing around
 * multi dimensioned arrays when the low order dimension is not known at compile
 * time. the mapping here from byte vector to array tests out as k&r compliant,
 * this is verified by constructing from a static array using new_etch_nativearray_from
 * and testing that the get methods return the same result as statically indexed
 * array items. as it stands, this code handles a max of 3 dimensions. it can be 
 * generalized to n dimensions, however the caller would have to allocate, populate, 
 * and pass arrays of subscripts for this to happen.
 */

#include <stdio.h>
#include "etch_nativearray.h"
#include "etch_objecttypes.h"
#include "etch_mem.h"

etch_nativearray* init_etch_nativearray(unsigned short, const size_t, const int, const int, const int, const int);
int etch_nativearray_put1 (etch_nativearray*, void*, int);
int etch_nativearray_put2 (etch_nativearray*, void*, int, int);
int etch_nativearray_put3 (etch_nativearray*, void*, int, int, int);
int etch_nativearray_get1 (etch_nativearray*, void*, int);
int etch_nativearray_get2 (etch_nativearray*, void*, int, int);
int etch_nativearray_get3 (etch_nativearray*, void*, int, int, int);
int etch_nativearray_set_content_type(etch_nativearray*);

/*
 * new_etch_nativearray() 
 * etch_nativearray constructor
 * note that when creating arrays, the dimensions are passed low-order first,
 * so for x[2][3][4], dim0 is 4, dim1 is 3, dim2 is 2. for y[7][9], dim0 is 9,
 * dim1 is 7, and dim2 is zero of course.
 */
etch_nativearray* new_etch_nativearray(unsigned short class_id, const size_t itemsize,  
    const int numdims, const int dim0, const int dim1, const int dim2)
{
    etch_nativearray* newarray = init_etch_nativearray(class_id, itemsize, numdims, dim0, dim1, dim2);
    if (NULL == newarray) return NULL;

    newarray->values = etch_malloc(newarray->bytecount, ETCHTYPEB_BYTES);
    memset(newarray->values, 0, newarray->bytecount);
    newarray->is_content_owned = TRUE;
  
    etch_nativearray_set_content_type(newarray);
    return newarray;
}

/*
 * new_etch_nativearray_from() 
 * etch_nativearray constructor from existing byte vector
 * @param values source array, caller retains ownership.
 */
etch_nativearray* new_etch_nativearray_from(void* values, unsigned short class_id, const size_t itemsize, 
    const int numdims, const int dim0, const int dim1, const int dim2)
{
    etch_nativearray* newarray = init_etch_nativearray(class_id, itemsize, numdims, dim0, dim1, dim2);
    if (NULL == newarray) return NULL;

    newarray->values = values;
    newarray->is_content_owned = FALSE;

    etch_nativearray_set_content_type(newarray);
    return newarray;
}

/*
 * new_etch_nativearray_of() 
 * etch_nativearray constructor for array of objects of specified type and class
 */
etch_nativearray* new_etch_nativearray_of(unsigned short content_obj_type, unsigned short content_class_id, const int numdims, const int dim0, const int dim1, const int dim2)
{
    etch_nativearray* newarray = init_etch_nativearray(CLASSID_ARRAY_OBJECT, sizeof(void*), numdims, dim0, dim1, dim2);
    if (NULL == newarray) return NULL;

    newarray->content_obj_type = content_obj_type;
    newarray->content_class_id = content_class_id;
    return newarray;
}

/*
 * init_etch_nativearray() 
 * etch_nativearray private constructor
 * assumes max number of dimensions is 3
 */
etch_nativearray* init_etch_nativearray(unsigned short class_id, const size_t itemsize,  
    const int numdims, const int dim0, const int dim1, const int dim2)
{
    etch_nativearray* newarray = NULL;
    int i,j;
    if (numdims < 1 || itemsize < 1) return NULL;
    if (numdims > 1 && dim1 < 1)     return NULL;
    if (numdims > 2 && dim2 < 1)     return NULL;

    newarray = (etch_nativearray*)new_object(sizeof(etch_nativearray), ETCHTYPEB_NATIVEARRAY, class_id);

    newarray->numdims  = numdims;
    newarray->itemsize = itemsize;

    /* dimension array contains the array dimensions, 
     * e.g., for x[2][3][4], [0] is 4, [1] is 3, [2] is 2 
     */
    newarray->dimension[0] = dim0;
    newarray->dimension[1] = numdims > 1? dim1: 0;
    newarray->dimension[2] = numdims > 2? dim2: 0;

    /* dimsize array contains size in bytes of the next lower dimension, 
     * stored so that the values need not be calculated on each array access. 
     * [0] is item size, so for int x[5][7][9], [0] is sizeof(int), 
     * [1] is 9*sizeof(int), [2] is 7*9*sizeof(int)
     */
    newarray->dimsize[0] = itemsize;
    newarray->bytecount  = itemsize * dim0;

    for(i = 1, j = 0; i < numdims; i++, j++)
    {
        newarray->dimsize[i] = newarray->dimension[j] * newarray->dimsize[j];
        newarray->bytecount *= newarray->dimension[i];
    }

    ((etch_object*)newarray)->clone   = etch_nativearray_clone;
    ((etch_object*)newarray)->destroy = destroy_etch_nativearray;

    newarray->put1 = etch_nativearray_put1;
    newarray->put2 = etch_nativearray_put2;
    newarray->put3 = etch_nativearray_put3;
    newarray->get1 = etch_nativearray_get1;
    newarray->get2 = etch_nativearray_get2;
    newarray->get3 = etch_nativearray_get3;

    return newarray;      
}


void* etch_nativearray_clone(void* obj)
{
    etch_nativearray* source = (etch_nativearray*)obj;
    etch_nativearray* newarray = NULL;

    if(source == NULL) {
        return NULL;
    }

    newarray = new_etch_nativearray_from(source->values, source->content_class_id, source->itemsize, source->numdims, (int)source->dimension[0], (int)source->dimension[1], (int)source->dimension[2]);


    // always own copies of unwrapped content
    if(source->content_class_id == CLASSID_UNWRAPPED){
        newarray->values = etch_malloc(source->bytecount, ETCHTYPEB_BYTES);
        memcpy(newarray->values,source->values,source->bytecount);
        newarray->is_content_owned = TRUE;
    }else {
        //never own anything else
        newarray->is_content_owned = FALSE;
        newarray->values = source->values;
    }
    newarray->content_class_id = source->content_class_id;
    newarray->content_obj_type = source->content_obj_type;
    ((etch_object*)newarray)->class_id = ((etch_object*)source)->class_id;
    return newarray;

}

/**
 * destroy_etch_nativearray_content()
 * destroy nativearray's content vector.
 * return -1 if content not owned by nativearray and therefore not destroyed;
 * otherwise return zero, regardless of whether content was null.
 */
int destroy_etch_nativearray_content(etch_nativearray* a)
{
    int  result = 0;
    if  (!is_etchobj_static_content(a) && a->is_content_owned) {
        if(a->content_class_id != CLASSID_UNWRAPPED){
            size_t i = 0;
            size_t length = a->bytecount / sizeof(etch_object*);
            ETCH_ASSERT(a->bytecount % sizeof(etch_object*) == 0);
            for(; i < length; i++){
                void** temp = a->values;
                if( temp[i] ){
                    etch_object_destroy(temp[i]);
                }
            }
        }
        etch_free(a->values);  /* OK if values null */  
    }
 
    else result = -1;
    return result;
}


/**
 * destroy_etch_nativearray()
 * etch_nativearray destructor
 */
int destroy_etch_nativearray(void* obj) 
{
    etch_nativearray* a = (etch_nativearray*)obj;
    if (a->is_content_owned && !is_etchobj_static_content(a)) 
        destroy_etch_nativearray_content(a);
    destroy_objectex((etch_object*)a);
    return 0;
}


/*
 * new_subarray() 
 * construct and return subaarray[i] of this array.
 * subarray points into parent content and so does not own its content
 */
etch_nativearray* new_subarray(etch_nativearray* a, const int i) 
{
    etch_nativearray* subarray = NULL;
    const int sub_numdims = a->numdims - 1;

    if (a->numdims > 1 && i < (int) a->dimension[sub_numdims]) 
    {   
        const size_t sub_bytelen = a->dimsize[sub_numdims];
        const size_t vector_offset = i * sub_bytelen;
        byte* subvector = (byte*) a->values + vector_offset;

        subarray = new_etch_nativearray_from(subvector, 
            ((etch_object*)a)->class_id, (int) a->itemsize, sub_numdims,  
            (int) a->dimension[0], (int) a->dimension[1], 0);

        subarray->bytecount = sub_bytelen;
        subarray->content_obj_type = a->content_obj_type;
        subarray->content_class_id = a->content_class_id;
        subarray->is_content_owned = a->is_content_owned;

        subarray->counts[0] = a->counts[0]; /* user-maintained counts */  
        subarray->counts[1] = a->counts[1];  
        subarray->counts[2] = 0;
    }

    return subarray;
}


/*
 * etch_nativearray_get_element() 
 * return element[i] of specified array, which, if array is multi-dimensioned,
 * will be another native array, otherwise an etch object. for example, if
 * the supplied array is byte[2][4], a native array of byte[4] is returned.
 * if the supplied array is byte[4], an etch_byte object is returned.
 * returned subarrays do not own content, their content references the content
 * of their parent.
 */
etch_object* etch_nativearray_get_element(etch_nativearray* a, const int i) 
{
    int result = 0;
    etch_object* wrapped_element = NULL;

    const int sub_numdims = a->numdims - 1;
    if (sub_numdims < 0) return NULL;

    if (sub_numdims > 0) 
        return (etch_object*) new_subarray(a, i);

    result = etch_nativearray_get_wrapped_component(a, i, &wrapped_element);

    return wrapped_element;
}


/*
 * etch_nativearray_set_content_type() 
 * set content_obj_type and content_class_id based on array class_id.
 * returns zero if content type was set, otherwise -1
 */
int etch_nativearray_set_content_type(etch_nativearray* a)
{
    unsigned short obj_type = 0;
    int result = 0;

    switch(((etch_object*)a)->class_id) 
    {
        case CLASSID_ARRAY_BYTE:    obj_type = ETCHTYPEB_BYTE;   break;
        case CLASSID_ARRAY_BOOL:    obj_type = ETCHTYPEB_BOOL;   break;
        case CLASSID_ARRAY_INT8:    obj_type = ETCHTYPEB_INT8;   break;
        case CLASSID_ARRAY_INT16:   obj_type = ETCHTYPEB_INT16;  break;
        case CLASSID_ARRAY_INT32:   obj_type = ETCHTYPEB_INT32;  break;
        case CLASSID_ARRAY_INT64:   obj_type = ETCHTYPEB_INT64;  break;
        case CLASSID_ARRAY_FLOAT:   obj_type = ETCHTYPEB_IEEE32; break;
        case CLASSID_ARRAY_DOUBLE:  obj_type = ETCHTYPEB_IEEE64; break;
    }

    if (obj_type) {
        a->content_obj_type = obj_type;
        a->content_class_id = CLASSID_UNWRAPPED;
    }
    else switch(((etch_object*)a)->class_id) 
    {
        case CLASSID_ARRAY_OBJECT: 
            a->content_obj_type = ETCHTYPEB_ETCHOBJECT; 
            a->content_class_id = CLASSID_OBJECT;
            break;

        case CLASSID_ARRAY_STRING:  
            a->content_obj_type = ETCHTYPEB_STRING; 
            a->content_class_id = CLASSID_STRING;
            break;

        default:
            result = -1; /* indicates content type not set */
    }
    
    return result;
}


/**
 * put1()
 * insert item to singly dimensioned array
 * array access can be generalized by passing an array of subscripts; however
 * since we are currently handling max 3 dimensions, the calling sequence is 
 * much simpler when we have separate accessors for each dimensionality.
 */
int etch_nativearray_put1(etch_nativearray* a, void* value, int i) 
{
    size_t offset = etch_nativearray_off1(a, i);
    if (value == NULL || offset < 0) return -1;
    memcpy((byte*)a->values + offset, value, a->itemsize); 
    return 0;
}


/**
 * put2()
 * insert item to 2-dimensional array
 */
int etch_nativearray_put2(etch_nativearray* a, void* value, int i, int j) 
{
    size_t offset = etch_nativearray_off2(a, i, j);
    if (value == NULL || offset < 0) return -1;
    memcpy((byte*)a->values + offset, value, a->itemsize);  
    return 0;
}


/**
 * put3()
 * insert item to 3-dimensional array
 */
int etch_nativearray_put3(etch_nativearray* a, void* value, int i, int j, int k) 
{
    size_t offset = etch_nativearray_off3(a, i, j, k);
    if (value == NULL || offset < 0) return -1;
    memcpy((byte*)a->values + offset, value, a->itemsize); 
    return 0;
}


/**
 * get1()
 * access and return item from singly dimensioned array
 */
int etch_nativearray_get1(etch_nativearray* a, void* value, int i) 
{
    size_t offset = etch_nativearray_off1(a, i);
    if (value == NULL || offset < 0) return -1;
    memcpy(value, (byte*)a->values + offset, a->itemsize); 
    return 0;
}


/**
 * get2()
 * access and return item from 2-dimensional array
 */
int etch_nativearray_get2(etch_nativearray* a, void* value, int i, int j) 
{
    size_t offset = etch_nativearray_off2(a, i, j);
    if (value == NULL || offset < 0) return -1;
    memcpy(value, (byte*)a->values + offset, a->itemsize); 
    return 0;
}


/**
 * get3()
 * access and return item from 3-dimensional array
 */
int etch_nativearray_get3(etch_nativearray* a, void* value, int i, int j, int k) 
{
    size_t offset = etch_nativearray_off3(a, i, j, k);
    if (value == NULL || offset < 0) return -1;
    memcpy(value, (byte*)a->values + offset, a->itemsize); 
    return 0;
}


/*
 * etch_nativearray_off1() 
 * calculate byte offset into byte vector for a 1-dimension array
 */
size_t etch_nativearray_off1(etch_nativearray* a, int i)
{
    size_t offset = 0;    
    if (i >= (int) a->dimension[0] || i < 0) return -1; 

    offset = i * a->dimsize[0];
    return offset;
}


/*
 * etch_nativearray_off2() 
 * calculate byte offset into byte vector for a 2-dimension array
 */
size_t etch_nativearray_off2(etch_nativearray* a, int i, int j)
{
    size_t offset = 0;    
    if ((i >= (int) a->dimension[1] || i < 0)  
     || (j >= (int) a->dimension[0] || j < 0)) return -1; 

    offset = (i * a->dimsize[1]) + (j * a->dimsize[0]);
    return offset;
}


/*
 * etch_nativearray_off3() 
 * calculate byte offset into byte vector for a 3-dimension array
 */
size_t etch_nativearray_off3(etch_nativearray* a, int i, int j, int k)
{
    size_t offset = 0;    
    if ((i >= (int) a->dimension[2] || i < 0)  
     || (j >= (int) a->dimension[1] || j < 0)   
     || (k >= (int) a->dimension[0] || k < 0)) return -1; 

    offset = (i * a->dimsize[2]) + (j * a->dimsize[1]) + (k * a->dimsize[0]);
    return offset;
}


/** 
 * etch_nativearray_get_wrapped_component()
 * get wrapped component[i] from the single-dimensioned native array.
 * caller owns returned object.
 * todo: test that if array content was wrapped, the is_value_owned
 * setting is sufficient for tranparent memory management of returned object.
 */
int etch_nativearray_get_wrapped_component(etch_nativearray* a, const int i, etch_object** out)
{
    const int numentries = (int) a->dimension[0];
    const int is_wrapped_content = a->content_class_id != 0;
    int result = 0;
    union
    { char  vbyte; short  vint16; int   vint32; int64 vint64; 
      float vfloat;double vdouble;void* vaddr;  int64 all;
    } v;

    if (a->numdims != 1 || i >= numentries) return -1;
    v.all = 0;

    if (is_wrapped_content)
    {   /* content of the native array is wrapped, e.g, etch_object*,   
         * so we return the item as is */   
         result = a->get1(a, &v.vaddr, i);
         *out = v.vaddr;        
    }
    else 
    {
       
        
        switch(a->content_obj_type)
        {   /* content of the native array is unwrapped, e.g, int[], so we wrap   
             * the array item with an etch object prior to returning it */
            case ETCHTYPEB_BYTE: 
                 result = a->get1(a, &v.vbyte, i);
                 *out = (etch_object*) new_byte(v.vbyte);
                 break;
      
            case ETCHTYPEB_BOOL: 
                 result = a->get1(a, &v.vbyte, i);
                 *out = (etch_object*) new_boolean(v.vbyte);
                 break;   

            case ETCHTYPEB_INT8: 
                 result = a->get1(a, &v.vbyte, i);
                 *out = (etch_object*) new_int8(v.vbyte);
                 break; 
         
            case ETCHTYPEB_INT16:  
                 result = a->get1(a, &v.vint16, i);
                 *out = (etch_object*) new_int16(v.vint16);
                 break; 

            case ETCHTYPEB_INT32: 
                 result = a->get1(a, &v.vint32, i);
                 *out = (etch_object*) new_int32(v.vint32);
                 break; 

            case ETCHTYPEB_INT64: 
                 result = a->get1(a, &v.vint64, i);
                 *out = (etch_object*) new_int64(v.vint64);
                 break;  

            case ETCHTYPEB_IEEE32:  
                 result = a->get1(a, &v.vfloat, i);
                 *out = (etch_object*) new_float(v.vfloat);
                 break;      

            case ETCHTYPEB_IEEE64:
                 result = a->get1(a, &v.vdouble, i);
                 *out = (etch_object*) new_double(v.vdouble);
                 break; 

            case ETCHTYPEB_STRING: 
                 result = a->get1(a, &v.vaddr, i);
                 *out = (etch_object*) new_stringw(v.vaddr);
		 printf("warning\n");
                 break; 

            default: /* item is an anonymous pointer to a value owned by caller */
            {    
                result = a->get1(a, &v.vaddr, i);   
                *out = (etch_object*) v.vaddr;
            } 
        }
        /*
        if(out && *out && ! a->is_content_owned)
           set_etchobj_static_content((*out));
        */
    }  /* switch(a->content_obj_type) */ 

    return result;
}