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

#include <map>

#include <Locker.h>
#include <StringList.h>

#include <ObjectList.h>

#include "Image.h"
#include "ImageInfo.h"
#include "TargetAddressRange.h"
#include "Thread.h"
#include "ThreadInfo.h"
#include "UserBreakpoint.h"
#include "Watchpoint.h"


// team event types
enum {
        TEAM_EVENT_TEAM_RENAMED,

        TEAM_EVENT_THREAD_ADDED,
        TEAM_EVENT_THREAD_REMOVED,
        TEAM_EVENT_IMAGE_ADDED,
        TEAM_EVENT_IMAGE_REMOVED,

        TEAM_EVENT_THREAD_STATE_CHANGED,
        TEAM_EVENT_THREAD_CPU_STATE_CHANGED,
        TEAM_EVENT_THREAD_STACK_TRACE_CHANGED,

        TEAM_EVENT_IMAGE_DEBUG_INFO_CHANGED,

        TEAM_EVENT_IMAGE_LOAD_SETTINGS_CHANGED,
        TEAM_EVENT_IMAGE_LOAD_NAME_ADDED,
        TEAM_EVENT_IMAGE_LOAD_NAME_REMOVED,

        TEAM_EVENT_DEFAULT_SIGNAL_DISPOSITION_CHANGED,
        TEAM_EVENT_CUSTOM_SIGNAL_DISPOSITION_CHANGED,
        TEAM_EVENT_CUSTOM_SIGNAL_DISPOSITION_REMOVED,

        TEAM_EVENT_CONSOLE_OUTPUT_RECEIVED,

        TEAM_EVENT_BREAKPOINT_ADDED,
        TEAM_EVENT_BREAKPOINT_REMOVED,
        TEAM_EVENT_USER_BREAKPOINT_CHANGED,

        TEAM_EVENT_WATCHPOINT_ADDED,
        TEAM_EVENT_WATCHPOINT_REMOVED,
        TEAM_EVENT_WATCHPOINT_CHANGED,

        TEAM_EVENT_DEBUG_REPORT_CHANGED,

        TEAM_EVENT_CORE_FILE_CHANGED,

        TEAM_EVENT_MEMORY_CHANGED
};


class Architecture;
class Breakpoint;
class BStringList;
class Function;
class FunctionID;
class FunctionInstance;
class LocatableFile;
class SourceCode;
class SourceLocation;
class Statement;
class TeamDebugInfo;
class TeamMemory;
class TeamTypeInformation;
class UserBreakpoint;
class Value;


typedef std::map<int32, int32> SignalDispositionMappings;


class Team {
public:
                        class Event;
                        class BreakpointEvent;
                        class ConsoleOutputEvent;
                        class DebugReportEvent;
                        class MemoryChangedEvent;
                        class ImageEvent;
                        class ImageLoadEvent;
                        class ImageLoadNameEvent;
                        class DefaultSignalDispositionEvent;
                        class CustomSignalDispositionEvent;
                        class ThreadEvent;
                        class UserBreakpointEvent;
                        class WatchpointEvent;
                        class CoreFileChangedEvent;
                        class Listener;

public:
                                                                Team(team_id teamID, TeamMemory* teamMemory,
                                                                        Architecture* architecture,
                                                                        TeamDebugInfo* debugInfo,
                                                                        TeamTypeInformation* typeInformation);
                                                                ~Team();

                        status_t                        Init();

                        bool                            Lock()          { return fLock.Lock(); }
                        void                            Unlock()        { fLock.Unlock(); }

                        team_id                         ID() const                      { return fID; }
                        TeamMemory*                     GetTeamMemory() const
                                                                        { return fTeamMemory; }
                        Architecture*           GetArchitecture() const
                                                                        { return fArchitecture; }
                        TeamDebugInfo*          DebugInfo() const       { return fDebugInfo; }
                        TeamTypeInformation*
                                                                GetTeamTypeInformation() const
                                                                        { return fTypeInformation; }

                        const char*                     Name() const    { return fName.String(); }
                        void                            SetName(const BString& name);

                        void                            AddThread(::Thread* thread);
                        status_t                        AddThread(const ThreadInfo& threadInfo,
                                                                        ::Thread** _thread = NULL);
                        void                            RemoveThread(::Thread* thread);
                        bool                            RemoveThread(thread_id threadID);
                        ::Thread*                       ThreadByID(thread_id threadID) const;
                        const ThreadList&       Threads() const;

