/****************************************************************************
 *   Copyright (c) 2019 Zheng Lei (realthunder) <realthunder.dev@gmail.com> *
 *                                                                          *
 *   This file is part of the FreeCAD CAx development system.               *
 *                                                                          *
 *   This library is free software; you can redistribute it and/or          *
 *   modify it under the terms of the GNU Library General Public            *
 *   License as published by the Free Software Foundation; either           *
 *   version 2 of the License, or (at your option) any later version.       *
 *                                                                          *
 *   This library  is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
 *   GNU Library General Public License for more details.                   *
 *                                                                          *
 *   You should have received a copy of the GNU Library General Public      *
 *   License along with this library; see the file COPYING.LIB. If not,     *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,          *
 *   Suite 330, Boston, MA  02111-1307, USA                                 *
 *                                                                          *
 ****************************************************************************/

#ifndef APP_AUTOTRANSACTION_H
#define APP_AUTOTRANSACTION_H

#include <cstddef>

namespace App {

class Application;

/// Helper class to manager transaction (i.e. undo/redo)
class AppExport AutoTransaction {
private:
    /// Private new operator to prevent heap allocation
    void* operator new (std::size_t) = delete;

public:
    /** Constructor
     *
     * @param name: optional new transaction name on construction
     * @param tmpName: if true and a new transaction is setup, the name given is
     * considered as temporary, and subsequent construction of this class (or
     * calling Application::setActiveTransaction()) can override the transaction
     * name.
     *
     * The constructor increments an internal counter
     * (Application::_activeTransactionGuard). The counter prevents any new
     * active transaction being setup. It also prevents close (i.e. commits) the
     * current active transaction until it reaches zero. It does not have any
     * effect on aborting transaction, though.
     */
    AutoTransaction(const char *name=nullptr, bool tmpName=false);

    /** Destructor
     *
     * This destructor decrease an internal counter
     * (Application::_activeTransactionGuard), and will commit any current
     * active transaction when the counter reaches zero.
     */
    ~AutoTransaction();

    /** Close or abort the transaction
     *
     * This function can be used to explicitly close (i.e. commit) the
     * transaction, if the current transaction ID matches the one created inside
     * the constructor. For aborting, it will abort any current transaction
     */
    void close(bool abort=false);

    /** Enable/Disable any AutoTransaction instance in the current stack
     *
     * Once disabled, any empty temporary named transaction is closed. If there
     * are non-empty or non-temporary named active transaction, it will not be
     * auto closed.
     *
     * This function may be used in, for example, Gui::Document::setEdit() to
     * allow a transaction live past any command scope.
     */
    static void setEnable(bool enable);

private:
    int tid = 0;
};


/** Helper class to lock a transaction from being closed or aborted.
 *
 * The helper class is used to protect some critical transaction from being
 * closed prematurely, e.g. when deleting some object.
 */
class AppExport TransactionLocker {
public:

    /** Constructor
     * @param lock: whether to activate the lock
     */
    TransactionLocker(bool lock=true);

    /** Destructor
     * Unlock the transaction is this locker is active
     */
    ~TransactionLocker();

    /** Activate or deactivate this locker
     * @param enable: whether to activate the locker
     *
     * An internal counter is used to support recursive locker. When activated,
     * the current active transaction cannot be closed or aborted.  But the
     * closing call (Application::closeActiveTransaction()) will be remembered,
     * and performed when the internal lock counter reaches zero.
     */
    void activate(bool enable);

    /// Check if the locker is active
    bool isActive() const {return active;}

    /// Check if transaction is being locked
    static bool isLocked();

    friend class Application;

private:
    /// Private new operator to prevent heap allocation
    void* operator new (std::size_t) = delete;

private:
    bool active;
};

} // namespace App

#endif // APP_AUTOTRANSACTION_H