// When unique_ptr is not enough: std::shared_ptr and std::make_shared,
// and std::weak_ptr

// std::shared_ptr uses a reference counter: unlike unique_ptr, there
// can be multiple shared_ptr's pointing to the same data. The data
// is deallocated when the reference counter decreases to zero.  Each
// share increases the counter.  This way of memory mangagement is quite
// common and is found in Swift and other languages.  But it's not
// capable of completely freeing the programmer from worrying about memory:
// cyclic pointers will never decrease the count, requiring the programmer
// to identify some pointers as "weak" (std:weak_ptr).  But this can be
// tricky, and in the worst case requires the construction of spanning trees.

#include<iostream>
#include<memory>      
#include<concepts>  // requires -std=c++20
using namespace std;

void shared_demo() {
  shared_ptr<int> sx = make_shared<int>(1);
  auto sy = make_shared<int>(10);
  cout << sx.use_count() << " :  should be 1\n";
  sy = sx; // shared pointers can be "copied"
  cout << sx.use_count() << " :  should now be 2, the 1 is shared\n";
  auto sz = move(sx);   // as well as "moved": sx is no longer a owner
  cout << sz.use_count() << " :  still 2: no new share created\n";
  cout << sx.use_count() << " :  should be 0, share got moved\n";
  //cout << *sx <<endl;    // segmentation fault, or prints junk

  cout << *sz << " : should print 1\n";
  // but sy also "owns" the 1
  *sy = 3;
  cout << *sz << " : should now print 3\n";

  // the use_count() decreases when a share gets deallocated.
  
}// shared_pointer demo program

////// memory leaks are still possible with cyclic shared pointers

struct bad_mutual_share
{
  int A[10];
  shared_ptr<bad_mutual_share> other;
};

void share_and_leak() {
  auto a = make_shared<bad_mutual_share>();
  auto b = make_shared<bad_mutual_share>();
  a->other = b;  // copy constructor applied, so another share is created..
  b->other = a; 
}

struct fixed_mutual_share {
  int A[10];
  weak_ptr<fixed_mutual_share> other;
};

void no_more_leak() {
  auto a = make_shared<fixed_mutual_share>();
  auto b = make_shared<fixed_mutual_share>();
  a->other = b;
  b->other = a;  // pointers are weak, does not increase ref. counter
  
  //a->other->A[0] = 10; // can't use weak_ptr to access data directly
  a->other.lock()->A[0] = 10;  // temporary upgrade to shared_ptr
}


///// own version of shared pointer, Rc for "reference counter"
template<typename T>  // header
class Rc;
template<typename T>  // header
class RcManager; 
template<typename T, class... Args>
RcManager<T> makeRc(Args&&...);

int ccx{0}; // counter for diagnostics

template<typename T>
class Rc {
protected:
  RcManager<T>* manager{nullptr};
  Rc() {}
public:
  operator bool() { return manager && manager.ptr!=nullptr; }
  T& operator *() { return *(manager->ptr); }
  T* operator ->() { return manager->ptr; }
  
  template<typename TT, class... Args>
  friend RcManager<TT> makeRc(Args&&...);

  bool is_manager() { return manager==this; }
  
  unsigned int use_count() {
    if (manager) return manager->counter;
    else return 0;
  }

  // Rule of FIVE  (so we can have rule of ZERO)

  // destructor
  ~Rc() {
    if (manager) manager->dec_counter();
  }

  // copy = 
  const Rc<T>& operator =(const Rc<T>& other) {
    if (is_manager()) {
      cerr << "Rc manager cannot be reassigned\n";
      return other;
    }
    if (manager) manager->dec_counter(); // prevent mem leaks
    manager = other.manager;
    if (manager) manager->inc_counter();
    //cout << "copy = called\n";
    return other;
  }
  // copy constructor
  Rc(const Rc<T>& other) {
    manager = other.manager;
    if (manager) manager->counter += 1;
    cout << "copy constructor called " << ++ccx << " times\n";
  }

  // move =
  void operator =(Rc<T>&& other) {
    if (other.is_manager()) {
      cerr << "Rc manager cannot be moved - copying assigning\n";
      if (manager) manager->dec_counter(); // prevent mem leaks
      manager = other.manager;
      manager->inc_counter();
      return;
    }
    if (manager) manager->dec_counter(); // prevent mem leaks
    manager = other.manager;
    other.manager = nullptr; // disconnect from data
    //cout << "move = called\n";
  }

  // move constructor
  Rc(Rc<T>&& other) {
    if (other.is_manager()) {  // copy instead
      cerr << "Rc manager cannot be moved - copying instead\n";
      manager = other.manager;
      manager->counter += 1;
      return;      
    }
    manager = other.manager;
    other.manager = nullptr; // disconnect from data
    cout << "move constructor called\n";    
  }

}; // Rc

template<typename T>
class RcManager : public Rc<T> // an RcManager is also an Rc
{
  T* ptr{};
  unsigned int counter{1};
  RcManager(T* p) {  // private constructor called from friend makeRc
    ptr = p;
    Rc<T>::manager = this;  //must access protected vars this way
  }
  void inc_counter() { counter++; }
  void dec_counter() {
    if (counter>0) {
      counter--;
      if (counter == 0 && ptr) delete ptr;
    }
  } // dec_counter
  
public:
  template<typename TT, class... Args>
  friend RcManager<TT> makeRc(Args&&...);

  //template<typename TT, class... Args>
  friend class Rc<T>;
}; // RcManager subclass

template<class TY, class... Args>
RcManager<TY> makeRc(Args&&... args) {
  return RcManager<TY>(new TY(std::forward<Args>(args)...));
  // forward retains original l/r-value status of args
}// make_managed
  

void RcDemo() {
  RcManager<int> rc = makeRc<int>(3);   // this calls move constructor!
  RcManager<int> rrr = makeRc<int>(33);
  Rc<int> rd = rc;
  *rd = 4;

  cout << rc.use_count() << " : init use count\n";
  cout << *rc << " : should be 4\n";
  cout << *rd << " : should be 4\n";
  cout << rc.use_count() << " : should be 2\n";

  Rc<int> re = move(rd); // genuine move construction
  cout << re.use_count() << " : should still be 2\n";
  cout << *re << " : should be 4 again\n";
}

int main() {
  //shared_demo();
  RcDemo();
  //while (1) share_and_leak();
  //while (1) no_more_leak();
  return 0;
}