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


#include <String.h>
#include <Window.h>

#include <util/OpenHashTable.h>

#include "BreakpointsView.h"
#include "Function.h"
#include "GuiTeamUiSettings.h"
#include "ImageFunctionsView.h"
#include "ImageListView.h"
#include "SourceView.h"
#include "StackFrame.h"
#include "StackTraceView.h"
#include "Team.h"
#include "ThreadListView.h"
#include "VariablesView.h"


class BButton;
class BFilePanel;
class BMenuBar;
class BMessageRunner;
class BSplitView;
class BStringList;
class BStringView;
class BTabView;
class ConsoleOutputView;
class BreakpointEditWindow;
class ExpressionEvaluationWindow;
class ExpressionPromptWindow;
class Image;
class InspectorWindow;
class RegistersView;
class SourceCode;
class SourceLanguage;
class StackFrame;
class TeamSettingsWindow;
class Type;
class UserBreakpoint;
class UserInterfaceListener;
class VariablesView;


class TeamWindow : public BWindow, ThreadListView::Listener,
        ImageListView::Listener, StackTraceView::Listener,
        ImageFunctionsView::Listener, BreakpointsView::Listener,
        SourceView::Listener, VariablesView::Listener, Team::Listener,
        Function::Listener, StackFrame::Listener {
public:
                                                                TeamWindow(::Team* team,
                                                                        UserInterfaceListener* listener);
                                                                ~TeamWindow();

        static  TeamWindow*                     Create(::Team* team,
                                                                        UserInterfaceListener* listener);
                                                                        // throws

        virtual void                            DispatchMessage(BMessage* message,
                                                                        BHandler* handler);
        virtual void                            MessageReceived(BMessage* message);
        virtual bool                            QuitRequested();

                        status_t                        LoadSettings(
                                                                        const GuiTeamUiSettings* settings);
                        status_t                        SaveSettings(
                                                                        GuiTeamUiSettings* settings);

                        void                            DisplayBackgroundStatus(const char* message);


private:
        enum ActiveSourceObject {
                ACTIVE_SOURCE_NONE,
                ACTIVE_SOURCE_STACK_FRAME,
                ACTIVE_SOURCE_FUNCTION,
                ACTIVE_SOURCE_BREAKPOINT
        };

        struct ThreadStackFrameSelectionKey;
        struct ThreadStackFrameSelectionEntry;
        struct ThreadStackFrameSelectionEntryHashDefinition;

        typedef BOpenHashTable<ThreadStackFrameSelectionEntryHashDefinition>
                ThreadStackFrameSelectionInfoTable;


private:
        // ThreadListView::Listener
        virtual void                            ThreadSelectionChanged(::Thread* thread);

        // ImageListView::Listener
        virtual void                            ImageSelectionChanged(Image* image);

        // StackTraceView::Listener
        virtual void                            StackFrameSelectionChanged(StackFrame* frame);

        // ImageFunctionsView::Listener
        virtual void                            FunctionSelectionChanged(
                                                                        FunctionInstance* function);

        // BreakpointsView::Listener
        virtual void                            BreakpointSelectionChanged(
                                                                        BreakpointProxyList& proxies);
        virtual void                            SetBreakpointEnabledRequested(
                                                                        UserBreakpoint* breakpoint,
                                                                        bool enabled);
        virtual void                            ClearBreakpointRequested(
                                                                        UserBreakpoint* breakpoint);

        virtual void                            SetWatchpointEnabledRequested(
                                                                        Watchpoint* breakpoint,
                                                                        bool enabled);
        virtual void                            ClearWatchpointRequested(
                                                                        Watchpoint* watchpoint);


        // SourceView::Listener
        virtual void                            SetBreakpointRequested(target_addr_t address,
                                                                        bool enabled);
        virtual void                            ClearBreakpointRequested(
                                                                        target_addr_t address);
        virtual void                            ThreadActionRequested(::Thread* thread,
                                                                        uint32 action, target_addr_t address);
        virtual void                            FunctionSourceCodeRequested(
                                                                        FunctionInstance* function,
                                                                        bool forceDisassembly);


        // VariablesView::Listener
        virtual void                            ValueNodeValueRequested(CpuState* cpuState,
                                                                        ValueNodeContainer* container,
                                                                        ValueNode* valueNode);
        virtual void                            ExpressionEvaluationRequested(
                                                                        ExpressionInfo* info,
                                                                        StackFrame* frame,
                                                                        ::Thread* thread);
        virtual void                            ValueNodeWriteRequested(ValueNode* node,
                                                                        CpuState* state, Value* value);

        // Team::Listener
        virtual void                            TeamRenamed(const Team::Event& event);
        virtual void                            ThreadStateChanged(
                                                                        const Team::ThreadEvent& event);
        virtual void                            ThreadCpuStateChanged(
                                                                        const Team::ThreadEvent& event);
        virtual void                            ThreadStackTraceChanged(
                                                                        const Team::ThreadEvent& event);
        virtual void                            ImageDebugInfoChanged(
                                                                        const Team::ImageEvent& event);
        virtual void                            ConsoleOutputReceived(
                                                                        const Team::ConsoleOutputEvent& event);
        virtual void                            UserBreakpointChanged(
                                                                        const Team::UserBreakpointEvent& event);
        virtual void                            WatchpointChanged(
                                                                        const Team::WatchpointEvent& event);
        virtual void                            DebugReportChanged(
                                                                        const Team::DebugReportEvent& event);
        virtual void                            CoreFileChanged(
                                                                        const Team::CoreFileChangedEvent& event);


        // Function::Listener
        virtual void                            FunctionSourceCodeChanged(Function* function);

                        void                            _Init();

                        void                            _LoadSettings(
                                                                        const GuiTeamUiSettings* settings);

                        void                            _UpdateTitle();
                        void                            _SetActiveThread(::Thread* thread);
                        void                            _SetActiveImage(Image* image);
                        void                            _SetActiveStackTrace(StackTrace* stackTrace);
                        void                            _SetActiveStackFrame(StackFrame* frame);
                        void                            _SetActiveBreakpoint(
                                                                        UserBreakpoint* breakpoint);
                        void                            _SetActiveFunction(FunctionInstance* function,
                                                                        bool searchForFrame = true);
                        void                            _SetActiveSourceCode(SourceCode* sourceCode);
                        void                            _UpdateCpuState();
                        void                            _UpdateRunButtons();
                        void                            _UpdateSourcePathState();
                        void                            _ScrollToActiveFunction();

                        void                            _HandleThreadStateChanged(thread_id threadID);
                        void                            _HandleCpuStateChanged(thread_id threadID);
                        void                            _HandleStackTraceChanged(thread_id threadID);
                        void                            _HandleImageDebugInfoChanged(image_id imageID);
                        void                            _HandleSourceCodeChanged();
                        void                            _HandleUserBreakpointChanged(
                                                                        UserBreakpoint* breakpoint);
                        void                            _HandleWatchpointChanged(
                                                                        Watchpoint* watchpoint);

        static  status_t                        _RetrieveMatchingSourceWorker(void* arg);
                        void                            _HandleResolveMissingSourceFile(entry_ref&
                                                                        locatedPath);
                        void                            _HandleLocateSourceRequest(
                                                                        BStringList* entries = NULL);
        static  status_t                        _RetrieveMatchingSourceEntries(
                                                                        const BString& path,
                                                                        BStringList* _entries);

                        status_t                        _SaveInspectorSettings(
                                                                        const BMessage* settings);

                        status_t                        _GetActiveSourceLanguage(
                                                                        SourceLanguage*& _language);

private:
                        ::Team*                         fTeam;
                        ::Thread*                       fActiveThread;
                        Image*                          fActiveImage;
                        StackTrace*                     fActiveStackTrace;
                        StackFrame*                     fActiveStackFrame;
                        ThreadStackFrameSelectionInfoTable*
                                                                fThreadSelectionInfoTable;
                        UserBreakpoint*         fActiveBreakpoint;
                        FunctionInstance*       fActiveFunction;
                        SourceCode*                     fActiveSourceCode;
                        ActiveSourceObject      fActiveSourceObject;
                        UserInterfaceListener* fListener;
                        BMessageRunner*         fTraceUpdateRunner;
                        BTabView*                       fTabView;
                        BTabView*                       fLocalsTabView;
                        ThreadListView*         fThreadListView;
                        ImageListView*          fImageListView;
                        ImageFunctionsView*     fImageFunctionsView;
                        BreakpointsView*        fBreakpointsView;
                        VariablesView*          fVariablesView;
                        RegistersView*          fRegistersView;
                        StackTraceView*         fStackTraceView;
                        SourceView*                     fSourceView;
                        BButton*                        fRunButton;
                        BButton*                        fStepOverButton;
                        BButton*                        fStepIntoButton;
                        BButton*                        fStepOutButton;
                        BMenuBar*                       fMenuBar;
                        BStringView*            fSourcePathView;
                        BStringView*            fStatusBarView;
                        ConsoleOutputView*      fConsoleOutputView;
                        BSplitView*                     fFunctionSplitView;
                        BSplitView*                     fSourceSplitView;
                        BSplitView*                     fImageSplitView;
                        BSplitView*                     fThreadSplitView;
                        BSplitView*                     fConsoleSplitView;
                        TeamSettingsWindow*     fTeamSettingsWindow;
                        BreakpointEditWindow* fBreakpointEditWindow;
                        InspectorWindow*        fInspectorWindow;
                        ExpressionEvaluationWindow* fExpressionEvalWindow;
                        ExpressionPromptWindow* fExpressionPromptWindow;
                        GuiTeamUiSettings       fUiSettings;
                        BFilePanel*                     fFilePanel;
                        thread_id                       fActiveSourceWorker;
};


#endif  // TEAM_WINDOW_H