/*
 * Copyright 2015, Rene Gollent, rene@gollent.com.
 * Copyright 2009-2012, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "CompoundValueNode.h"

#include <new>

#include "Architecture.h"
#include "IntegerValue.h"
#include "Tracing.h"
#include "Type.h"
#include "ValueLoader.h"
#include "ValueLocation.h"
#include "ValueNodeContainer.h"


// #pragma mark - Child


class CompoundValueNode::Child : public ValueNodeChild {
public:
        Child(CompoundValueNode* parent, const BString& name)
                :
                fParent(parent),
                fName(name)
        {
        }

        virtual const BString& Name() const
        {
                return fName;
        }

        virtual ValueNode* Parent() const
        {
                return fParent;
        }

protected:
        CompoundValueNode*      fParent;
        BString                         fName;
};


// #pragma mark - BaseTypeChild


class CompoundValueNode::BaseTypeChild : public Child {
public:
        BaseTypeChild(CompoundValueNode* parent, BaseType* baseType)
                :
                Child(parent, baseType->GetType()->Name()),
                fBaseType(baseType)
        {
                fBaseType->AcquireReference();
        }

        virtual ~BaseTypeChild()
        {
                fBaseType->ReleaseReference();
        }

        virtual Type* GetType() const
        {
                return fBaseType->GetType();
        }

        virtual status_t ResolveLocation(ValueLoader* valueLoader,
                ValueLocation*& _location)
        {
                // The parent's location refers to the location of the complete
                // object. We want to extract the location of a member.
                ValueLocation* parentLocation = fParent->Location();
                if (parentLocation == NULL)
                        return B_BAD_VALUE;

                ValueLocation* location;
                status_t error = fParent->fType->ResolveBaseTypeLocation(fBaseType,
                        *parentLocation, location);
                if (error != B_OK) {
                        TRACE_LOCALS("CompoundValueNode::BaseTypeChild::ResolveLocation(): "
                                "ResolveBaseTypeLocation() failed: %s\n", strerror(error));
                        return error;
                }

                _location = location;
                return B_OK;
        }

private:
        BaseType*       fBaseType;
};


// #pragma mark - MemberChild


class CompoundValueNode::MemberChild : public Child {
public:
        MemberChild(CompoundValueNode* parent, DataMember* member)
                :
                Child(parent, member->Name()),
                fMember(member)
        {
                fMember->AcquireReference();
        }

        virtual ~MemberChild()
        {
                fMember->ReleaseReference();
        }

        virtual Type* GetType() const
        {
                return fMember->GetType();
        }

        virtual status_t ResolveLocation(ValueLoader* valueLoader,
                ValueLocation*& _location)
        {
                // The parent's location refers to the location of the complete
                // object. We want to extract the location of a member.
                ValueLocation* parentLocation = fParent->Location();
                if (parentLocation == NULL)
                        return B_BAD_VALUE;

                ValueLocation* location;
                status_t error = fParent->fType->ResolveDataMemberLocation(fMember,
                        *parentLocation, location);
                if (error != B_OK) {
                        TRACE_LOCALS("CompoundValueNode::MemberChild::ResolveLocation(): "
                                "ResolveDataMemberLocation() failed: %s\n", strerror(error));
                        return error;
                }

                _location = location;
                return B_OK;
        }

private:
        DataMember*     fMember;
};


// #pragma mark - CompoundValueNode


CompoundValueNode::CompoundValueNode(ValueNodeChild* nodeChild,
        CompoundType* type)
        :
        ValueNode(nodeChild),
        fType(type)
{
        fType->AcquireReference();
}


CompoundValueNode::~CompoundValueNode()
{
        fType->ReleaseReference();

        for (int32 i = 0; Child* child = fChildren.ItemAt(i); i++)
                child->ReleaseReference();
}


Type*
CompoundValueNode::GetType() const
{
        return fType;
}


status_t
CompoundValueNode::ResolvedLocationAndValue(ValueLoader* valueLoader,
        ValueLocation*& _location, Value*& _value)
{
        // get the location
        ValueLocation* location = NodeChild()->Location();
        if (location == NULL)
                return B_BAD_VALUE;

        location->AcquireReference();
        _location = location;
        _value = NULL;
        return B_OK;
}


status_t
CompoundValueNode::CreateChildren(TeamTypeInformation* info)
{
        if (!fChildren.IsEmpty())
                return B_OK;

        // base types
        for (int32 i = 0; BaseType* baseType = fType->BaseTypeAt(i); i++) {
                TRACE_LOCALS("  base %" B_PRId32 "\n", i);

                BaseTypeChild* child = new(std::nothrow) BaseTypeChild(this, baseType);
                if (child == NULL || !fChildren.AddItem(child)) {
                        delete child;
                        return B_NO_MEMORY;
                }

                child->SetContainer(fContainer);
        }

        // members
        for (int32 i = 0; DataMember* member = fType->DataMemberAt(i); i++) {
                TRACE_LOCALS("  member %" B_PRId32 ": \"%s\"\n", i, member->Name());

                MemberChild* child = new(std::nothrow) MemberChild(this, member);
                if (child == NULL || !fChildren.AddItem(child)) {
                        delete child;
                        return B_NO_MEMORY;
                }

                child->SetContainer(fContainer);
        }

        if (fContainer != NULL)
                fContainer->NotifyValueNodeChildrenCreated(this);

        return B_OK;
}


int32
CompoundValueNode::CountChildren() const
{
        return fChildren.CountItems();
}


ValueNodeChild*
CompoundValueNode::ChildAt(int32 index) const
{
        return fChildren.ItemAt(index);
}