template <class T> class Ptr;

class PteBase {
protected:
	struct Prec {
		PteBase *ptr;
		Atomic   n;
		bool autodelete;
	};

	volatile Prec  *prec;

	Prec           *PtrAdd();
	void Autodelete();
	static void     PtrRelease(Prec *prec);
	static Prec    *PtrAdd(const Uuid& uuid);
	static void Lock();
	static void Unlock();
	
	PteBase();
	~PteBase();

	friend class PtrBase;
};

class PtrBase {
protected:
	PteBase::Prec *prec;
	void Set(PteBase *p);
	virtual void Release();
	void Assign(PteBase *p);
public:
	virtual ~PtrBase();
};

template <class T>
class Pte : public PteBase {
	friend class Ptr<T>;
};

template <class T>
class PteAuto : public PteBase {
	friend class Ptr<T>;
public:
	PteAuto(){PteBase::Autodelete();}
};

template <class T>
class Ptr : public PtrBase, Moveable< Ptr<T> > {
	T   *Get() const                          { return prec&&prec->ptr ? static_cast<T *>(prec->ptr) : NULL; }
protected:
	void Release();
	void Autodelete();
public:
	T       *operator->() const               { return Get(); }
	T       *operator~() const                { return Get(); }
	operator T*() const                       { return Get(); }

	Ptr& operator=(T *ptr)                    { Assign(ptr); return *this; }
	Ptr& operator=(const Ptr& ptr)            { Assign(ptr.Get()); return *this; }

	Ptr()                                     { prec = NULL; }
	Ptr(T *ptr)                               { Set(ptr); }
	Ptr(const Ptr& ptr)                       { Set(ptr.Get()); }
	~Ptr()                                    { Autodelete(); }
	String ToString() const;

	friend bool operator==(const Ptr& a, const T *b)   { return a.Get() == b; }
	friend bool operator==(const T *a, const Ptr& b)   { return a == b.Get(); }
	friend bool operator==(const Ptr& a, const Ptr& b) { return a.prec == b.prec; }

	friend bool operator==(const Ptr& a, T *b)         { return a.Get() == b; }
	friend bool operator==(T *a, const Ptr& b)         { return a == b.Get(); }

	friend bool operator!=(const Ptr& a, const T *b)   { return a.Get() != b; }
	friend bool operator!=(const T *a, const Ptr& b)   { return a != b.Get(); }
	friend bool operator!=(const Ptr& a, const Ptr& b) { return a.prec != b.prec; }

	friend bool operator!=(const Ptr& a, T *b)         { return a.Get() != b; }
	friend bool operator!=(T *a, const Ptr& b)         { return a != b.Get(); }
};

template<class T>
void Ptr<T>::Release(){
	Autodelete();
	PtrBase::Release();
}

template<class T>
void Ptr<T>::Autodelete(){
	PteBase::Lock();
	if(prec&&prec->autodelete&&prec->ptr&&prec->n < 2){
		delete (T*)(prec->ptr);
		prec->ptr = NULL;
	}
	PteBase::Unlock();
}

template <class T>
String Ptr<T>::ToString() const{
	return prec&&prec->ptr ? FormatPtr(Get()) : String("0x0");
}

#include "Core.h"

NAMESPACE_UPP

static StaticCriticalSection sPteLock;

void PteBase::Lock(){
	sPteLock.Enter();
}

void PteBase::Unlock(){
	sPteLock.Leave();
}

PteBase::Prec *PteBase::PtrAdd(){
	sPteLock.Enter();
	if(prec) {
		++prec->n;
		sPteLock.Leave();
	}
	else {
		sPteLock.Leave();
		prec = new Prec;
		prec->n = 1;
		prec->ptr = this;
		prec->autodelete = false;
	}
	return const_cast<Prec *>(prec);
}

void PteBase::PtrRelease(Prec *prec){
	CriticalSection::Lock __(sPteLock);
	if(prec && --prec->n == 0){
		if(prec->ptr){
			prec->ptr->prec = NULL;
		}
		delete prec;
		prec = NULL;
	}
}

void PteBase::Autodelete(){
	if(!prec){
		prec = new Prec;
		prec->n = 0;
		prec->ptr = this;
	}
	prec->autodelete = true;
}

PteBase::PteBase(){
	prec = NULL;
}

PteBase::~PteBase(){
	CriticalSection::Lock __(sPteLock);
	if(prec)
		prec->ptr = NULL;
}

void PtrBase::Release(){
	PteBase::PtrRelease(prec);
}

void PtrBase::Set(PteBase *p){
	prec = p ? p->PtrAdd() : NULL;
}

void PtrBase::Assign(PteBase *p){
	Release();
	Set(p);
}

PtrBase::~PtrBase(){
	Release();
}

END_UPP_NAMESPACE

#include <Core/Core.h>

using namespace Upp;

struct Foo : PteAuto<Foo> {
	String text;
};

Foo* factory(){
	return new Foo;
}

CONSOLE_APP_MAIN
{
	Ptr<Foo> ptr;
	{
		Ptr<Foo> ptr1 = new Foo;
		ptr1->text = "Text";
		ptr = ptr1;
		Cout() << (void*)~ptr << " -> " << ptr->text << "\n";
	}
	Cout() << "-------------\n";
	Cout() << (void*)~ptr << "\n";
	ptr = factory();
	ptr = factory();
}

