// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#pragma once

#include <memory>
#include <mutex>
#include <thread>

#include "flutter/fml/macros.h"
#include "flutter/fml/synchronization/shared_mutex.h"
#include "impeller/base/thread_safety.h"

namespace impeller {

class IPLR_CAPABILITY("mutex") Mutex {
 public:
  Mutex() = default;

  ~Mutex() = default;

  void Lock() IPLR_ACQUIRE() { mutex_.lock(); }

  void Unlock() IPLR_RELEASE() { mutex_.unlock(); }

 private:
  std::mutex mutex_;

  Mutex(const Mutex&) = delete;

  Mutex(Mutex&&) = delete;

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

  Mutex& operator=(Mutex&&) = delete;
};

class IPLR_CAPABILITY("mutex") RWMutex {
 public:
  RWMutex()
      : mutex_(std::unique_ptr<fml::SharedMutex>(fml::SharedMutex::Create())) {}

  ~RWMutex() = default;

  void LockWriter() IPLR_ACQUIRE() { mutex_->Lock(); }

  void UnlockWriter() IPLR_RELEASE() { mutex_->Unlock(); }

  void LockReader() IPLR_ACQUIRE_SHARED() { mutex_->LockShared(); }

  void UnlockReader() IPLR_RELEASE_SHARED() { mutex_->UnlockShared(); }

 private:
  std::unique_ptr<fml::SharedMutex> mutex_;

  RWMutex(const RWMutex&) = delete;

  RWMutex(RWMutex&&) = delete;

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

  RWMutex& operator=(RWMutex&&) = delete;
};

class IPLR_SCOPED_CAPABILITY Lock {
 public:
  explicit Lock(Mutex& mutex) IPLR_ACQUIRE(mutex) : mutex_(mutex) {
    mutex_.Lock();
  }

  ~Lock() IPLR_RELEASE() { mutex_.Unlock(); }

 private:
  Mutex& mutex_;

  Lock(const Lock&) = delete;

  Lock(Lock&&) = delete;

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

  Lock& operator=(Lock&&) = delete;
};

class IPLR_SCOPED_CAPABILITY ReaderLock {
 public:
  explicit ReaderLock(RWMutex& mutex) IPLR_ACQUIRE_SHARED(mutex)
      : mutex_(mutex) {
    mutex_.LockReader();
  }

  ~ReaderLock() IPLR_RELEASE() { mutex_.UnlockReader(); }

 private:
  RWMutex& mutex_;

  ReaderLock(const ReaderLock&) = delete;

  ReaderLock(ReaderLock&&) = delete;

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

  ReaderLock& operator=(ReaderLock&&) = delete;
};

class IPLR_SCOPED_CAPABILITY WriterLock {
 public:
  explicit WriterLock(RWMutex& mutex) IPLR_ACQUIRE(mutex) : mutex_(mutex) {
    mutex_.LockWriter();
  }

  ~WriterLock() IPLR_RELEASE() { mutex_.UnlockWriter(); }

 private:
  RWMutex& mutex_;

  WriterLock(const WriterLock&) = delete;

  WriterLock(WriterLock&&) = delete;

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

  WriterLock& operator=(WriterLock&&) = delete;
};

}  // namespace impeller