/*
 * Copyright 2004-2007, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include "DataEditor.h"

#include <Autolock.h>
#include <NodeMonitor.h>
#include <Debug.h>
#include <Directory.h>
#include <Drivers.h>
#include <fs_attr.h>
#include <fs_info.h>

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#include <errno.h>


#ifdef TRACE
#       undef TRACE
#endif

//#define TRACE_DATA_EDITOR
#ifdef TRACE_DATA_EDITOR
#       define TRACE(x) printf x
#else
#       define TRACE(x) ;
#endif


class StateWatcher {
        public:
                StateWatcher(DataEditor &editor);
                ~StateWatcher();

        private:
                DataEditor      &fEditor;
                bool            fCouldUndo;
                bool            fCouldRedo;
                bool            fWasModified;
};

class DataChange {
        public:
                virtual ~DataChange();

                virtual void Apply(off_t offset, uint8 *buffer, size_t size) = 0;
                virtual void Revert(off_t offset, uint8 *buffer, size_t size) = 0;
                virtual bool Merge(DataChange *change);
                virtual void GetRange(off_t fileSize, off_t &_offset, off_t &_size) = 0;
};

class ReplaceChange : public DataChange {
        public:
                ReplaceChange(off_t offset, const uint8 *data, size_t size);
                ~ReplaceChange();

                virtual void Apply(off_t offset, uint8 *buffer, size_t size);
                virtual void Revert(off_t offset, uint8 *buffer, size_t size);
                virtual bool Merge(DataChange *change);
                virtual void GetRange(off_t fileSize, off_t &_offset, off_t &_size);

        private:
                void Normalize(off_t bufferOffset, size_t bufferSize,
                        off_t &offset, size_t &dataOffset, size_t &size);

                uint8   *fNewData;
                uint8   *fOldData;
                size_t  fSize;
                off_t   fOffset;
};


//---------------------


#ifdef TRACE_DATA_EDITOR

#define DUMPED_BLOCK_SIZE 16

static void
dump_block(const uint8 *buffer, int size, const char *prefix)
{
        for (int i = 0; i < size;) {
                int start = i;

                printf(prefix);
                for (; i < start + DUMPED_BLOCK_SIZE; i++) {
                        if (!(i % 4))
                                printf(" ");

                        if (i >= size)
                                printf("  ");
                        else
                                printf("%02x", *(unsigned char *)(buffer + i));
                }
                printf("  ");

                for (i = start; i < start + DUMPED_BLOCK_SIZE; i++) {
                        if (i < size) {
                                char c = buffer[i];

                                if (c < 30)
                                        printf(".");
                                else
                                        printf("%c", c);
                        } else
                                break;
                }
                printf("\n");
        }
}
#endif  // TRACE_DATA_EDITOR


static int
CompareCaseInsensitive(const uint8 *a, const uint8 *b, size_t size)
{
        for (size_t i = 0; i < size; i++) {
                uint8 diff = tolower(a[i]) - tolower(b[i]);
                if (diff)
                        return diff;
        }

        return 0;
}


static int
CompareOffsets(const off_t *a, const off_t *b)
{
        if (*a < *b)
                return -1;
        else if (*a > *b)
                return 1;

        return 0;
}


//      #pragma mark -


StateWatcher::StateWatcher(DataEditor &editor)
        :
        fEditor(editor)
{
        fCouldUndo = editor.CanUndo();
        fCouldRedo = editor.CanRedo();
        fWasModified = editor.IsModified();
}


StateWatcher::~StateWatcher()
{
        BMessage update;
        if (fCouldRedo != fEditor.CanRedo())
                update.AddBool("can_redo", fEditor.CanRedo());
        if (fCouldUndo != fEditor.CanUndo())
                update.AddBool("can_undo", fEditor.CanUndo());
        if (fWasModified != fEditor.IsModified())
                update.AddBool("modified", fEditor.IsModified());

        // only send an update if we have to report anything
        if (!update.IsEmpty())
                fEditor.SendNotices(kMsgDataEditorStateChange, &update);
}


//      #pragma mark -


DataChange::~DataChange()
{
}


bool
DataChange::Merge(DataChange *change)
{
        return false;
}


//      #pragma mark -


ReplaceChange::ReplaceChange(off_t offset, const uint8 *data, size_t size)
{
        fOffset = offset;

        fNewData = (uint8 *)malloc(size);
        fOldData = (uint8 *)malloc(size);
        if (fNewData != NULL && fOldData != NULL) {
                memcpy(fNewData, data, size);
                fSize = size;
        } else
                fSize = 0;
}


ReplaceChange::~ReplaceChange()
{
        free(fNewData);
        free(fOldData);
}


/** Normalizes the supplied offset & size pair to be limited by
 *      the buffer offset and size.
 *      All parameters must have been initialized before calling this
 *      method.
 */

