/*
 * Copyright 2006-2012, Stephan Aßmus <superstippi@gmx.de>
 * Copyright 2021, Andrew Lindesay <apl@lindesay.co.nz>
 * Distributed under the terms of the MIT License.
 */

#include "EditManager.h"

#include <algorithm>

#include <stdio.h>
#include <string.h>

#include <Locker.h>
#include <String.h>


EditManager::Listener::~Listener()
{
}


EditManager::EditManager()
{
}


EditManager::~EditManager()
{
        Clear();
}


status_t
EditManager::Perform(UndoableEdit* edit, EditContext& context)
{
        if (edit == NULL)
                return B_BAD_VALUE;

        return Perform(UndoableEditRef(edit, true), context);
}


status_t
EditManager::Perform(const UndoableEditRef& edit, EditContext& context)
{
        status_t ret = edit.IsSet() ? B_OK : B_BAD_VALUE;
        if (ret == B_OK)
                ret = edit->InitCheck();

        if (ret == B_OK)
                ret = edit->Perform(context);

        if (ret == B_OK) {
                ret = _AddEdit(edit);
                if (ret != B_OK)
                        edit->Undo(context);
        }

        _NotifyListeners();

        return ret;
}


status_t
EditManager::Undo(EditContext& context)
{
        status_t status = B_ERROR;
        if (!fUndoHistory.empty()) {
                UndoableEditRef edit(fUndoHistory.top());
                fUndoHistory.pop();
                status = edit->Undo(context);
                if (status == B_OK)
                        fRedoHistory.push(edit);
                else
                        fUndoHistory.push(edit);
        }

        _NotifyListeners();

        return status;
}


status_t
EditManager::Redo(EditContext& context)
{
        status_t status = B_ERROR;
        if (!fRedoHistory.empty()) {
                UndoableEditRef edit(fRedoHistory.top());
                fRedoHistory.pop();
                status = edit->Redo(context);
                if (status == B_OK)
                        fUndoHistory.push(edit);
                else
                        fRedoHistory.push(edit);
        }

        _NotifyListeners();

        return status;
}


bool
EditManager::GetUndoName(BString& name)
{
        if (!fUndoHistory.empty()) {
                name << " ";
                fUndoHistory.top()->GetName(name);
                return true;
        }
        return false;
}


bool
EditManager::GetRedoName(BString& name)
{
        if (!fRedoHistory.empty()) {
                name << " ";
                fRedoHistory.top()->GetName(name);
                return true;
        }
        return false;
}


void
EditManager::Clear()
{
        while (!fUndoHistory.empty())
                fUndoHistory.pop();
        while (!fRedoHistory.empty())
                fRedoHistory.pop();

        _NotifyListeners();
}


void
EditManager::Save()
{
        if (!fUndoHistory.empty())
                fEditAtSave = fUndoHistory.top();

        _NotifyListeners();
}


bool
EditManager::IsSaved()
{
        bool saved = fUndoHistory.empty();
        if (fEditAtSave.IsSet() && !saved) {
                if (fEditAtSave == fUndoHistory.top())
                        saved = true;
        }
        return saved;
}


// #pragma mark -


void
EditManager::AddListener(Listener* listener)
{
        return fListeners.push_back(listener);
}


void
EditManager::RemoveListener(Listener* listener)
{
        fListeners.erase(std::remove(fListeners.begin(), fListeners.end(),
                listener), fListeners.end());
}


// #pragma mark -


status_t
EditManager::_AddEdit(const UndoableEditRef& edit)
{
        status_t status = B_OK;

        bool add = true;
        if (!fUndoHistory.empty()) {
                // Try to collapse edits to a single edit
                // or remove this and the previous edit if
                // they reverse each other
                const UndoableEditRef& top = fUndoHistory.top();
                if (edit->UndoesPrevious(top.Get())) {
                        add = false;
                        fUndoHistory.pop();
                } else if (top->CombineWithNext(edit.Get())) {
                        add = false;
                        // After collapsing, the edit might
                        // have changed it's mind about InitCheck()
                        // (the commands reversed each other)
                        if (top->InitCheck() != B_OK) {
                                fUndoHistory.pop();
                        }
                } else if (edit->CombineWithPrevious(top.Get())) {
                        fUndoHistory.pop();
                        // After collapsing, the edit might
                        // have changed it's mind about InitCheck()
                        // (the commands reversed each other)
                        if (edit->InitCheck() != B_OK) {
                                add = false;
                        }
                }
        }
        if (add)
                fUndoHistory.push(edit);

        if (status == B_OK) {
                // The redo stack needs to be empty
                // as soon as an edit was added (also in case of collapsing)
                while (!fRedoHistory.empty()) {
                        fRedoHistory.pop();
                }
        }

        return status;
}


void
EditManager::_NotifyListeners()
{
        // Iterate a copy of the list, so we don't crash if listeners
        // detach themselves while being notified.
        std::vector<Listener*> listeners(fListeners);

        std::vector<Listener*>::const_iterator it;
        for (it = listeners.begin(); it != listeners.end(); it++) {
                Listener* listener = *it;
                listener->EditManagerChanged(this);
        }
}