                        status_t                        AddImage(const ImageInfo& imageInfo,
                                                                        LocatableFile* imageFile,
                                                                        Image** _image = NULL);
                        void                            RemoveImage(Image* image);
                        bool                            RemoveImage(image_id imageID);
                        Image*                          ImageByID(image_id imageID) const;
                        Image*                          ImageByAddress(target_addr_t address) const;
                        const ImageList&        Images() const;
                        void                            ClearImages();

                        bool                            AddStopImageName(const BString& name);
                        void                            RemoveStopImageName(const BString& name);
                        const BStringList&      StopImageNames() const;

                        void                            SetStopOnImageLoad(bool enabled,
                                                                        bool useImageNameList);
                        bool                            StopOnImageLoad() const
                                                                        { return fStopOnImageLoad; }
                        bool                            StopImageNameListEnabled() const
                                                                        { return fStopImageNameListEnabled; }

                        void                            SetDefaultSignalDisposition(int32 disposition);
                        int32                           DefaultSignalDisposition() const
                                                                        { return fDefaultSignalDisposition; }
                        bool                            SetCustomSignalDisposition(int32 signal,
                                                                        int32 disposition);
                        void                            RemoveCustomSignalDisposition(int32 signal);
                        int32                           SignalDispositionFor(int32 signal) const;
                                                                        // if no custom disposition is found,
                                                                        // returns default
                        const SignalDispositionMappings&
                                                                GetSignalDispositionMappings() const;

                        void                            ClearSignalDispositionMappings();

                        bool                            AddBreakpoint(Breakpoint* breakpoint);
                                                                        // takes over reference (also on error)
                        void                            RemoveBreakpoint(Breakpoint* breakpoint);
                                                                        // releases its own reference
                        int32                           CountBreakpoints() const;
                        Breakpoint*                     BreakpointAt(int32 index) const;
                        Breakpoint*                     BreakpointAtAddress(
                                                                        target_addr_t address) const;
                        void                            GetBreakpointsInAddressRange(
                                                                        TargetAddressRange range,
                                                                        BObjectList<UserBreakpoint>& breakpoints)
                                                                                const;
                        void                            GetBreakpointsForSourceCode(
                                                                        SourceCode* sourceCode,
                                                                        BObjectList<UserBreakpoint>& breakpoints)
                                                                                const;

                        void                            AddUserBreakpoint(
                                                                        UserBreakpoint* userBreakpoint);
                        void                            RemoveUserBreakpoint(
                                                                        UserBreakpoint* userBreakpoint);
                        const UserBreakpointList& UserBreakpoints() const
                                                                        { return fUserBreakpoints; }

                        bool                            AddWatchpoint(Watchpoint* watchpoint);
                                                                        // takes over reference (also on error)
                        void                            RemoveWatchpoint(Watchpoint* watchpoint);
                                                                        // releases its own reference
                        int32                           CountWatchpoints() const;
                        Watchpoint*                     WatchpointAt(int32 index) const;
                        Watchpoint*                     WatchpointAtAddress(
                                                                        target_addr_t address) const;
                        void                            GetWatchpointsInAddressRange(
                                                                        TargetAddressRange range,
                                                                        BObjectList<Watchpoint>& watchpoints)
                                                                                const;
                        const WatchpointList& Watchpoints() const
                                                                        { return fWatchpoints; }

                        status_t                        GetStatementAtAddress(target_addr_t address,
                                                                        FunctionInstance*& _function,
                                                                        Statement*& _statement);
                                                                        // returns a reference to the statement,
                                                                        // not to the functions instance, though,
                                                                        // caller must lock
                        status_t                        GetStatementAtSourceLocation(
                                                                        SourceCode* sourceCode,
                                                                        const SourceLocation& location,
                                                                        Statement*& _statement);
                                                                        // returns a reference to the statement
                                                                        // (any matching statement!),
                                                                        // caller must lock,

                        Function*                       FunctionByID(FunctionID* functionID) const;

                        void                            AddListener(Listener* listener);
                        void                            RemoveListener(Listener* listener);

                        // service methods for Thread
                        void                            NotifyThreadStateChanged(::Thread* thread);
                        void                            NotifyThreadCpuStateChanged(::Thread* thread);
                        void                            NotifyThreadStackTraceChanged(
                                                                        ::Thread* thread);

                        // service methods for Image
                        void                            NotifyImageDebugInfoChanged(Image* image);

                        // service methods for Image load settings
                        void                            NotifyStopOnImageLoadChanged(bool enabled,
                                                                        bool useImageNameList);
                        void                            NotifyStopImageNameAdded(const BString& name);
                        void                            NotifyStopImageNameRemoved(
                                                                        const BString& name);