void
ReplaceChange::Normalize(off_t bufferOffset, size_t bufferSize, off_t &offset,
        size_t &dataOffset, size_t &size)
{
        if (fOffset < bufferOffset) {
                offset = bufferOffset;
                dataOffset = bufferOffset - fOffset;
                size -= dataOffset;
        }

        if (offset + size > bufferOffset + bufferSize)
                size = bufferOffset + bufferSize - offset;
}


void
ReplaceChange::Apply(off_t bufferOffset, uint8 *buffer, size_t bufferSize)
{
        // is it in our range?
        if (fOffset > (bufferOffset + (off_t)bufferSize)
                || (fOffset + (off_t)fSize) < bufferOffset) {
                return;
        }

        // don't change anything outside the supplied buffer
        off_t offset = fOffset;
        size_t dataOffset = 0;
        size_t size = fSize;
        Normalize(bufferOffset, bufferSize, offset, dataOffset, size);
        if (size == 0)
                return;

#ifdef TRACE_DATA_EDITOR
        printf("Apply %p (buffer offset = %lld):\n", this, bufferOffset);
        dump_block(buffer + offset - bufferOffset, size, "old:");
        dump_block(fNewData + dataOffset, size, "new:");
#endif

        // now we can safely exchange the buffer!
        memcpy(fOldData + dataOffset, buffer + offset - bufferOffset, size);
        memcpy(buffer + offset - bufferOffset, fNewData + dataOffset, size);
}


void
ReplaceChange::Revert(off_t bufferOffset, uint8 *buffer, size_t bufferSize)
{
        // is it in our range?
        if (fOffset - bufferOffset > (off_t)bufferSize
                || fOffset + (off_t)fSize < bufferOffset) {
                return;
        }

        // don't change anything outside the supplied buffer
        off_t offset = fOffset;
        size_t dataOffset = 0;
        size_t size = fSize;
        Normalize(bufferOffset, bufferSize, offset, dataOffset, size);
        if (size == 0)
                return;

#ifdef TRACE_DATA_EDITOR
        printf("Revert %p (buffer offset = %lld):\n", this, bufferOffset);
        dump_block(buffer + offset - bufferOffset, size, "old:");
        dump_block(fOldData + dataOffset, size, "new:");
#endif

        // now we can safely revert the buffer!
        memcpy(buffer + offset - bufferOffset, fOldData + dataOffset, size);
}


