#pragma once
#include "RefCounter.h"

using namespace std;

template <typename T> class MySmartPointer
{
public:
    MySmartPointer(T* pointer);
    MySmartPointer(const MySmartPointer& otherSmartPointer);
    MySmartPointer(T* arrayPointer[], int size);
    ~MySmartPointer();

    T* getPointer() const;
    int getCounter();

    T& operator*() { return (*pointer); }
    T* operator->() { return pointer; }

    void operator=(const MySmartPointer& otherSmartPointer);

    void copyPointer(const MySmartPointer& otherSmartPointer);
    void decreasePointer();
    void decreaseArrayPointer();

private:
    T* pointer;
    RefCounter* counter;
    int arraySize = 0;
};

template <typename T>
MySmartPointer<T>::MySmartPointer(T* pointer) {
    this->pointer = pointer;
    counter = new RefCounter();
    counter->add();
}

template <typename T>
MySmartPointer<T>::MySmartPointer(const MySmartPointer& otherSmartPointer) {
    if (otherSmartPointer.arraySize != 0) {
        this->pointer = otherSmartPointer.pointer;
        this->arraySize = otherSmartPointer.arraySize;
    }
    else this->pointer = otherSmartPointer.pointer;
    this->counter = otherSmartPointer.counter;
    counter->add();

}

template <typename T>
MySmartPointer<T>::MySmartPointer(T* arrayPointer[], int size) {
    if (size <= 0) throw (-1);
    arraySize = size;
    this->pointer = *arrayPointer;
    counter = new RefCounter();
    counter->add();
}

template <typename T>
MySmartPointer<T>::~MySmartPointer() {
    if (arraySize > 0) {
        decreaseArrayPointer();
    }
    else decreasePointer();
}

template <typename T>
void MySmartPointer<T>::copyPointer(const MySmartPointer& otherSmartPointer) {
    if (otherSmartPointer.arraySize != 0) {
        arraySize = otherSmartPointer.arraySize;
        this->pointer = otherSmartPointer.getArrayPointer();
    }
    else this->pointer = otherSmartPointer.getPointer();

    this->counter = otherSmartPointer.counter;
    counter->add();
}

template <typename T>
void MySmartPointer<T>::decreasePointer() {
    if (counter->get() == 1) {
        delete pointer;
        delete counter;
    }
    else {
        counter->dec();
    }
}

template <typename T>
void MySmartPointer<T>::decreaseArrayPointer() {
    if (counter->get() == 1) {
        delete [] pointer;
        delete counter;
    }
    else {
        counter->dec();
    }
}

template <typename T>
void MySmartPointer<T>::operator=(const MySmartPointer& otherSmartPointer) {
    if (counter->get() == 0) {
        copyPointer(otherSmartPointer);
    }
    else {
        if (arraySize != 0) { decreaseArrayPointer(); }
        else decreasePointer();
        copyPointer(otherSmartPointer);
    }
}


template <typename T>
T* MySmartPointer<T>::getPointer() const {
    return pointer;
}

template <typename T>
int MySmartPointer<T>::getCounter() {
    return counter->get();
}


// MAIN:

IntClass* array[10];
    for (int i = 0; i < 10; i++) {
        array[i] = new IntClass(i);
    }

    MySmartPointer<IntClass> pointer(array, 10);
    MySmartPointer<IntClass> pointer2(pointer);
    cout << pointer.getCounter();