                        // service methods for Signal Disposition settings
                        void                            NotifyDefaultSignalDispositionChanged(
                                                                        int32 newDisposition);
                        void                            NotifyCustomSignalDispositionChanged(
                                                                        int32 signal, int32 disposition);
                        void                            NotifyCustomSignalDispositionRemoved(
                                                                        int32 signal);

                        // service methods for console output
                        void                            NotifyConsoleOutputReceived(
                                                                        int32 fd, const BString& output);

                        // breakpoint related service methods
                        void                            NotifyUserBreakpointChanged(
                                                                        UserBreakpoint* breakpoint);

                        // watchpoint related service methods
                        void                            NotifyWatchpointChanged(
                                                                        Watchpoint* watchpoint);

                        // debug report related service methods
                        void                            NotifyDebugReportChanged(
                                                                        const char* reportPath, status_t result);

                        // core file related service methods
                        void                            NotifyCoreFileChanged(
                                                                        const char* targetPath);

                        // memory write related service methods
                        void                            NotifyMemoryChanged(target_addr_t address,
                                                                        target_size_t size);

private:
                        struct BreakpointByAddressPredicate;
                        struct WatchpointByAddressPredicate;

                        typedef BObjectList<Breakpoint> BreakpointList;
                        typedef DoublyLinkedList<Listener> ListenerList;

private:
                        void                            _NotifyTeamRenamed();
                        void                            _NotifyThreadAdded(::Thread* thread);
                        void                            _NotifyThreadRemoved(::Thread* thread);
                        void                            _NotifyImageAdded(Image* image);
                        void                            _NotifyImageRemoved(Image* image);

private:
                        BLocker                         fLock;
                        team_id                         fID;
                        TeamMemory*                     fTeamMemory;
                        TeamTypeInformation*
                                                                fTypeInformation;
                        Architecture*           fArchitecture;
                        TeamDebugInfo*          fDebugInfo;
                        BString                         fName;
                        ThreadList                      fThreads;
                        ImageList                       fImages;
                        bool                            fStopOnImageLoad;
                        bool                            fStopImageNameListEnabled;
                        BStringList                     fStopImageNames;
                        int32                           fDefaultSignalDisposition;
                        SignalDispositionMappings
                                                                fCustomSignalDispositions;
                        BreakpointList          fBreakpoints;
                        WatchpointList          fWatchpoints;
                        UserBreakpointList      fUserBreakpoints;
                        ListenerList            fListeners;
};


class Team::Event {
public:
                                                                Event(uint32 type, Team* team);

                        uint32                          EventType() const       { return fEventType; }
                        Team*                           GetTeam() const         { return fTeam; }

protected:
                        uint32                          fEventType;
                        Team*                           fTeam;
};


class Team::ThreadEvent : public Event {
public:
                                                                ThreadEvent(uint32 type, ::Thread* thread);

                        ::Thread*                       GetThread() const       { return fThread; }

protected:
                        ::Thread*                       fThread;
};


class Team::ImageEvent : public Event {
public:
                                                                ImageEvent(uint32 type, Image* image);

                        Image*                          GetImage() const        { return fImage; }

protected:
                        Image*                          fImage;
};


class Team::ImageLoadEvent : public Event {
public:
                                                                ImageLoadEvent(uint32 type, Team* team,
                                                                        bool stopOnImageLoad,
                                                                        bool stopImageNameListEnabled);

                        bool                            StopOnImageLoad() const
                                                                        { return fStopOnImageLoad; }
                        bool                            StopImageNameListEnabled() const
                                                                        { return fStopImageNameListEnabled; }

private:
                        bool                            fStopOnImageLoad;
                        bool                            fStopImageNameListEnabled;
};


class Team::ImageLoadNameEvent : public Event {
public:
                                                                ImageLoadNameEvent(uint32 type, Team* team,
                                                                        const BString& name);

                        const BString&          ImageName() const { return fImageName; }

private:
                        BString                         fImageName;
};


class Team::DefaultSignalDispositionEvent : public Event {
public:
                                                                DefaultSignalDispositionEvent(uint32 type,
                                                                        Team* team, int32 disposition);

                        int32                           DefaultDisposition() const
                                                                        { return fDefaultDisposition; }

private:
                        int32                           fDefaultDisposition;
};


class Team::CustomSignalDispositionEvent : public Event {
public:
                                                                CustomSignalDispositionEvent(uint32 type,
                                                                        Team* team, int32 signal,
                                                                        int32 disposition);

                        int32                           Signal() const { return fSignal; }
                        int32                           Disposition() const { return fDisposition; }

private:
                        int32                           fSignal;
                        int32                           fDisposition;
};


class Team::BreakpointEvent : public Event {
public:
                                                                BreakpointEvent(uint32 type, Team* team,
                                                                        Breakpoint* breakpoint);