bool
ReplaceChange::Merge(DataChange *_change)
{
        ReplaceChange *change = dynamic_cast<ReplaceChange *>(_change);
        if (change == NULL)
                return false;

        if (change->fOffset + change->fSize == fOffset + fSize
                && change->fSize == 1) {
                // this is a special case - the new change changed the last byte of
                // the old change: we do this since the same byte is changed twice
                // in hex mode editing.
                fNewData[fSize - 1] = change->fNewData[0];
#ifdef TRACE_DATA_EDITOR
                printf("Merge one byte %p (offset = %lld, size = %lu):\n", this, fOffset,
                        fSize);
                dump_block(fOldData, fSize, "old:");
                dump_block(fNewData, fSize, "new:");
#endif
                return true;
        }

        // are the changes adjacent?

        if (change->fOffset + (off_t)change->fSize != fOffset
                && fOffset + (off_t)fSize != change->fOffset)
                return false;

        // okay, we can try to merge the two changes

        uint8 *newData = fOffset < change->fOffset ? fNewData : change->fNewData;
        size_t size = fSize + change->fSize;

        if ((newData = (uint8 *)realloc(newData, size)) == NULL)
                return false;

        uint8 *oldData = fOffset < change->fOffset ? fOldData : change->fOldData;
        if ((oldData = (uint8 *)realloc(oldData, size)) == NULL) {
                fNewData = (uint8 *)realloc(newData, fSize);
                        // if this fails, we can't do anything about it
                return false;
        }

        if (fOffset < change->fOffset) {
                memcpy(newData + fSize, change->fNewData, change->fSize);
                memcpy(oldData + fSize, change->fOldData, change->fSize);
        } else {
                memcpy(newData + change->fSize, fNewData, fSize);
                memcpy(oldData + change->fSize, fOldData, fSize);
                change->fNewData = fNewData;
                change->fOldData = fOldData;
                        // transfer ownership, so that they will be deleted with the change
                fOffset = change->fOffset;
        }

        fNewData = newData;
        fOldData = oldData;
        fSize = size;

#ifdef TRACE_DATA_EDITOR
        printf("Merge %p (offset = %lld, size = %lu):\n", this, fOffset, fSize);
        dump_block(fOldData, fSize, "old:");
        dump_block(fNewData, fSize, "new:");
#endif

        return true;
}


void
ReplaceChange::GetRange(off_t /*fileSize*/, off_t &_offset, off_t &_size)
{
        _offset = fOffset;
        _size = fSize;
}


//      #pragma mark -


DataEditor::DataEditor()
        :
        BLocker("data view"),
        fAttribute(NULL)
{
}


DataEditor::DataEditor(entry_ref &ref, const char *attribute)
        :
        BLocker("data view"),
        fAttribute(NULL)
{
        SetTo(ref, attribute);
}


DataEditor::DataEditor(BEntry &entry, const char *attribute)
        :
        BLocker("data view"),
        fAttribute(NULL)
{
        SetTo(entry, attribute);
}


DataEditor::DataEditor(const DataEditor &editor)
        :
        BLocker("data view"),
        fAttribute(NULL)
{
}


DataEditor::~DataEditor()
{
        free((void*)fAttribute);
}


status_t
DataEditor::SetTo(const char *path, const char *attribute)
{
        BEntry entry(path);
        return SetTo(entry, attribute);
}


status_t
DataEditor::SetTo(entry_ref &ref, const char *attribute)
{
        BEntry entry(&ref);
        return SetTo(entry, attribute);
}


