/*
 * 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_ke_environment_h_
#define _include_ke_environment_h_

#include "Objects.h"
#include "Handles.h"
#include "Heap.h"
#include "FixedArray.h"

namespace ke {

class EnvironmentMap;
class Variable;
class ByteArray;
class Type;

// An environment represents the lexical environment of a code or function
// object. It used for variables which may be accessed outside a function's
// normal activation (i.e., upvars).
//
// A module uses an Environment to store its global variables.
class Environment : public Object
{
    template <typename T>
    inline T *pointerToSlot(unsigned slot);

  public:
    static Environment *New(Zone *zone, Handle<EnvironmentMap> map, Heap::Tenure tenure = Heap::Tenure_Default);

    inline EnvironmentMap *map();
    inline size_t size();

    float getFloat(unsigned slot) {
        return *pointerToSlot<float>(slot);
    }
    int getInt32(unsigned slot) {
        return *pointerToSlot<int>(slot);
    }
    Object *getObject(unsigned slot) {
        return *pointerToSlot<Object *>(slot);
    }
    void setFloat(unsigned slot, float f) {
        *pointerToSlot<float>(slot) = f;
    }
    void setInt32(unsigned slot, int i) {
        *pointerToSlot<int>(slot) = i;
    }
    void setObject(unsigned slot, Object *obj) {
        // :TODO: write barrier
        *pointerToSlot<Object *>(slot) = obj;
    }

    static inline size_t offsetOfSlotOffset(unsigned offset) {
        return sizeof(Environment) + offset;
    }

    static inline Environment *cast(Object *obj) {
        assert(!obj || obj->is(MapKind_Environment));
        return reinterpret_cast<Environment *>(obj);
    }
};

struct EnvironmentSlotDescriptor
{
    Barriered<Type> type;
    unsigned offset;
};

class EnvironmentSlotDescriptorArray : public Object
{
    unsigned length_;

  public:
    static EnvironmentSlotDescriptorArray *New(Zone *zone, unsigned length);

    EnvironmentSlotDescriptor *slots() {
        return reinterpret_cast<EnvironmentSlotDescriptor *>(this + 1);
    }
    EnvironmentSlotDescriptor &at(unsigned slot) {
        assert(slot < length_);
        return slots()[slot];
    }
    unsigned length() {
        return length_;
    }
    unsigned size() {
        return Align(sizeof(*this) + length() * sizeof(EnvironmentSlotDescriptorArray),
                     kObjectAlignment);
    }

    static inline EnvironmentSlotDescriptorArray *cast(Object *obj) {
        assert(!obj || obj->is(MapKind_EnvironmentSlotDescriptorArray));
        return reinterpret_cast<EnvironmentSlotDescriptorArray *>(obj);
    }
};

class EnvironmentMap : public Map
{
    unsigned structureSize_;
    unsigned traceOffsetCount_;
    Barriered<EnvironmentSlotDescriptorArray> slots_;

  public:
    static EnvironmentMap *New(Zone *zone, unsigned nvars, Variable **vars);

    unsigned structureSize() {
        return structureSize_;
    }
    unsigned traceOffsetCount() {
        return traceOffsetCount_;
    }
    const unsigned *traceOffsets() {
        return reinterpret_cast<unsigned *>(this + 1);
    }
    size_t size() {
        return Align(sizeof(EnvironmentMap) + sizeof(unsigned) * traceOffsetCount(), kObjectAlignment);
    }
    EnvironmentSlotDescriptor &slotDescriptor(unsigned slot) {
        return slots_->at(slot);
    }

    static inline size_t offsetOfSlots() {
        return offsetof(EnvironmentMap, slots_);
    }

    static inline EnvironmentMap *cast(Object *obj) {
        assert(!obj || obj->is(MapKind_MetaEnvironment));
        return reinterpret_cast<EnvironmentMap *>(obj);
    }
};

size_t
Environment::size()
{
    return Align(sizeof(Environment) + map()->structureSize(), kObjectAlignment);
}

EnvironmentMap *
Environment::map()
{
    return EnvironmentMap::cast(Object::map());
}

template <typename T> T *
Environment::pointerToSlot(unsigned slot)
{
    return reinterpret_cast<T *>(reinterpret_cast<char *>(this + 1) + map()->slotDescriptor(slot).offset);
}

}

#endif // _include_ke_environment_h_