/*
 * Copyright 2008, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef ACTIVITY_VIEW_H
#define ACTIVITY_VIEW_H


#include <map>

#include <Locker.h>
#include <Message.h>
#include <ObjectList.h>
#include <View.h>

#include "CircularBuffer.h"
#include "DataSource.h"


class BBitmap;
class BMessageRunner;
class Scale;
class SystemInfoHandler;
class ViewHistory;
struct data_item;

class DataHistory {
public:
                                                DataHistory(bigtime_t memorize, bigtime_t interval);
                                                ~DataHistory();

                        void            AddValue(bigtime_t time, int64 value);

                        int64           ValueAt(bigtime_t time);
                        int64           MaximumValue() const;
                        int64           MinimumValue() const;
                        bigtime_t       Start() const;
                        bigtime_t       End() const;

                        void            SetRefreshInterval(bigtime_t interval);
                        void            SetScale(Scale* scale);

private:
        CircularBuffer<data_item> fBuffer;
        int64                           fMinimumValue;
        int64                           fMaximumValue;
        bigtime_t                       fRefreshInterval;
        int32                           fLastIndex;
        Scale*                          fScale;
};


class ActivityView : public BView {
public:
                                                ActivityView(BRect frame, const char* name,
                                                        const BMessage* settings, uint32 resizingMode);
                                                ActivityView(const char* name,
                                                        const BMessage* settings);
                                                ActivityView(BMessage* archive);
        virtual                         ~ActivityView();

        virtual status_t        Archive(BMessage* into, bool deep = true) const;
        static  BArchivable* Instantiate(BMessage* archive);

                        status_t        SaveState(BMessage& state) const;

#ifdef __HAIKU__
                        BLayoutItem* CreateHistoryLayoutItem();
                        BLayoutItem* CreateLegendLayoutItem();
#endif

                        DataSource*     FindDataSource(const DataSource* source);
                        status_t        AddDataSource(const DataSource* source,
                                                        const BMessage* state = NULL);
                        status_t        RemoveDataSource(const DataSource* source);
                        void            RemoveAllDataSources();

                        bigtime_t       RefreshInterval() const
                                                        { return atomic_get64((int64*)&fRefreshInterval); }

protected:
        virtual void            AttachedToWindow();
        virtual void            DetachedFromWindow();

#ifdef __HAIKU__
        virtual BSize           MinSize();
#endif

        virtual void            FrameResized(float width, float height);
        virtual void            MouseDown(BPoint where);
        virtual void            MouseUp(BPoint where);
        virtual void            MouseMoved(BPoint where, uint32 transit,
                                                        const BMessage* dragMessage);

        virtual void            MessageReceived(BMessage* message);

        virtual void            Draw(BRect updateRect);

private:
                        void            _Init(const BMessage* settings);
                        ::Scale*        _ScaleFor(scale_type type);
                        void            _Refresh();
        static  status_t        _RefreshThread(void* self);
                        void            _UpdateOffscreenBitmap();
                        BView*          _OffscreenView();
                        void            _UpdateFrame();
                        BRect           _HistoryFrame() const;
                        float           _LegendHeight() const;
                        BRect           _LegendFrame() const;
                        BRect           _LegendFrameAt(BRect frame, int32 index) const;
                        BRect           _LegendColorFrameAt(BRect frame, int32 index) const;
                        float           _PositionForValue(DataSource* source,
                                                        DataHistory* values, int64 value);
                        void            _DrawHistory();
                        void            _UpdateResolution(int32 resolution,
                                                        bool broadcast = true);

private:
        class HistoryLayoutItem;
        class LegendLayoutItem;

        friend class HistoryLayoutItem;
        friend class LegendLayoutItem;

        rgb_color                       fHistoryBackgroundColor;
        rgb_color                       fLegendBackgroundColor;
        BBitmap*                        fOffscreen;
#ifdef __HAIKU__
        BLayoutItem*            fHistoryLayoutItem;
        BLayoutItem*            fLegendLayoutItem;
#endif

        mutable BLocker         fSourcesLock;
        BObjectList<DataSource> fSources;
        BObjectList<DataHistory> fValues;
        BObjectList<ViewHistory> fViewValues;
        thread_id                       fRefreshThread;
        sem_id                          fRefreshSem;
        bigtime_t                       fRefreshInterval;
        bigtime_t                       fLastRefresh;
        int32                           fDrawResolution;
        bool                            fShowLegend;
        bool                            fZooming;
        BPoint                          fZoomPoint;
        int32                           fOriginalResolution;
        SystemInfoHandler*      fSystemInfoHandler;
        std::map<scale_type, ::Scale*> fScales;
};

#endif  // ACTIVITY_VIEW_H