status_t
DataEditor::SetTo(BEntry &entry, const char *attribute)
{
        fSize = 0;
        fLastChange = fFirstChange = NULL;
        fChangesFromSaved = 0;
        fView = NULL;
        fRealViewOffset = 0;
        fViewOffset = 0;
        fRealViewSize = fViewSize = fBlockSize = 512;

        free((void*)fAttribute);
        if (attribute != NULL)
                fAttribute = strdup(attribute);
        else
                fAttribute = NULL;

        struct stat stat;
        status_t status = entry.GetStat(&stat);
        if (status < B_OK)
                return status;

        entry.GetRef(&fAttributeRef);

        bool isFileSystem = false;

        if (entry.IsDirectory()) {
                // we redirect root directories to their volumes
                BDirectory directory(&entry);
                if (directory.InitCheck() == B_OK && directory.IsRootDirectory()) {
                        fs_info info;
                        if (fs_stat_dev(stat.st_dev, &info) != 0)
                                return errno;

                        status = entry.SetTo(info.device_name);
                        if (status < B_OK)
                                return status;

                        entry.GetStat(&stat);

                        fBlockSize = info.block_size;
                        if (fBlockSize > 0 && fBlockSize <= 65536)
                                isFileSystem = true;
                }
        }

        status = fFile.SetTo(&entry, B_READ_WRITE);
        if (status < B_OK) {
                // try to open read only
                status = fFile.SetTo(&entry, B_READ_ONLY);
                if (status < B_OK)
                        return status;

                fIsReadOnly = true;
        } else
                fIsReadOnly = false;

        entry.GetRef(&fRef);
        fIsDevice = S_ISBLK(stat.st_mode) || S_ISCHR(stat.st_mode);

        if (IsAttribute()) {
                BNode node(&fAttributeRef);
                attr_info info;
                status = node.GetAttrInfo(fAttribute, &info);
                if (status != B_OK) {
                        fFile.Unset();
                        return status;
                }

                fSize = info.size;
                fType = info.type;
        } else if (fIsDevice) {
                device_geometry geometry;
                int device = fFile.Dup();
                if (device < 0 || ioctl(device, B_GET_GEOMETRY, &geometry,
                                sizeof(geometry)) < 0) {
                        if (device >= 0)
                                close(device);
                        fFile.Unset();
                        return B_ERROR;
                }
                close(device);

                fSize = 1LL * geometry.head_count * geometry.cylinder_count
                        * geometry.sectors_per_track * geometry.bytes_per_sector;
                if (fSize < 0)
                        fSize = 0;
                if (!isFileSystem)
                        fBlockSize = geometry.bytes_per_sector;
        } else if (entry.IsDirectory() || entry.IsSymLink()) {
                fSize = 0;
                fIsReadOnly = true;
        } else {
                status = fFile.GetSize(&fSize);
                if (status < B_OK) {
                        fFile.Unset();
                        return status;
                }
        }

        if (fBlockSize == 0)
                fBlockSize = 512;

        fRealViewSize = fViewSize = fBlockSize;
        fNeedsUpdate = true;

        return B_OK;
}


status_t
DataEditor::InitCheck()
{
        return fFile.InitCheck();
}


void
DataEditor::AddChange(DataChange *change)
{
        if (change == NULL)
                return;

        StateWatcher watcher(*this);
                // update state observers

        RemoveRedos();
        change->Apply(fRealViewOffset, fView, fRealViewSize);

        SendNotices(change);
                // update observers

        // try to join changes
        if (fLastChange == NULL || !fLastChange->Merge(change)) {
                fChanges.AddItem(change);
                fLastChange = change;
                fChangesFromSaved++;
        } else
                delete change;
}


status_t
DataEditor::Replace(off_t offset, const uint8 *data, size_t length)
{
        if (IsReadOnly())
                return B_NOT_ALLOWED;

        BAutolock locker(this);

        if (offset >= fSize)
                return B_BAD_VALUE;
        if (offset + (off_t)length > fSize)
                length = fSize - offset;

        if (fNeedsUpdate) {
                status_t status = Update();
                if (status < B_OK)
                        return status;
        }

        ReplaceChange *change = new ReplaceChange(offset, data, length);
        AddChange(change);

        return B_OK;
}


status_t
DataEditor::Remove(off_t offset, off_t length)
{
        if (IsReadOnly())
                return B_NOT_ALLOWED;

        BAutolock locker(this);

        // not yet implemented
        // ToDo: this needs some changes to the whole change mechanism

        return B_ERROR;
}


status_t
DataEditor::Insert(off_t offset, const uint8 *text, size_t length)
{
        if (IsReadOnly())
                return B_NOT_ALLOWED;

        BAutolock locker(this);

        // not yet implemented
        // ToDo: this needs some changes to the whole change mechanism

        return B_ERROR;
}


void
DataEditor::ApplyChanges()
{
        if (fLastChange == NULL && fFirstChange == NULL)
                return;

        int32 firstIndex = fFirstChange != NULL ? fChanges.IndexOf(fFirstChange) + 1
                : 0;
        int32 lastIndex = fChanges.IndexOf(fLastChange);

        if (fChangesFromSaved >= 0) {
                // ascend changes
                TRACE(("ApplyChanges(): ascend from %ld to %ld\n", firstIndex,
                        lastIndex));

                for (int32 i = firstIndex; i <= lastIndex; i++) {
                        DataChange *change = fChanges.ItemAt(i);
                        change->Apply(fRealViewOffset, fView, fRealViewSize);
                }
        } else {
                // descend changes
                TRACE(("ApplyChanges(): descend from %ld to %ld\n", firstIndex - 1,
                        lastIndex));

                for (int32 i = firstIndex - 1; i > lastIndex; i--) {
                        DataChange *change = fChanges.ItemAt(i);
                        change->Revert(fRealViewOffset, fView, fRealViewSize);
                }
        }
}