class PteBase {
protected:
	struct Prec {
		PteBase *ptr;
		Atomic   n;
	};
	
	virtual void OnPrecDelete() {};
	
	volatile Prec  *prec;

	Prec           *PtrAdd();
	static void     PtrRelease(Prec *prec);
	static Prec    *PtrAdd(const Uuid& uuid);
	
	PteBase();
	~PteBase();

	friend class PtrBase;
};

void PteBase::PtrRelease(Prec *prec){
	CriticalSection::Lock __(sPteLock);
	if(prec && --prec->n == 0){
		if(prec->ptr){
			prec->ptr->prec = NULL;
			prec->ptr->OnPrecDelete();
		}
		delete prec;
		prec = NULL;
	}
}

#include <Core/Core.h>

using namespace Upp;

struct Foo : public Pte<Foo> {
	String text;
	~Foo();
protected:
	virtual void OnPrecDelete(){delete (Foo*)this;}
};

Foo::~Foo(){
	Cout() << "deleted " << (void*)(this) << "\n";
}

Foo* factory(){
	return new Foo;
}

CONSOLE_APP_MAIN
{
	Ptr<Foo> ptr;
	{
		Ptr<Foo> ptr1 = new Foo;
		ptr1->text = "Text";
		ptr = ptr1;
		Cout() << (void*)~ptr << " -> " << ptr->text << "\n";
	}
	Cout() << "-------------\n";
	Cout() << (void*)~ptr << "\n";
	ptr = factory();
	ptr = factory();
}

//shared pointer
//idea borrowed from boost shared_ptr, an additional chunk of memory is managed
//which centrally holds the refcount of that object pointed to
//if Shared is created freshly, it AtomicInc's the ref count to 1;
//if a Shared is destroyed it AtomicDec's the refcount, and if its 0,
//	it will delete both, the object and the refcount chunk
//if another instance is created as copy, the refcount is taken and incremented.
//if it is assigned, it decrements own existing counter, possibly releasing mem, and retains new
//pick semantic is not needed here anymore, it not even is possible
//since an 'operator=(const Shared<>&) is needed to aquire the source. pick is const in some cases as well)
//thus Shared is only Moveable, without deepcopyoption, which in fact would speak agains the idea of Shared anyway
//Attach / Detach remains

template <class T>
class Shared : Moveable< Shared<T> > {
	mutable T  *ptr;
	Atomic     *rfc;

	void Retain() const { ASSERT(rfc); AtomicInc(*rfc); }
	void Release()      { ASSERT(rfc); if(AtomicDec(*rfc) == 0) { Free(); delete rfc; rfc = NULL; } }

	void        Free()                     { if(ptr && ptr != (T*)1) delete ptr; }
	void        Chk() const                { ASSERT(ptr != (T*)1); }
	void        ChkP() const               { Chk(); ASSERT(ptr); }

public:
	void        Attach(T *data)            { Free(); ptr = data; }
	T          *Detach() pick_             { ChkP(); T *t = ptr; ptr = NULL; return t; }
	T          *operator-() pick_          { return Detach(); }
	void        Clear()                    { Free(); ptr = NULL; }

	void        operator=(T *data)         { Attach(data); }
	void        operator=(const Shared<T>& d){ Release(); ptr = d.ptr; rfc = d.rfc; Retain(); }
	void        operator=(pick_ One<T>& d) { Attach(d.Detach()); }

	const T    *operator->() const         { ChkP(); return ptr; }
	T          *operator->()               { ChkP(); return ptr; }
	const T    *operator~() const          { Chk(); return ptr; }
	T          *operator~()                { Chk(); return ptr; }
	const T&    operator*() const          { ChkP(); return *ptr; }
	T&          operator*()                { ChkP(); return *ptr; }

	template <class TT>
	TT&         Create()                   { TT *q = new TT; Attach(q); return *q; }
	T&          Create()                   { T *q = new T; Attach(q); return *q; }

	bool        IsEmpty() const            { Chk(); return !ptr; }

	operator bool() const                  { return ptr; }

	Shared()                               { ptr = NULL; rfc = new Atomic(1); }
	Shared(T *newt)                        { ptr = newt; rfc = new Atomic(1); }
	Shared(const Shared<T>& p)             { ptr = p.ptr; rfc = p.rfc; Retain(); }
	~Shared()                              { Release(); }

	Shared(pick_ One<T>& p)                { ptr = p.Detach(); rfc = new Atomic(1); }
	Shared(const One<T>& p, int)           { ptr = DeepCopyNew(*p); rfc = new Atomic(1); }
};

Shared<Size> Test(Shared<Size> s)
{
	if(!s.IsEmpty())
		RLOG(*s);
	return s;	
}

CONSOLE_APP_MAIN
{
	Shared<Size> p;
	{
	Shared<Size> s;

	s.Create();
	*s = Size(123,456);

	Shared<Size> q;
	q = Test(s);
	
	p = q;
	}
	if(!p.IsEmpty())
		RLOG(*p);
	One<Size> os;

	os.Create();
	*os = Size(1,2);
	p = os;
	RLOG(*p);

	os.Create();
	*os = Size(3,4);
	p = Shared<Size>(os);
	RLOG(*p);
}