// Copyright 2004-present Facebook. All Rights Reserved.

#pragma once

#include <iostream>

namespace facebook::gorilla {

#pragma region out

// Adaptation of c#'s out keyword in c++
// https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/out-parameter-modifier
//
// Instead of passing a parameter by reference for output, we pass it by
// this "out" struct instead. Both the method declaration and the caller
// needs to explicitly write "out" in the code, so there is less chance
// of confussion.
//
// Example:
//
//   void getString(out<std::string> output) {
//     output = "This is the Output";
//   }
//
//   std::string stringOutput;
//   getString(out(stringOutput));
//
template <typename Tcrtp, typename T>
class InOutBase {
 public:
  explicit InOutBase(T& item) : item_(&item) {}
  InOutBase(T&& item) = delete;
  InOutBase() = delete;
  InOutBase(const InOutBase<Tcrtp, T>& other) = default;
  InOutBase(InOutBase<Tcrtp, T>&& other) noexcept = default;

  T& Item() {
    return *item_;
  }

  operator T&() {
    return Item();
  }

#pragma region OperatorForwarding
 public:
  // todo(widagdos): forward all operators

  template <typename TOther>
  [[nodiscard]] bool operator==(const TOther& rhs) const {
    return *item_ == rhs;
  }

  template <typename TOther>
  [[nodiscard]] bool operator!=(const TOther& rhs) const {
    return *item_ != rhs;
  }

  Tcrtp operator+() const {
    *item_ = +item_;
    return *this;
  }

  Tcrtp operator-() const {
    *item_ = -item_;
    return *this;
  }

  template <typename TOther>
  auto operator+(const TOther& t2) const {
    return *item_ + t2;
  }

  template <typename TOther>
  auto operator-(const TOther& t2) const {
    return *item_ - t2;
  }

  template <typename TOther>
  auto operator*(const TOther& t2) const {
    return *item_ * t2;
  }

  template <typename TOther>
  auto operator/(const TOther& t2) const {
    return *item_ / t2;
  }

  template <typename TOther>
  auto operator%(const TOther& t2) const {
    return *item_ % t2;
  }

  template <typename TOther>
  auto operator|(const TOther& t2) const {
    return *item_ | t2;
  }

  template <typename TOther>
  auto operator&(const TOther& t2) const {
    return *item_ & t2;
  }

  template <typename TOther>
  auto operator^(const TOther& t2) const {
    return *item_ ^ t2;
  }

  template <typename TOther>
  Tcrtp operator+=(const TOther& t2) {
    *item_ += t2;
    return static_cast<Tcrtp>(*this);
  }

  template <typename TOther>
  Tcrtp operator-=(const TOther& t2) {
    *item_ -= t2;
    return static_cast<Tcrtp>(*this);
  }

  template <typename TOther>
  Tcrtp operator*=(const TOther& t2) {
    *item_ *= t2;
    return static_cast<Tcrtp>(*this);
  }

  template <typename TOther>
  Tcrtp operator/=(const TOther& t2) {
    *item_ /= t2;
    return static_cast<Tcrtp>(*this);
  }

  template <typename TOther>
  Tcrtp operator%=(const TOther& t2) {
    *item_ %= t2;
    return static_cast<Tcrtp>(*this);
  }

  template <typename TOther>
  Tcrtp operator&=(const TOther& t2) {
    *item_ &= t2;
    return static_cast<Tcrtp>(*this);
  }

  template <typename TOther>
  Tcrtp operator|=(const TOther& t2) {
    *item_ |= t2;
    return static_cast<Tcrtp>(*this);
  }

  template <typename TOther>
  Tcrtp operator^=(const TOther& t2) {
    *item_ ^= t2;
  }

  template <typename TOther>
  auto& operator[](TOther&& other) {
    return (*item_)[std::forward<TOther>(other)];
  }

#pragma endregion OperatorForwarding

#pragma region StringForwarding
 public:
  auto begin() {
    return item_->begin();
  }

  auto end() {
    return item_->end();
  }

  auto begin() const {
    return item_->begin();
  }

  auto end() const {
    return item_->end();
  }

  auto& at(size_t pos) {
    return item_->at(pos);
  }

  auto& operator[](size_t pos) {
    return (*item_)[pos];
  }

  auto empty() const {
    return item_->empty();
  }

  auto size() const {
    return item_->size();
  }

  auto max_size() const {
    return item_->max_size();
  }

  auto reserve(size_t capacity) {
    return item_->reserve(capacity);
  }

  auto capacity() const {
    return item_->capacity();
  }

  auto resize(size_t capacity) {
    return item_->resize(capacity);
  }

  template <typename TOther>
  Tcrtp append(const TOther& other) {
    item_->append(other);
    return static_cast<Tcrtp>(*this);
  }

  template <typename TOther>
  void push_back(const TOther& other) {
    item_->push_back(other);
  }

#pragma endregion StringForwarding

 protected:
  // This cannot be reference since we enable this error:
  //   binding reference member 'item_' to stack allocated parameter 'item'
  //   [-Werror,-Wdangling-field]
  T* item_;
};

// Adaptation of c# out keyword
template <typename T>
class out : public InOutBase<out<T>, T> {
 public:
  explicit out(T& item) : InOutBase<out<T>, T>(item) {}
  out(T&& item) = delete;
  out() = delete;
  out(const out<T>& other) = default;
  out(out<T>&& other) noexcept = default;
  out& operator=(const T& a) {
    *InOutBase<out<T>, T>::item_ = a;
    return *this;
  }
  out& operator=(T&& a) {
    *InOutBase<out<T>, T>::item_ = std::move(a);
    return *this;
  }
  void PrintTo(const out<T>& item, std::ostream* os);
};

// // Adaptation of c# ref keyword
template <typename T>
class inout : public InOutBase<inout<T>, T> {
 public:
  explicit inout(T& item) : InOutBase<inout<T>, T>(item) {}
  inout(T&& item) = delete;
  inout() = delete;
  inout(const inout<T>& other) = default;
  inout(inout<T>&& other) noexcept = default;
  inout& operator=(const T& a) {
    *InOutBase<inout<T>, T>::item_ = a;
    return *this;
  }
  inout& operator=(T&& a) {
    *InOutBase<inout<T>, T>::item_ = std::move(a);
    return *this;
  }
};

template <typename T>
inline std::ostream& operator<<(std::ostream& os, const out<T>& item) {
  os << (T&)item;
  return os;
}

template <typename T>
inline std::ostream& operator<<(std::ostream& os, const inout<T>& item) {
  os << (T&)item;
  return os;
}
template <typename T>
inline void PrintTo(const out<T>& item, std::ostream* os) {
  *os << (T&)item;
}

#pragma endregion out

} // namespace facebook::gorilla


int main() {
  return 0;
}