status_t
DataEditor::Save()
{
        BAutolock locker(this);

        if (!IsModified())
                return B_OK;

        StateWatcher watcher(*this);

        // Do we need to ascend or descend the list of changes?

        int32 firstIndex = fFirstChange != NULL ? fChanges.IndexOf(fFirstChange) + 1
                : 0;
        int32 lastIndex = fChanges.IndexOf(fLastChange);
        if (fChangesFromSaved < 0 && firstIndex != lastIndex) {
                // swap indices
                ASSERT(firstIndex > lastIndex);

                int32 temp = firstIndex - 1;
                firstIndex = lastIndex;
                lastIndex = temp;
        }

        if (firstIndex < 0)
                firstIndex = 0;
        if (lastIndex > fChanges.CountItems() - 1)
                lastIndex = fChanges.CountItems();

        // Collect ranges of data we need to write.

        // ToDo: This is a very simple implementation and could be drastically
        // improved by having items that save ranges, not just offsets. If Insert()
        // and Remove() are going to be implemented, it should be improved that
        // way to reduce the memory footprint to something acceptable.

        BObjectList<off_t> list;
        for (int32 i = firstIndex; i <= lastIndex; i++) {
                DataChange *change = fChanges.ItemAt(i);

                off_t offset, size;
                change->GetRange(FileSize(), offset, size);
                offset -= offset % BlockSize();

                while (size > 0) {
                        list.BinaryInsertCopyUnique(offset, CompareOffsets);
                        offset += BlockSize();
                        size -= BlockSize();
                }
        }

        // read in data and apply changes, write it back to disk

        off_t oldOffset = fViewOffset;

        for (int32 i = 0; i < list.CountItems(); i++) {
                off_t offset = *list.ItemAt(i);

                // load the data into our view
                SetViewOffset(offset, false);

                if (fNeedsUpdate) {
                        status_t status = Update();
                        if (status < B_OK)
                                return status;
                }

                // save back to disk

                // don't try to change the file size
                size_t size = fRealViewSize;
                if (fRealViewOffset + (off_t)fRealViewSize > (off_t)fSize)
                        size = fSize - fRealViewOffset;

                ssize_t bytesWritten;
                if (IsAttribute()) {
                        bytesWritten = fFile.WriteAttr(fAttribute, fType, fRealViewOffset,
                                fView, size);
                } else
                        bytesWritten = fFile.WriteAt(fRealViewOffset, fView, size);

                if (bytesWritten < B_OK)
                        return bytesWritten;
        }

        // update state

        SetViewOffset(oldOffset, false);
        if (fNeedsUpdate)
                Update();

        fChangesFromSaved = 0;
        fFirstChange = fLastChange;

        return B_OK;
}


/** This method will be called by DataEditor::AddChange()
 *      immediately before a change is applied.
 *      It removes all pending redo nodes from the list that would
 *      come after the current change.
 */

void
DataEditor::RemoveRedos()
{
        int32 start = fChanges.IndexOf(fLastChange) + 1;

        for (int32 i = fChanges.CountItems(); i-- > start; ) {
                DataChange *change = fChanges.RemoveItemAt(i);
                delete change;
        }
}


status_t
DataEditor::Undo()
{
        BAutolock locker(this);

        if (!CanUndo())
                return B_ERROR;

        StateWatcher watcher(*this);
                // update state observers

        DataChange *undoChange = fLastChange;

        int32 index = fChanges.IndexOf(undoChange);
        fChangesFromSaved--;
        undoChange->Revert(fRealViewOffset, fView, fRealViewSize);

        if (index > 0)
                fLastChange = fChanges.ItemAt(index - 1);
        else
                fLastChange = NULL;

        // update observers
        SendNotices(undoChange);

        return B_OK;
}


