/*
    utils/uniquelock.h
    QMutex-compatible replacement for std::unique_lock

    This file is part of libkleopatra, the KDE keymanagement library
    SPDX-FileCopyrightText: 2008-2021 Free Software Foundation, Inc.
    SPDX-FileCopyrightText: 2021 g10 Code GmbH
    SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

    SPDX-License-Identifier: GPL-3.0-or-later WITH GCC-exception-3.1
*/

#pragma once

#include "kleo_export.h"

#include <QtGlobal>
#include <QMutex>

#include <chrono>
#include <memory>

namespace Kleo
{

/// Do not acquire ownership of the mutex.
struct DeferLockType { explicit DeferLockType() = default; };

/// Try to acquire ownership of the mutex without blocking.
struct TryToLockType { explicit TryToLockType() = default; };

/// Assume the calling thread has already obtained mutex ownership
/// and manage it.
struct AdoptLockType { explicit AdoptLockType() = default; };

/// Tag used to prevent a scoped lock from acquiring ownership of a mutex.
inline constexpr DeferLockType deferLock { };

/// Tag used to prevent a scoped lock from blocking if a mutex is locked.
inline constexpr TryToLockType tryToLock { };

/// Tag used to make a scoped lock take ownership of a locked mutex.
inline constexpr AdoptLockType adoptLock { };

/** @brief A movable scoped lock type for QMutex.
 *
 * A UniqueLock controls mutex ownership within a scope. Ownership of the
 * mutex can be delayed until after construction and can be transferred
 * to another UniqueLock by move construction or move assignment. If a
 * mutex lock is owned when the destructor runs ownership will be released.
 */
class KLEO_EXPORT UniqueLock
{
public:
    UniqueLock() noexcept;
    explicit UniqueLock(QMutex &mutex);

    UniqueLock(QMutex &mutex, DeferLockType) noexcept;
    UniqueLock(QMutex &mutex, TryToLockType);
    UniqueLock(QMutex &mutex, AdoptLockType) noexcept;

    template<typename Clock, typename Duration>
    UniqueLock(QMutex &mutex, const std::chrono::time_point<Clock, Duration> &timePoint)
        : mMutex{std::addressof(mutex)}
        , mOwnsMutex{mMutex->try_lock_until(timePoint)}
    {
    }

    template<typename Rep, typename Period>
    UniqueLock(QMutex &mutex, const std::chrono::duration<Rep, Period> &duration)
        : mMutex{std::addressof(mutex)}
        , mOwnsMutex{mMutex->try_lock_for(duration)}
    {
    }

    ~UniqueLock();

    UniqueLock(const UniqueLock &) = delete;
    UniqueLock &operator=(const UniqueLock &) = delete;

    UniqueLock(UniqueLock &&u) noexcept;
    UniqueLock &operator=(UniqueLock &&u) noexcept;

    void lock();

    bool try_lock();

    template<typename Clock, typename Duration>
    bool try_lock_until(const std::chrono::time_point<Clock, Duration> &timePoint)
    {
        Q_ASSERT(mMutex);
        Q_ASSERT(!mOwnsMutex);
        if (mMutex && !mOwnsMutex) {
            mOwnsMutex = mMutex->try_lock_until(timePoint);
            return mOwnsMutex;
        }
    }

    template<typename Rep, typename Period>
    bool try_lock_for(const std::chrono::duration<Rep, Period> &duration)
    {
        Q_ASSERT(mMutex);
        Q_ASSERT(!mOwnsMutex);
        if (mMutex && !mOwnsMutex) {
            mOwnsMutex = mMutex->try_lock_for(duration);
            return mOwnsMutex;
        }
    }

    void unlock();

    void swap(UniqueLock &u) noexcept;

    QMutex *release() noexcept;

    bool owns_lock() const noexcept;

    explicit operator bool() const noexcept;

    QMutex *mutex() const noexcept;

private:
    QMutex *mMutex;
    bool    mOwnsMutex;
};

} // namespace Kleo

namespace std {

/// Swap overload for UniqueLock objects.
/// @relates UniqueLock
inline void swap(Kleo::UniqueLock &x, Kleo::UniqueLock &y) noexcept { x.swap(y); }

}
