/*
  Copyright 2007-2017 David Robillard <d@drobilla.net>

  Raul is free software: you can redistribute it and/or modify it under the
  terms of the GNU General Public License as published by the Free Software
  Foundation, either version 3 of the License, or any later version.

  Raul 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 General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with Raul.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef RAUL_MAID_HPP
#define RAUL_MAID_HPP

#include "raul/Deletable.hpp"
#include "raul/Noncopyable.hpp"

#include <atomic>
#include <memory>
#include <utility>

namespace raul {

/**
   Explicit garbage collector.

   This allows objects to be disposed of in a real-time thread, but actually
   deleted later by another thread which calls cleanup().  Disposable objects
   may be explicitly disposed by calling dispose(), or automatically managed
   with a managed_ptr which can safely be dropped in any thread, including
   real-time threads.

   @ingroup raul
*/
class Maid : public Noncopyable
{
public:
  /// An object that can be disposed via Maid::dispose()
  class Disposable : public Deletable
  {
  public:
    Disposable() = default;

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

    Disposable(Disposable&&) = delete;
    Disposable& operator=(Disposable&&) = delete;

    ~Disposable() override = default;

  private:
    friend class Maid;
    Disposable* _maid_next{};
  };

  /// Disposable wrapper for any type
  template<typename T>
  class Managed
    : public raul::Maid::Disposable
    , public T
  {
  public:
    template<typename... Args>
    explicit Managed(Args&&... args)
      : T(std::forward<Args>(args)...)
    {}
  };

  /// Deleter for Disposable objects
  template<typename T>
  class Disposer
  {
  public:
    explicit Disposer(Maid* maid)
      : _maid(maid)
    {}

    Disposer() = default;

    void operator()(T* obj)
    {
      if (_maid) {
        _maid->dispose(obj);
      }
    }

  private:
    Maid* _maid{nullptr};
  };

  /**
     A managed pointer that automatically disposes of its contents.

     This is a unique_ptr so that it is possible to statically verify that
     code is real-time safe.
  */
  template<typename T>
  using managed_ptr = std::unique_ptr<T, Disposer<T>>;

  Maid()
    : _disposed(nullptr)
  {}

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

  Maid(Maid&&)  = delete;
  Maid& operator=(Maid&&) = delete;

  inline ~Maid() { cleanup(); }

  /// Return false iff there is currently no garbage
  inline bool empty() const
  {
    return !_disposed.load(std::memory_order_relaxed);
  }

  /**
     Enqueue an object for deletion when cleanup() is called next.

     This is thread-safe, and real-time safe assuming reasonably low
     contention.
  */
  inline void dispose(Disposable* obj)
  {
    if (obj) {
      // Atomically add obj to the head of the disposed list
      do {
        obj->_maid_next = _disposed.load(std::memory_order_relaxed);
      } while (!_disposed.compare_exchange_weak(obj->_maid_next,
                                                obj,
                                                std::memory_order_release,
                                                std::memory_order_relaxed));
    }
  }

  /**
     Delete all disposed objects immediately.

     Obviously not real-time safe, but may be called while other threads are
     calling dispose().
  */
  inline void cleanup()
  {
    // Atomically get the head of the disposed list
    Disposable* const disposed =
      _disposed.exchange(nullptr, std::memory_order_acquire);

    // Free the disposed list
    for (Disposable* obj = disposed; obj;) {
      Disposable* const next = obj->_maid_next;
      delete obj;
      obj = next;
    }
  }

  /// Make a unique_ptr that will dispose its object when dropped
  template<class T, class... Args>
  managed_ptr<T> make_managed(Args&&... args)
  {
    return std::unique_ptr<T, Disposer<T>>(new T(std::forward<Args>(args)...),
                                           Disposer<T>(this));
  }

private:
  std::atomic<Disposable*> _disposed;
};

template<typename T>
using managed_ptr = Maid::managed_ptr<T>;

} // namespace raul

#endif // RAUL_MAID_HPP