status_t
DataEditor::Redo()
{
        BAutolock locker(this);

        if (!CanRedo())
                return B_ERROR;

        StateWatcher watcher(*this);
                // update state observers

        int32 index = fChanges.IndexOf(fLastChange);
        fLastChange = fChanges.ItemAt(index + 1);
        fChangesFromSaved++;

        fLastChange->Apply(fRealViewOffset, fView, fRealViewSize);

        // update observers
        SendNotices(fLastChange);

        return B_OK;
}


bool
DataEditor::CanUndo() const
{
        return fLastChange != NULL;
}


bool
DataEditor::CanRedo() const
{
        return fChanges.IndexOf(fLastChange) < fChanges.CountItems() - 1;
}


status_t
DataEditor::SetFileSize(off_t size)
{
        // ToDo: implement me!
        //fSize = size;
        //return B_OK;
        return B_ERROR;
}


status_t
DataEditor::SetViewOffset(off_t offset, bool sendNotices)
{
        BAutolock locker(this);

        if (fView == NULL) {
                status_t status = SetViewSize(fViewSize);
                if (status < B_OK)
                        return status;
        }

        if (offset < 0 || offset > fSize)
                return B_BAD_VALUE;

        offset = (offset / fViewSize) * fViewSize;
        if (offset == fViewOffset)
                return B_OK;

        fViewOffset = offset;
        fRealViewOffset = (fViewOffset / fBlockSize) * fBlockSize;
        fNeedsUpdate = true;

        if (sendNotices) {
                BMessage update;
                update.AddInt64("offset", fViewOffset);
                SendNotices(kMsgDataEditorParameterChange, &update);
        }

        return B_OK;
}


status_t
DataEditor::SetViewOffset(off_t offset)
{
        return SetViewOffset(offset, true);
}


status_t
DataEditor::SetViewSize(size_t size, bool sendNotices)
{
        BAutolock locker(this);

        size_t realSize = (size + fBlockSize - 1) & ~(fBlockSize - 1);
                // round to the next multiple of block size

        if (realSize == fRealViewSize && fViewSize == size && fView != NULL)
                return B_OK;

        if (realSize == 0)
                return B_BAD_VALUE;

        if (realSize != fRealViewSize || fView == NULL) {
                uint8 *view = (uint8 *)realloc(fView, realSize);
                if (view == NULL)
                        return B_NO_MEMORY;

                fView = view;
                fRealViewSize = realSize;
        }

        fViewSize = size;
        fNeedsUpdate = true;

        // let's correct the view offset if necessary
        if (fViewOffset % size)
                SetViewOffset(fViewOffset);

        if (sendNotices) {
                BMessage update;
                update.AddInt32("view_size", size);
                SendNotices(kMsgDataEditorParameterChange, &update);
        }

        return B_OK;
}


status_t
DataEditor::SetViewSize(size_t size)
{
        return SetViewSize(size, true);
}


status_t
DataEditor::SetBlockSize(size_t size)
{
        BAutolock locker(this);

        fBlockSize = size;
        status_t status = SetViewOffset(fViewOffset, false);
                // this will trigger an update of the real view offset
        if (status == B_OK)
                status = SetViewSize(fViewSize, false);

        BMessage update;
        update.AddInt32("block_size", size);
        update.AddInt64("offset", fViewOffset);
        SendNotices(kMsgDataEditorParameterChange, &update);

        return status;
}


status_t
DataEditor::Update()
{
        ssize_t bytesRead;
        if (IsAttribute()) {
                BNode node(&fAttributeRef);
                bytesRead = node.ReadAttr(fAttribute, fType, fRealViewOffset, fView,
                        fRealViewSize);
        } else
                bytesRead = fFile.ReadAt(fRealViewOffset, fView, fRealViewSize);

        if (bytesRead < B_OK)
                return bytesRead;

        if ((size_t)bytesRead < fRealViewSize) {
                // make sure the rest of data is cleared
                memset(fView + bytesRead, 0, fRealViewSize - bytesRead);
        }

        ApplyChanges();
        fNeedsUpdate = false;

        return B_OK;
}


