// EPT8_CM.cpp : This file contains the 'main' function. Program execution begins and ends there.
//

#include <iostream>

using namespace std;
/////////////////////////////////CTAB
#pragma once
#define DEF_TAB_SIZE 10
class CTab
{
public:
    CTab() { pi_tab = new int[DEF_TAB_SIZE]; i_size = DEF_TAB_SIZE; }
    CTab(const CTab& cOther);
    CTab(CTab&& cOther);
    CTab operator=(CTab&& cOther);
    ~CTab();
    bool bSetSize(int iNewSize);
    int iGetSize() { return(i_size); }
private:
    void v_copy(const CTab& cOther);
    int* pi_tab;
    int i_size;
};


bool CTab::bSetSize(int a) {
    if (a <= 0)
        return false;
    i_size = a;
    return true;
}

CTab::CTab(const CTab& cOther)
{
    v_copy(cOther);
    std::cout << "Copy ";
}

CTab::~CTab()
{
    if (pi_tab != NULL) delete pi_tab;
    std::cout << "Destr ";
}

/*
CTab CTab::operator=(const CTab& cOther)
{
    if (pi_tab != NULL) delete pi_tab;
    v_copy(cOther);
    std::cout << "op= ";
    return(*this);
}
*/
CTab CTab::operator=(CTab&& cOther)
{
    std::cout << "op= ";
    pi_tab = cOther.pi_tab;
    i_size = cOther.i_size;
    cOther.pi_tab = NULL;
    return (*this);
}

void CTab::v_copy(const CTab& cOther)
{
    pi_tab = new int[cOther.i_size];
    i_size = cOther.i_size;
    for (int ii = 0; ii < cOther.i_size; ii++)
        pi_tab[ii] = cOther.pi_tab[ii];
}

CTab::CTab(CTab&& cOther)
{
    pi_tab = cOther.pi_tab;
    i_size = cOther.i_size;
    cOther.pi_tab = NULL;
    std::cout << "MOVE ";
}







///////////////////////////////////CTABLE (without move semantics)

const string s_name_default = "default_name";
const int default_table_length = 10;

class CTable {
public:
    CTable();
    CTable(string sName, int iTableLen);
    CTable(const CTable& pcOthe);
    ~CTable();

    void vSetName(string sName);
    bool bSetNewSize(int iTableLen);
    void printTable();
    CTable* pcClone();
    void vSetValueAt(int iOffset, int iNewVal);

    string s_name;
    int* table;
    int table_length;

    CTable operator + (CTable& tableToConcat);
    void operator=(CTable& tableToConcat);


};



void CTable::vSetName(string sName) {
    s_name = sName;
}

bool CTable::bSetNewSize(int iTableLen) {
    if (iTableLen <= 0) {
        return false;
    }
    int* table = new int[iTableLen];
    table_length = iTableLen;
    return true;
}

CTable* CTable::pcClone() {
    CTable clone(*this);
    return &clone;
}

CTable::CTable() {
    s_name = s_name_default;
    cout << "without: " << s_name << endl;
    table = new int[default_table_length];
    table_length = default_table_length;
}

CTable::CTable(string sName, int iTableLen) {
    s_name = sName;
    cout << "parameter: " << s_name << endl;
    table = new int[iTableLen];
    table_length = iTableLen;
}

CTable::CTable(const CTable& obj) {
    s_name = obj.s_name + "_copy";
    table = new int[obj.table_length];
    table_length = obj.table_length;

    for (int i = 0; i < obj.table_length; i++) {
        table[i] = obj.table[i];
    }
    cout << "copy: " << s_name << endl;
}


CTable::~CTable() {
    cout << "removing: " << s_name << endl;
    delete[] table;
}


void v_mod_tab(CTable* pcTab, int iNewSize) {
    if (iNewSize > 0) {
        pcTab->table = new int[iNewSize];
        pcTab->table_length = iNewSize;
    }
}
void v_mod_tab(CTable cTab, int iNewSize) {
    if (iNewSize > 0) {
        cTab.table = new int[iNewSize];
        cTab.table_length = iNewSize;
    }
}