                        Breakpoint*                     GetBreakpoint() const   { return fBreakpoint; }

protected:
                        Breakpoint*                     fBreakpoint;
};


class Team::ConsoleOutputEvent : public Event {
public:
                                                                ConsoleOutputEvent(uint32 type, Team* team,
                                                                        int32 fd, const BString& output);

                        int32                           Descriptor() const      { return fDescriptor; }
                        const BString&          Output() const          { return fOutput; }

protected:
                        int32                           fDescriptor;
                        BString                         fOutput;
};


class Team::DebugReportEvent : public Event {
public:
                                                                DebugReportEvent(uint32 type, Team* team,
                                                                        const char* reportPath,
                                                                        status_t finalStatus);

                        const char*                     GetReportPath() const   { return fReportPath; }
                        status_t                        GetFinalStatus() const  { return fFinalStatus; }
protected:
                        const char*                     fReportPath;
                        status_t                        fFinalStatus;
};


class Team::CoreFileChangedEvent : public Event {
public:
                                                                CoreFileChangedEvent(uint32 type, Team* team,
                                                                        const char* targetPath);
                        const char*                     GetTargetPath() const   { return fTargetPath; }
protected:
                        const char*                     fTargetPath;
};


class Team::MemoryChangedEvent : public Event {
public:
                                                                MemoryChangedEvent(uint32 type, Team* team,
                                                                        target_addr_t address, target_size_t size);

                        target_addr_t           GetTargetAddress() const
                                                                        { return fTargetAddress; }

                        target_size_t           GetSize() const { return fSize; }
protected:
                        target_addr_t           fTargetAddress;
                        target_size_t           fSize;
};


class Team::WatchpointEvent : public Event {
public:
                                                                WatchpointEvent(uint32 type, Team* team,
                                                                        Watchpoint* watchpoint);

                        Watchpoint*                     GetWatchpoint() const   { return fWatchpoint; }

protected:
                        Watchpoint*                     fWatchpoint;
};


class Team::UserBreakpointEvent : public Event {
public:
                                                                UserBreakpointEvent(uint32 type, Team* team,
                                                                        UserBreakpoint* breakpoint);

                        UserBreakpoint*         GetBreakpoint() const   { return fBreakpoint; }

protected:
                        UserBreakpoint*         fBreakpoint;
};


class Team::Listener : public DoublyLinkedListLinkImpl<Team::Listener> {
public:
        virtual                                         ~Listener();

        virtual void                            TeamRenamed(
                                                                        const Team::Event& event);

        virtual void                            ThreadAdded(const Team::ThreadEvent& event);
        virtual void                            ThreadRemoved(const Team::ThreadEvent& event);

        virtual void                            ImageAdded(const Team::ImageEvent& event);
        virtual void                            ImageRemoved(const Team::ImageEvent& 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                            StopOnImageLoadSettingsChanged(
                                                                        const Team::ImageLoadEvent& event);
        virtual void                            StopOnImageLoadNameAdded(
                                                                        const Team::ImageLoadNameEvent& event);
        virtual void                            StopOnImageLoadNameRemoved(
                                                                        const Team::ImageLoadNameEvent& event);

        virtual void                            DefaultSignalDispositionChanged(
                                                                        const Team::DefaultSignalDispositionEvent&
                                                                                event);
        virtual void                            CustomSignalDispositionChanged(
                                                                        const Team::CustomSignalDispositionEvent&
                                                                                event);
        virtual void                            CustomSignalDispositionRemoved(
                                                                        const Team::CustomSignalDispositionEvent&
                                                                                event);

        virtual void                            ConsoleOutputReceived(
                                                                        const Team::ConsoleOutputEvent& event);

        virtual void                            BreakpointAdded(
                                                                        const Team::BreakpointEvent& event);
        virtual void                            BreakpointRemoved(
                                                                        const Team::BreakpointEvent& event);
        virtual void                            UserBreakpointChanged(
                                                                        const Team::UserBreakpointEvent& event);

        virtual void                            WatchpointAdded(
                                                                        const Team::WatchpointEvent& event);
        virtual void                            WatchpointRemoved(
                                                                        const Team::WatchpointEvent& event);
        virtual void                            WatchpointChanged(
                                                                        const Team::WatchpointEvent& event);

        virtual void                            DebugReportChanged(
                                                                        const Team::DebugReportEvent& event);

        virtual void                            CoreFileChanged(
                                                                        const Team::CoreFileChangedEvent& event);

        virtual void                            MemoryChanged(
                                                                        const Team::MemoryChangedEvent& event);
};


#endif  // TEAM_H