status_t
DataEditor::UpdateIfNeeded(bool *_updated)
{
        if (!fNeedsUpdate) {
                if (_updated)
                        *_updated = false;
                return B_OK;
        }

        status_t status = B_OK;

        if (fView == NULL)
                status = SetViewOffset(fViewOffset);

        if (status == B_OK && fNeedsUpdate) {
                status = Update();
                if (status == B_OK && _updated)
                        *_updated = true;
        }

        return status;
}


status_t
DataEditor::ForceUpdate()
{
        BAutolock locker(this);

        status_t status = B_OK;

        off_t newSize = fSize;
        if (IsAttribute()) {
                // update attribute size (we ignore the type for now)
                attr_info info;
                status = fFile.GetAttrInfo(fAttribute, &info);
                if (status != B_OK) {
                        // The attribute may have just been removed before
                        // it gets rewritten, so we don't do anything
                        // else here (we just set the file size to 0)
                        newSize = 0;
                } else
                        newSize = info.size;
        } else if (!IsDevice()) {
                // update file size

                if (fFile.GetSize(&newSize) != B_OK)
                        return B_ERROR;
        }

        if (fSize != newSize) {
                fSize = newSize;

                // update observers
                BMessage update;
                update.AddInt64("file_size", newSize);
                SendNotices(kMsgDataEditorParameterChange, &update);
        }

        if (fView == NULL)
                status = SetViewOffset(fViewOffset);
        else {
                BMessage update;
                update.AddInt64("offset", fViewOffset);
                update.AddInt64("size", fViewSize);
                SendNotices(kMsgDataEditorUpdate, &update);
        }

        if (status == B_OK)
                status = Update();

        return status;
}


status_t
DataEditor::GetViewBuffer(const uint8 **_buffer)
{
        if (!IsLocked())
                debugger("DataEditor: view not locked");

        status_t status = UpdateIfNeeded();
        if (status != B_OK)
                return status;
        if (fView == NULL)
                return B_NO_INIT;

        *_buffer = fView + fViewOffset - fRealViewOffset;
        return B_OK;
}