void CTable::printTable() {
    for (int i = 0; i < table_length; i++) {
        cout << "Element " << i << " value: " << table[i] << endl;
    }
    cout << endl;
}

void CTable::vSetValueAt(int iOffset, int iNewVal) {
    if (iOffset >= table_length) return;
    table[iOffset] = iNewVal;
}

/*
CTable CTable::operator + (CTable &tableToConcat) {

    int newSize = table_length + tableToConcat.table_length;
    CTable newCt("obj3", newSize);


    for (int i = 0, j = 0; i < newSize; i++) {
        if (i < table_length) {
            newCt.table[i] = table[i];
        }
        else {
            newCt.table[i] = tableToConcat.table[j++];
        }
    //  cout<<"ADDING: "<< newCt.table[i]<<endl;
    }

    return newCt;
}
*/

CTable CTable::operator + (CTable& tableToConcat) {

    int newSize;
    if (table_length > tableToConcat.table_length) {
        newSize = table_length;
    }
    else {
        newSize = tableToConcat.table_length;
    }

    CTable newCt("obj3", newSize);


    for (int i = 0, j = 0; i < newSize; i++) {
        if (i > tableToConcat.table_length - 1) {
            newCt.table[i] = table[i];
            //newCt.table[i] = 0;
        }
        else if (i > table_length - 1) {
            newCt.table[i] = tableToConcat.table[i];
            //newCt.table[i] = 0;
        }
        else
        {
            newCt.table[i] = table[i] + tableToConcat.table[i];
        }

    }

    return newCt;
}

void CTable::operator=(CTable& tableToConcat) {

    delete[] table;
    int size = tableToConcat.table_length;
    table = new int[size];

    for (int i = 0; i < size; i++) {
        table[i] = tableToConcat.table[i];
    }

}





/////////////////////////////////CTABLEMOVE
class CTable_move {
public:
    CTable_move();
    CTable_move(string sName, int iTableLen);
    CTable_move(const CTable_move& pcOthe);
    ~CTable_move();

    void vSetName(string sName);
    bool bSetNewSize(int iTableLen);
    void printTable();
    CTable_move* pcClone();
    void vSetValueAt(int iOffset, int iNewVal);

    string s_name;
    int* table;
    int table_length;

    // Stuff added in lab 8
    CTable_move(CTable_move&& other); // move constructor
    CTable_move& operator=(CTable_move&& other); // move assignment
    CTable_move operator+ (CTable_move&& other);

};


void CTable_move::vSetName(string sName) {
    s_name = sName;
}

bool CTable_move::bSetNewSize(int iTableLen) {
    if (iTableLen <= 0) {
        return false;
    }
    int* table = new int[iTableLen];
    table_length = iTableLen;
    return true;
}

CTable_move* CTable_move::pcClone() {
    CTable_move clone(*this);
    return &clone;
}

CTable_move::CTable_move() {
    s_name = "default_name";
    cout << "without: " << s_name << endl;
    table = new int[10];
    table_length = 10;
}

CTable_move::CTable_move(string sName, int iTableLen) {
    s_name = sName;
    cout << "parameter: " << s_name << endl;
    table = new int[iTableLen];
    table_length = iTableLen;
}

CTable_move::CTable_move(const CTable_move& obj) {
    s_name = obj.s_name + "_copy";
    table = new int[obj.table_length];
    table_length = obj.table_length;

    for (int i = 0; i < obj.table_length; i++) {
        table[i] = obj.table[i];
    }
    cout << "copy: " << s_name << endl;
}


CTable_move::~CTable_move() {
    cout << "removing: " << s_name << endl;
    delete[] table;
}


void v_mod_tab(CTable_move* pcTab, int iNewSize) {
    if (iNewSize > 0) {
        pcTab->table = new int[iNewSize];
        pcTab->table_length = iNewSize;
    }
}
void v_mod_tab(CTable_move cTab, int iNewSize) {
    if (iNewSize > 0) {
        cTab.table = new int[iNewSize];
        cTab.table_length = iNewSize;
    }
}

