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


#include <GroupView.h>
#include <util/OpenHashTable.h>

#include "table/TreeTable.h"

#include "ExpressionInfo.h"


class ActionMenuItem;
class CpuState;
class SettingsMenu;
class StackFrame;
class Thread;
class Type;
class TypeComponentPath;
class ValueLocation;
class ValueNode;
class ValueNodeChild;
class ValueNodeContainer;
class ValueNodeManager;
class Value;
class Variable;
class VariableEditWindow;
class VariablesViewState;
class VariablesViewStateHistory;


class VariablesView : public BGroupView, private TreeTableListener,
        private ExpressionInfo::Listener {
public:
        class Listener;

public:
                                                                VariablesView(Listener* listener);
                                                                ~VariablesView();

        static  VariablesView*          Create(Listener* listener,
                                                                        ValueNodeManager* manager);
                                                                        // throws

                        void                            SetStackFrame(Thread* thread,
                                                                        StackFrame* stackFrame);

        virtual void                            MessageReceived(BMessage* message);

        virtual void                            DetachedFromWindow();

                        void                            LoadSettings(const BMessage& settings);
                        status_t                        SaveSettings(BMessage& settings);

                        void                            SetStackFrameClearPending();

private:
        // TreeTableListener
        virtual void                            TreeTableNodeExpandedChanged(TreeTable* table,
                                                                        const TreeTablePath& path, bool expanded);
        virtual void                            TreeTableNodeInvoked(TreeTable* table,
                                                                        const TreeTablePath& path);
        virtual void                            TreeTableCellMouseDown(TreeTable* table,
                                                                        const TreeTablePath& path,
                                                                        int32 columnIndex, BPoint screenWhere,
                                                                        uint32 buttons);

        // ExpressionInfo::Listener
        virtual void                            ExpressionEvaluated(ExpressionInfo* info,
                                                                        status_t result, ExpressionResult* value);

private:
                        class ContainerListener;
                        class ExpressionVariableID;
                        class ModelNode;
                        class VariableValueColumn;
                        class VariableTableModel;
                        class ContextMenu;
                        class TableCellContextMenuTracker;
                        class VariablesExpressionInfo;
                        typedef BObjectList<ActionMenuItem> ContextActionList;
                        typedef BObjectList<ExpressionInfo> ExpressionInfoList;
                        typedef BObjectList<ValueNodeChild> ExpressionChildList;

                        struct FunctionKey;
                        struct ExpressionInfoEntry;
                        struct ExpressionInfoEntryHashDefinition;

                        typedef BOpenHashTable<ExpressionInfoEntryHashDefinition>
                                ExpressionInfoTable;

private:
                        void                            _Init(ValueNodeManager* manager);

                        void                            _RequestNodeValue(ModelNode* node);
                        status_t                        _GetContextActionsForNode(ModelNode* node,
                                                                        ContextActionList*& _preActions,
                                                                        ContextActionList*& _postActions);
                        status_t                        _AddContextAction(const char* action,
                                                                        uint32 what, ContextActionList* actions,
                                                                        BMessage*& _message);
                        status_t                        _CreateContextAction(const char* action,
                                                                        uint32 what, ActionMenuItem*& _item);
                        status_t                        _AddTypeHandlerMenuIfNeeded(ModelNode* node,
                                                                        ContextActionList* actions);
                        void                            _FinishContextMenu(bool force);
                        void                            _SaveViewState(bool updateValues) const;
                        void                            _RestoreViewState();
                        status_t                        _AddViewStateDescendentNodeInfos(
                                                                        VariablesViewState* viewState,
                                                                        void* parent,
                                                                        TreeTablePath& path,
                                                                        bool updateValues) const;
                        status_t                        _ApplyViewStateDescendentNodeInfos(
                                                                        VariablesViewState* viewState,
                                                                        void* parent,
                                                                        TreeTablePath& path);
                        void                            _CopyVariableValueToClipboard();

                        status_t                        _AddExpression(const char* expression,
                                                                        bool persistentExpression,
                                                                        ExpressionInfo*& _info);
                        void                            _RemoveExpression(ModelNode* node);

                        void                            _RestoreExpressionNodes();

                        void                            _AddExpressionNode(ExpressionInfo* info,
                                                                        status_t result, ExpressionResult* value);

                        void                            _HandleTypecastResult(status_t result,
                                                                        ExpressionResult* value);

                        void                            _HandleEditVariableRequest(ModelNode* node,
                                                                        Value* value);

                        status_t                        _GetTypeForTypeCode(int32 typeCode,
                                                                        Type*& _resultType) const;

private:
                        Thread*                         fThread;
                        StackFrame*                     fStackFrame;
                        TreeTable*                      fVariableTable;
                        VariableTableModel*     fVariableTableModel;
                        ContainerListener*      fContainerListener;
                        VariablesViewState*     fPreviousViewState;
                        VariablesViewStateHistory* fViewStateHistory;
                        ExpressionInfoTable* fExpressions;
                        ExpressionChildList     fExpressionChildren;
                        TableCellContextMenuTracker* fTableCellContextMenuTracker;
                        VariablesExpressionInfo* fPendingTypecastInfo;
                        ExpressionInfo*         fTemporaryExpression;
                        bool                            fFrameClearPending;
                        VariableEditWindow*     fEditWindow;
                        Listener*                       fListener;
};


class VariablesView::Listener {
public:
        virtual                                         ~Listener();

        virtual void                            ValueNodeValueRequested(CpuState* cpuState,
                                                                        ValueNodeContainer* container,
                                                                        ValueNode* valueNode) = 0;

        virtual void                            ExpressionEvaluationRequested(
                                                                        ExpressionInfo* info,
                                                                        StackFrame* frame,
                                                                        Thread* thread) = 0;

        virtual void                            ValueNodeWriteRequested(
                                                                        ValueNode* node,
                                                                        CpuState* state,
                                                                        Value* newValue) = 0;

};


#endif  // VARIABLES_VIEW_H