off_t
DataEditor::Find(off_t startPosition, const uint8 *data, size_t dataSize,
        bool caseInsensitive, bool cyclic, BMessenger progressMonitor,
        volatile bool *stop)
{
        if (data == NULL || dataSize == 0)
                return B_BAD_VALUE;

        if (startPosition < 0)
                startPosition = 0;

        BAutolock locker(this);

        typedef int (*compare_func)(const uint8 *a, const uint8 *b, size_t size);
        compare_func compareFunc;
        if (caseInsensitive)
                compareFunc = CompareCaseInsensitive;
        else
                compareFunc = (compare_func)memcmp;

        bool savedIsReadOnly = fIsReadOnly;
        fIsReadOnly = true;
        off_t savedOffset = fViewOffset;
        off_t position = (startPosition / fRealViewSize) * fRealViewSize;
        size_t firstByte = startPosition % fRealViewSize;
        size_t matchLastOffset = 0;
        off_t foundAt = B_ENTRY_NOT_FOUND;
        bool noStop = false;
        if (stop == NULL)
                stop = &noStop;

        // start progress monitor
        {
                BMessage progress(kMsgDataEditorFindProgress);
                progress.AddBool("running", true);
                progressMonitor.SendMessage(&progress);
        }

        bigtime_t lastReport = 0;

        off_t blocks = fSize;
        if (!cyclic)
                blocks -= position;
        blocks = (blocks + fRealViewSize - 1) / fRealViewSize;

        for (; blocks-- > 0 && !*stop; position += fRealViewSize) {
                if (position > fSize)
                        position = 0;

                SetViewOffset(position, false);
                if (fNeedsUpdate)
                        Update();

                bigtime_t current = system_time();
                if (lastReport + 500000LL < current) {
                        // report the progress two times a second
                        BMessage progress(kMsgDataEditorFindProgress);
                        progress.AddInt64("position", position);
                        progressMonitor.SendMessage(&progress);

                        lastReport = current;
                }

                // search for data in current block

                if (matchLastOffset != 0) {
                        // we had a partial match in the previous block, let's
                        // check if it is a whole match
                        if (!compareFunc(fView, data + matchLastOffset,
                                        dataSize - matchLastOffset)) {
                                matchLastOffset = 0;
                                break;
                        }

                        foundAt = B_ENTRY_NOT_FOUND;
                        matchLastOffset = 0;
                }

                for (size_t i = firstByte; i < fRealViewSize; i++) {
                        if (position + (off_t)(i + dataSize) > (off_t)fSize)
                                break;

                        if (!compareFunc(fView + i, data, 1)) {
                                // one byte matches, compare the rest
                                size_t size = dataSize - 1;
                                size_t offset = i + 1;

                                if (offset + size > fRealViewSize)
                                        size = fRealViewSize - offset;

                                if (size == 0 || !compareFunc(fView + offset, data + 1, size)) {
                                        foundAt = position + i;

                                        if (size != dataSize - 1) {
                                                // only a partial match, we have to check the start
                                                // of the next block
                                                matchLastOffset = size + 1;
                                        }
                                        break;
                                }
                        }
                }

                if (foundAt >= 0 && matchLastOffset == 0)
                        break;

                firstByte = 0;
        }

        fIsReadOnly = savedIsReadOnly;

        if (foundAt >= 0 && matchLastOffset != 0)
                foundAt = B_ENTRY_NOT_FOUND;

        // stop progress monitor
        {
                BMessage progress(kMsgDataEditorFindProgress);
                progress.AddBool("running", false);
                progress.AddInt64("position", foundAt >= 0 ? foundAt : savedOffset);
                progressMonitor.SendMessage(&progress);
        }

        SetViewOffset(savedOffset, false);
                // this is to ensure that we're sending an update when
                // we're set to the found data offset

        if (foundAt < 0 && *stop)
                return B_INTERRUPTED;

        return foundAt;
}


void
DataEditor::SendNotices(DataChange *change)
{
        off_t offset, size;
        change->GetRange(FileSize(), offset, size);

        // update observer
        BMessage update;
        update.AddInt64("offset", offset);
        update.AddInt64("size", size);
        SendNotices(kMsgDataEditorUpdate, &update);
}


void
DataEditor::SendNotices(uint32 what, BMessage *message)
{
        if (fObservers.CountItems() == 0)
                return;

        BMessage *notice;
        if (message) {
                notice = new BMessage(*message);
                notice->what = what;
        } else
                notice = new BMessage(what);

        for (int32 i = fObservers.CountItems(); i-- > 0;) {
                BMessenger *messenger = fObservers.ItemAt(i);
                messenger->SendMessage(notice);
        }

        delete notice;
}


status_t
DataEditor::StartWatching(BMessenger target)
{
        BAutolock locker(this);

        node_ref node;
        status_t status = fFile.GetNodeRef(&node);
        if (status < B_OK)
                return status;

        fObservers.AddItem(new BMessenger(target));

        return watch_node(&node, B_WATCH_STAT | B_WATCH_ATTR, target);
}


status_t
DataEditor::StartWatching(BHandler *handler, BLooper *looper)
{
        return StartWatching(BMessenger(handler, looper));
}


void
DataEditor::StopWatching(BMessenger target)
{
        BAutolock locker(this);

        for (int32 i = fObservers.CountItems(); i-- > 0;) {
                BMessenger *messenger = fObservers.ItemAt(i);
                if (*messenger == target) {
                        fObservers.RemoveItemAt(i);
                        delete messenger;
                        break;
                }
        }

        stop_watching(target);
}


void
DataEditor::StopWatching(BHandler *handler, BLooper *looper)
{
        StopWatching(BMessenger(handler, looper));
}