void CTable_move::printTable() {
    for (int i = 0; i < table_length; i++) {
        cout << "Element " << i << " value: " << table[i] << endl;
    }
    cout << endl;
}

void CTable_move::vSetValueAt(int iOffset, int iNewVal) {
    if (iOffset >= table_length) return;
    table[iOffset] = iNewVal;
}

CTable_move CTable_move::operator + (CTable_move&& tableToConcat) {

    int newSize;
    if (table_length > tableToConcat.table_length) {
        newSize = table_length;
    }
    else {
        newSize = tableToConcat.table_length;
    }

    CTable_move newCt("obj3", newSize);


    for (int i = 0, j = 0; i < newSize; i++) {
        if (i > tableToConcat.table_length - 1) {
            newCt.table[i] = table[i];
            //newCt.table[i] = 0;
        }
        else if (i > table_length - 1) {
            newCt.table[i] = tableToConcat.table[i];
            //newCt.table[i] = 0;
        }
        else
        {
            newCt.table[i] = table[i] + tableToConcat.table[i];
        }

    }

    return newCt;
}

// MOVE
CTable_move::CTable_move(CTable_move&& other) {
    table = other.table;
    table_length = other.table_length;

    other.table = NULL;
    other.table_length = 0;
}

CTable_move& CTable_move::operator=(CTable_move&& other) {

    if (this != &other)
    {
        delete[] table;

        table = other.table;
        table_length = other.table_length;

        other.table = NULL;
        other.table_length = 0;
    }
    return *this;
    //return(std::move(*this));
}


///////////////////////////////////TESTING
CTab cCreateTab()
{
    CTab c_result;
    c_result.bSetSize(5);
    return(std::move(c_result));
}
CTable_move cCreateTableMove()
{
    CTable_move c_result;
    c_result.bSetNewSize(5);
    return(std::move(c_result));
}
CTable cCreateTable()
{
    CTable c_result;
    c_result.bSetNewSize(5);
    return c_result;
}

int main()
{

    cout << "\n= operator WITH move -0 copies\n" << endl;
    CTable_move ctab1 = cCreateTableMove();
    CTable_move ctab2 = cCreateTableMove();
    ctab1 = std::move(ctab2);


    cout << "\n\n= operator WITHOUT move -2 copies\n" << endl;
    CTable ctab3 = cCreateTable();
    CTable ctab4 = cCreateTable();
    ctab3 = ctab3;


    cout << "\n\n+ operator without MOVE -3 copies\n" << endl;
    CTable ctab5 = cCreateTable();
    CTable ctab6 = cCreateTable();
    ctab5 + ctab6;


    cout << "\n\n+ operator with MOVE -0 copies\n" << endl;
    CTable_move ctab7 = cCreateTableMove();
    CTable_move ctab8 = cCreateTableMove();
    ctab7 + std::move(ctab8);


    cout << "\n\n\n\n\nend - deallocation\n" << endl;
    /*
    cout << "\n--- TASK 3 ---\n" << endl;

    CTable c_tab_0, c_tab_1;
    c_tab_0.bSetNewSize(6);
    c_tab_1.bSetNewSize(4);

    c_tab_0.vSetValueAt(0, 0);
    c_tab_0.vSetValueAt(1, 1);
    c_tab_0.vSetValueAt(2, 2);
    c_tab_0.vSetValueAt(3, 3);
    c_tab_0.vSetValueAt(4, 4);
    c_tab_0.vSetValueAt(5, 5);


    c_tab_1.vSetValueAt(0, 50);
    c_tab_1.vSetValueAt(1, 51);
    c_tab_1.vSetValueAt(2, 52);
    c_tab_1.vSetValueAt(3, 53);


    cout << "\ntable 0 : \n";
    c_tab_0.printTable();
    cout << "table 1 : \n";
    c_tab_1.printTable();

    CTable c_tab_2 = (c_tab_0 + c_tab_1);
    c_tab_1.vSetValueAt(2, 123);


    cout << "\ntable 2 : \n";
    c_tab_2.printTable();

    cout << "\n--END--\n\n";
    */
}