/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "VariablesViewStateHistory.h"

#include <new>

#include "FunctionID.h"
#include "VariablesViewState.h"


// #pragma mark - Key


struct VariablesViewStateHistory::Key {
        thread_id       threadID;
        FunctionID*     functionID;

        Key(thread_id threadID, FunctionID* functionID)
                :
                threadID(threadID),
                functionID(functionID)
        {
        }

        uint32 HashValue() const
        {
                return functionID->HashValue() ^ threadID;
        }

        bool operator==(const Key& other) const
        {
                return threadID == other.threadID && *functionID == *other.functionID;
        }
};


// #pragma mark - StateEntry


struct VariablesViewStateHistory::StateEntry : Key, VariablesViewNodeInfo {
        StateEntry*                     next;
        VariablesViewState*     state;

        StateEntry(thread_id threadID, FunctionID* functionID)
                :
                Key(threadID, functionID),
                state(NULL)
        {
                functionID->AcquireReference();
        }

        ~StateEntry()
        {
                functionID->ReleaseReference();
                if (state != NULL)
                        state->ReleaseReference();
        }

        void SetState(VariablesViewState* state)
        {
                if (state == this->state)
                        return;

                if (state != NULL)
                        state->AcquireReference();

                if (this->state != NULL)
                        this->state->ReleaseReference();

                this->state = state;
        }
};


struct VariablesViewStateHistory::StateEntryHashDefinition {
        typedef Key                     KeyType;
        typedef StateEntry      ValueType;

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

        size_t Hash(const StateEntry* value) const
        {
                return HashKey(*value);
        }

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

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


VariablesViewStateHistory::VariablesViewStateHistory()
        :
        fStates(NULL)
{
}


VariablesViewStateHistory::~VariablesViewStateHistory()
{
        if (fStates != NULL) {
                StateEntry* entry = fStates->Clear(true);

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

                delete fStates;
        }
}


status_t
VariablesViewStateHistory::Init()
{
        fStates = new(std::nothrow) StateTable;
        if (fStates == NULL)
                return B_NO_MEMORY;

        return fStates->Init();
}


VariablesViewState*
VariablesViewStateHistory::GetState(thread_id threadID, FunctionID* functionID)
        const
{
        // first try an exact match with the thread ID
        if (threadID >= 0) {
                StateEntry* stateEntry = fStates->Lookup(Key(threadID, functionID));
                if (stateEntry != NULL)
                        return stateEntry->state;
        }

        // just match the function ID
        StateEntry* stateEntry = fStates->Lookup(Key(-1, functionID));
        return stateEntry != NULL ? stateEntry->state : NULL;
}


VariablesViewState*
VariablesViewStateHistory::GetState(FunctionID* functionID) const
{
        StateEntry* stateEntry = fStates->Lookup(Key(-1, functionID));
        return stateEntry != NULL ? stateEntry->state : NULL;
}


status_t
VariablesViewStateHistory::SetState(thread_id threadID, FunctionID* functionID,
        VariablesViewState* state)
{
        // Make sure the default entry for the function exists.
        StateEntry* defaultEntry = fStates->Lookup(Key(-1, functionID));
        bool newDefaultEntry = false;

        if (defaultEntry == NULL) {
                defaultEntry = new(std::nothrow) StateEntry(-1, functionID);
                if (defaultEntry == NULL)
                        return B_NO_MEMORY;
                fStates->Insert(defaultEntry);
                newDefaultEntry = true;
        }

        // If we have a valid thread ID, make sure the respective entry for the
        // function exists.
        StateEntry* threadEntry = NULL;
        if (threadID >= 0) {
                threadEntry = fStates->Lookup(Key(threadID, functionID));

                if (threadEntry == NULL) {
                        threadEntry = new(std::nothrow) StateEntry(threadID, functionID);
                        if (threadEntry == NULL) {
                                if (newDefaultEntry) {
                                        fStates->Remove(defaultEntry);
                                        delete defaultEntry;
                                }
                                return B_NO_MEMORY;
                        }
                        fStates->Insert(threadEntry);
                }
        }

        defaultEntry->SetState(state);
        if (threadEntry != NULL)
                threadEntry->SetState(state);

        return B_OK;
}