// Copyright 2022 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
#pragma once

#include <tuple>
#include <utility>

#include "pw_sync/borrow.h"
#include "pw_sync/internal/borrowable_storage.h"
#include "pw_sync/mutex.h"
#include "pw_sync/virtual_basic_lockable.h"

namespace pw::sync {

// InlineBorrowable holds an object of GuardedType and a Lock that guards
// access to the object. It should be used when an object should be guarded for
// its entire lifecycle by a single lock.
//
// This object should be shared with other componetns as a reference of type
// Borrowable<GuardedType, LockInterface>.
//
template <typename GuardedType,
          typename Lock = pw::sync::VirtualMutex,
          typename LockInterface = pw::sync::VirtualBasicLockable>
class InlineBorrowable : private internal::BorrowableStorage<GuardedType, Lock>,
                         public Borrowable<GuardedType, LockInterface> {
  using Storage = internal::BorrowableStorage<GuardedType, Lock>;
  using Base = Borrowable<GuardedType, LockInterface>;

 public:
  // Construct the guarded object and lock using their default constructors.
  constexpr InlineBorrowable()
      : Storage(std::in_place), Base(Storage::object_, Storage::lock_) {}

  // Construct the guarded object by providing its constructor arguments inline.
  //
  // This constructor supports list initialization for arrays, structs, and
  // other objects such as std::array.
  //
  // Example:
  //
  //   InlineBorrowable<Foo> foo(std::in_place, foo_arg1, foo_arg2);
  //
  //   InlineBorrowable<std::array<int, 2>> foo_array(std::in_place, 1, 2);
  //
  template <typename... Args>
  constexpr explicit InlineBorrowable(std::in_place_t, Args&&... args)
      : Storage(std::in_place, std::forward<Args>(args)...),
        Base(Storage::object_, Storage::lock_) {}

  // Construct the guarded object and lock by providing their construction
  // parameters using separate tuples.
  //
  // Example:
  //
  //   InlineBorrowable<Foo> foo(std::forward_as_tuple(foo_arg1, foo_arg2));
  //
  //   InlineBorrowable<Foo, MyLock> foo_lock(
  //       std::forward_as_tuple(foo_arg1, foo_arg2),
  //       std::forward_as_tuple(lock_arg1, lock_arg2));
  //
  // Note: this constructor only supports list initialization with C++20 or
  // later, because it requires https://wg21.link/p0960.
  //
  template <typename... ObjectArgs, typename... LockArgs>
  constexpr explicit InlineBorrowable(
      std::tuple<ObjectArgs...>&& object_args,
      std::tuple<LockArgs...>&& lock_args = std::make_tuple())
      : Storage(std::forward<std::tuple<ObjectArgs...>>(object_args),
                std::forward<std::tuple<LockArgs...>>(lock_args)),
        Base(Storage::object_, Storage::lock_) {}

  // Construct the guarded object and lock by providing factory functions.
  //
  // Example:
  //
  //    InlineBorrowable<Foo> foo([&]{ return Foo{foo_arg1, foo_arg2}; });
  //
  //    InlineBorrowable<Foo, MyLock> foo_lock(
  //        [&]{ return Foo{foo_arg1, foo_arg2}; }
  //        [&]{ return MyLock{lock_arg1, lock_arg2}; }
  //
  template <typename ObjectConstructor,
            typename LockConstructor = Lock(),
            typename = std::enable_if_t<
                std::is_invocable_r_v<GuardedType&&, ObjectConstructor>>,
            typename = std::enable_if_t<
                std::is_invocable_r_v<Lock&&, LockConstructor>>>
  constexpr explicit InlineBorrowable(
      const ObjectConstructor& object_ctor,
      const LockConstructor& lock_ctor = internal::DefaultConstruct<Lock>)
      : Storage(object_ctor, lock_ctor),
        Base(Storage::object_, Storage::lock_) {}

  template <typename ObjectConstructor,
            typename LockConstructor = Lock(),
            typename = std::enable_if_t<
                std::is_invocable_r_v<GuardedType&&, ObjectConstructor>>,
            typename = std::enable_if_t<
                std::is_invocable_r_v<Lock&&, LockConstructor>>>
  constexpr explicit InlineBorrowable(
      ObjectConstructor& object_ctor,
      const LockConstructor& lock_ctor = internal::DefaultConstruct<Lock>)
      : Storage(object_ctor, lock_ctor),
        Base(Storage::object_, Storage::lock_) {}

  template <typename ObjectConstructor,
            typename LockConstructor = Lock(),
            typename = std::enable_if_t<
                std::is_invocable_r_v<GuardedType&&, ObjectConstructor>>,
            typename = std::enable_if_t<
                std::is_invocable_r_v<Lock&&, LockConstructor>>>
  constexpr explicit InlineBorrowable(const ObjectConstructor& object_ctor,
                                      LockConstructor& lock_ctor)
      : Storage(object_ctor, lock_ctor),
        Base(Storage::object_, Storage::lock_) {}

  template <typename ObjectConstructor,
            typename LockConstructor = Lock(),
            typename = std::enable_if_t<
                std::is_invocable_r_v<GuardedType&&, ObjectConstructor>>,
            typename = std::enable_if_t<
                std::is_invocable_r_v<Lock&&, LockConstructor>>>
  constexpr explicit InlineBorrowable(ObjectConstructor& object_ctor,
                                      LockConstructor& lock_ctor)
      : Storage(object_ctor, lock_ctor),
        Base(Storage::object_, Storage::lock_) {}
};

}  // namespace pw::sync