/*
 * Copyright 2004-2018, Axel Dörfler, axeld@pinc-software.de.
 * All rights reserved. Distributed under the terms of the MIT license.
 */
#ifndef DATA_EDITOR_H
#define DATA_EDITOR_H


#include <File.h>
#include <Entry.h>
#include <Locker.h>
#include <ObjectList.h>


class BHandler;
class BLooper;
class BMessage;
class BMessenger;

class DataChange;
class StateWatcher;


class DataEditor : public BLocker {
public:
                                                                DataEditor();
                                                                DataEditor(entry_ref& ref,
                                                                        const char* attribute = NULL);
                                                                DataEditor(BEntry& entry,
                                                                        const char* attribute = NULL);
                                                                DataEditor(const DataEditor& editor);
        virtual                                         ~DataEditor();

                        status_t                        SetTo(const char* path,
                                                                        const char* attribute = NULL);
                        status_t                        SetTo(entry_ref &ref,
                                                                        const char* attribute = NULL);
                        status_t                        SetTo(BEntry &entry,
                                                                        const char* attribute = NULL);

                        status_t                        Save();

                        bool                            IsReadOnly() const { return fIsReadOnly; }
                        bool                            IsDevice() const { return fIsDevice; }
                        bool                            IsAttribute() const
                                                                        { return fAttribute != NULL; }
                        bool                            IsModified() const
                                                                        { return fLastChange != fFirstChange; }

                        const char*                     Attribute() const { return fAttribute; }
                        type_code                       Type() const { return fType; }

                        status_t                        InitCheck();

                        status_t                        Replace(off_t offset, const uint8* data,
                                                                        size_t length);
                        status_t                        Remove(off_t offset, off_t length);
                        status_t                        Insert(off_t offset, const uint8* data,
                                                                        size_t length);

                        status_t                        MoveBy(int32 bytes);
                        status_t                        MoveTo(off_t offset);

                        status_t                        Undo();
                        status_t                        Redo();

                        bool                            CanUndo() const;
                        bool                            CanRedo() const;

                        status_t                        SetFileSize(off_t size);
                        off_t                           FileSize() const { return fSize; }

                        status_t                        SetViewOffset(off_t offset);
                        off_t                           ViewOffset() const { return fViewOffset; }

                        status_t                        SetViewSize(size_t size);
                        size_t                          ViewSize() const { return fViewSize; }

                        status_t                        SetBlockSize(size_t size);
                        size_t                          BlockSize() const { return fBlockSize; }

                        status_t                        UpdateIfNeeded(bool* _updated = NULL);
                        status_t                        ForceUpdate();
                        status_t                        GetViewBuffer(const uint8** _buffer);

                        status_t                        StartWatching(BMessenger target);
                        status_t                        StartWatching(BHandler* handler,
                                                                        BLooper* looper = NULL);
                        void                            StopWatching(BMessenger target);
                        void                            StopWatching(BHandler* handler,
                                                                        BLooper* looper = NULL);

                        off_t                           Find(off_t startPosition, const uint8* data,
                                                                        size_t dataSize, bool caseInsensitive,
                                                                        bool cyclic, BMessenger progressMessenger,
                                                                        volatile bool* stop = NULL);

                        BFile&                          File() { return fFile; }
                        const entry_ref&        AttributeRef() const { return fAttributeRef; }
                        const entry_ref&        Ref() const { return fRef; }

private:
        friend class StateWatcher;

                        status_t                        SetViewOffset(off_t offset, bool sendNotices);
                        status_t                        SetViewSize(size_t size, bool sendNotices);
                        void                            SendNotices(uint32 what,
                                                                        BMessage* message = NULL);
                        void                            SendNotices(DataChange* change);
                        status_t                        Update();
                        void                            AddChange(DataChange* change);
                        void                            ApplyChanges();
                        void                            RemoveRedos();

private:
                        BObjectList<BMessenger> fObservers;

                        entry_ref                       fRef;
                        entry_ref                       fAttributeRef;
                        BFile                           fFile;
                        const char*                     fAttribute;
                        type_code                       fType;
                        bool                            fIsDevice;
                        bool                            fIsReadOnly;
                        off_t                           fRealSize;
                        off_t                           fSize;

                        BObjectList<DataChange> fChanges;
                        DataChange*                     fFirstChange;
                        DataChange*                     fLastChange;
                        int32                           fChangesFromSaved;

                        uint8*                          fView;
                        off_t                           fRealViewOffset;
                        off_t                           fViewOffset;
                        size_t                          fRealViewSize;
                        size_t                          fViewSize;
                        bool                            fNeedsUpdate;

                        size_t                          fBlockSize;
};


static const uint32 kMsgDataEditorStateChange = 'deSC';
static const uint32 kMsgDataEditorUpdate = 'deUp';
static const uint32 kMsgDataEditorParameterChange = 'dePC';

static const uint32 kMsgDataEditorFindProgress = 'deFP';


#endif  /* DATA_EDITOR_H */