/*
 * Copyright (C) 2012 David Anderson
 *
 * This file is part of JITCraft.
 *
 * JITCraft is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free
 * Software Foundation, either version 3 of the License, or (at your option)
 * any later version.
 * 
 * Foobar 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 for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * JITCraft. If not, see http://www.gnu.org/licenses/.
 */
#ifndef _include_jitcraft_array_h_
#define _include_jitcraft_array_h_

#include "Heap.h"
#include "Handles.h"
#include "Types.h"

namespace ke {

class ArrayMap;

class Array : public Object
{
    friend class ArrayMap;

    uint32 nelements_;
    void *elements_;

  public:
    static Array *New(Zone *zone, Handle<ArrayMap> map, uint32 elements,
                      Heap::Tenure = Heap::Tenure_Default);
    static Array *NewExternal(Zone *zone, Handle<ArrayMap> map, uint32 nelements,
                              void *elements, Heap::Tenure = Heap::Tenure_Default);

    uint32 nelements() {
        return nelements_;
    }
    void *vec() {
        return elements_;
    }

    inline int *int32Vec();
    inline float *floatVec();
    inline Object **objVec();
    inline char *chars();

    inline Type *type();
    inline size_t elementSize();

    int readInt32(size_t index) {
        assert(index < nelements());
        return int32Vec()[index];
    }
    void writeInt32(size_t index, int i) {
        assert(index < nelements());
        int32Vec()[index] = i;
    }
    char readChar(size_t index) {
        assert(index < nelements());
        return chars()[index];
    }
    void writeChar(size_t index, char c) {
        assert(index < nelements());
        chars()[index] = c;
    }
    float readFloat(size_t index) {
        assert(index < nelements());
        return floatVec()[index];
    }
    void writeFloat(size_t index, float f) {
        assert(index < nelements());
        floatVec()[index] = f;
    }
    inline void *slotPtr(size_t index);
    Object *readObject(size_t index) {
        assert(index < nelements());
        return objVec()[index];
    }
    void writeObject(Zone *zone, size_t index, Object *ptr) {
        assert(index < nelements());
        write(zone, &objVec()[index], ptr);
    }

    bool isExternal() {
        // Inline arrays always have their elements pointing at the next slot.
        Address buffer = reinterpret_cast<Address>(elements_);
        return buffer != reinterpret_cast<Address>(this + 1);
    }

    static inline size_t SizeOf(Array *array) {
        if (array->isExternal())
            return sizeof(Array);
        return sizeof(Array) + array->nelements() * array->elementSize();
    }

    static Array *cast(Object *obj) {
        assert(!obj || obj->is(MapKind_Array));
        return reinterpret_cast<Array *>(obj);
    }
};

class ArrayMap : public Map
{
    Barriered<Type> type_;
    Barriered<ArrayMap> contained_;

  public:
    static ArrayMap *New(Zone *zone, Handle<Type> type, Handle<ArrayMap> contained);

    Type *type() {
        return type_;
    }
    ArrayMap *contained() {
        return contained_;
    }

    // GC Descriptor.
    static inline size_t offsetOfType() {
        return OFFSETOF(ArrayMap, type_);
    }
    static inline size_t offsetOfContained() {
        return OFFSETOF(ArrayMap, contained_);
    }
    // End GC Descriptor.
    
    static ArrayMap *cast(Object *obj) {
        assert(!obj || obj->is(MapKind_MetaArray));
        return reinterpret_cast<ArrayMap *>(obj);
    }
};

inline int *
Array::int32Vec()
{
    assert(type()->levels() == 1);
    assert(type()->contained()->isInt32());
    return reinterpret_cast<int *>(vec());
}

inline float *
Array::floatVec()
{
    assert(type()->levels() == 1);
    assert(type()->contained()->isFloat());
    return reinterpret_cast<float *>(vec());
}

inline Object **
Array::objVec()
{
    assert(type()->levels() > 1);
    return reinterpret_cast<Object **>(vec());
}

inline void *
Array::slotPtr(size_t index)
{
    assert(type()->contained()->primitive() == PrimitiveType_Int32 ||
           type()->contained()->primitive() == PrimitiveType_Float);
    assert(index < nelements());
    return reinterpret_cast<int *>(vec()) + index;
}

inline char *
Array::chars()
{
    assert(type()->levels() == 1);
    assert(type()->contained()->primitive() == PrimitiveType_Char);
    return reinterpret_cast<char *>(vec());
}

inline Type *
Array::type()
{
    return ArrayMap::cast(map())->type();
}

inline size_t
Array::elementSize()
{
    assert(type()->isArray());
    if (type()->contained()->isArray())
        return sizeof(Object *);
    switch (type()->contained()->primitive()) {
      case PrimitiveType_Float:
        return sizeof(float);
      case PrimitiveType_Int32:
        return sizeof(int);
      default:
        assert(type()->contained()->primitive() == PrimitiveType_Char);
        return sizeof(char);
    }
}

}

#endif // _include_jitcraft_array_h_