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


#include "VariablesViewState.h"

#include <new>

#include "ExpressionValues.h"
#include "FunctionID.h"
#include "StackFrameValues.h"
#include "Type.h"
#include "TypeComponentPath.h"
#include "TypeHandler.h"


// #pragma mark - VariablesViewNodeInfo


VariablesViewNodeInfo::VariablesViewNodeInfo()
        :
        fNodeExpanded(false),
        fCastedType(NULL),
        fTypeHandler(NULL),
        fRendererSettings()
{
}


VariablesViewNodeInfo::VariablesViewNodeInfo(const VariablesViewNodeInfo& other)
        :
        fNodeExpanded(other.fNodeExpanded),
        fCastedType(other.fCastedType),
        fTypeHandler(other.fTypeHandler),
        fRendererSettings(other.fRendererSettings)
{
        if (fCastedType != NULL)
                fCastedType->AcquireReference();
}


VariablesViewNodeInfo::~VariablesViewNodeInfo()
{
        if (fCastedType != NULL)
                fCastedType->ReleaseReference();

        if (fTypeHandler != NULL)
                fTypeHandler->ReleaseReference();
}


VariablesViewNodeInfo&
VariablesViewNodeInfo::operator=(const VariablesViewNodeInfo& other)
{
        fNodeExpanded = other.fNodeExpanded;
        SetCastedType(other.fCastedType);
        SetTypeHandler(other.fTypeHandler);
        fRendererSettings = other.fRendererSettings;

        return *this;
}


void
VariablesViewNodeInfo::SetNodeExpanded(bool expanded)
{
        fNodeExpanded = expanded;
}


void
VariablesViewNodeInfo::SetCastedType(Type* type)
{
        if (fCastedType != NULL)
                fCastedType->ReleaseReference();

        fCastedType = type;
        if (fCastedType != NULL)
                fCastedType->AcquireReference();
}


void
VariablesViewNodeInfo::SetTypeHandler(TypeHandler* handler)
{
        if (fTypeHandler != NULL)
                fTypeHandler->ReleaseReference();

        fTypeHandler = handler;
        if (fTypeHandler != NULL)
                fTypeHandler->AcquireReference();
}


void
VariablesViewNodeInfo::SetRendererSettings(const BMessage& settings)
{
        fRendererSettings = settings;
}


// #pragma mark - Key


struct VariablesViewState::Key {
        ObjectID*                       variable;
        TypeComponentPath*      path;

        Key(ObjectID* variable, TypeComponentPath* path)
                :
                variable(variable),
                path(path)
        {
        }

        uint32 HashValue() const
        {
                return variable->HashValue() ^ path->HashValue();
        }

        bool operator==(const Key& other) const
        {
                return *variable == *other.variable && *path == *other.path;
        }
};


// #pragma mark - InfoEntry


struct VariablesViewState::InfoEntry : Key, VariablesViewNodeInfo {
        InfoEntry*      next;

        InfoEntry(ObjectID* variable, TypeComponentPath* path)
                :
                Key(variable, path)
        {
                variable->AcquireReference();
                path->AcquireReference();
        }

        ~InfoEntry()
        {
                variable->ReleaseReference();
                path->ReleaseReference();
        }

        void SetInfo(const VariablesViewNodeInfo& info)
        {
                VariablesViewNodeInfo::operator=(info);
        }
};


struct VariablesViewState::InfoEntryHashDefinition {
        typedef Key                     KeyType;
        typedef InfoEntry       ValueType;

        size_t HashKey(const Key& key) const
        {
                return key.HashValue();
        }

        size_t Hash(const InfoEntry* value) const
        {
                return value->HashValue();
        }

        bool Compare(const Key& key, const InfoEntry* value) const
        {
                return key == *value;
        }

        InfoEntry*& GetLink(InfoEntry* value) const
        {
                return value->next;
        }
};


VariablesViewState::VariablesViewState()
        :
        fNodeInfos(NULL),
        fValues(NULL),
        fExpressionValues(NULL)
{
}


VariablesViewState::~VariablesViewState()
{
        _Cleanup();
}


status_t
VariablesViewState::Init()
{
        fNodeInfos = new(std::nothrow) NodeInfoTable;
        if (fNodeInfos == NULL)
                return B_NO_MEMORY;

        return fNodeInfos->Init();
}

void
VariablesViewState::SetValues(StackFrameValues* values)
{
        if (fValues == values)
                return;

        if (fValues != NULL)
                fValues->ReleaseReference();

        fValues = values;

        if (fValues != NULL)
                fValues->AcquireReference();
}


void
VariablesViewState::SetExpressionValues(ExpressionValues* values)
{
        if (fExpressionValues == values)
                return;

        if (fExpressionValues != NULL)
                fExpressionValues->ReleaseReference();

        fExpressionValues = values;

        if (fExpressionValues != NULL)
                fExpressionValues->AcquireReference();
}


const VariablesViewNodeInfo*
VariablesViewState::GetNodeInfo(ObjectID* variable,
        const TypeComponentPath* path) const
{
        return fNodeInfos->Lookup(Key(variable, (TypeComponentPath*)path));
}


status_t
VariablesViewState::SetNodeInfo(ObjectID* variable, TypeComponentPath* path,
        const VariablesViewNodeInfo& info)
{
        InfoEntry* entry = fNodeInfos->Lookup(Key(variable, path));
        if (entry == NULL) {
                entry = new(std::nothrow) InfoEntry(variable, path);
                if (entry == NULL)
                        return B_NO_MEMORY;
                fNodeInfos->Insert(entry);
        }

        entry->SetInfo(info);
        return B_OK;
}


void
VariablesViewState::_Cleanup()
{
        if (fNodeInfos != NULL) {
                InfoEntry* entry = fNodeInfos->Clear(true);

                while (entry != NULL) {
                        InfoEntry* next = entry->next;
                        delete entry;
                        entry = next;
                }

                delete fNodeInfos;
                fNodeInfos = NULL;
        }

        SetValues(NULL);
        SetExpressionValues(NULL);
}