#pragma once
#include "Dataset.h"
#include "Tree.h"

// numara de cate ori apare clasa in dataset
int classCount(Dataset ds, std::string className)
{
    int classIndex = ds.nrAttributes - 1;
    int count = 0;
    for (int i = 0; i < ds.nrRecords; ++i)
    {
        if (ds.getDataValue(i, classIndex) == className)
        {
            count++;
        }
    }
    return count;
}

TreeNode *RandomTree(Dataset ds, std::string attribValue)
{
	TreeNode *node = new TreeNode; // se genereaza un nou nod
	node->branchName = attribValue; // ramura care se incheie cu acest nod va avea ca eticheta valoarea atributului nodului parinte

	/*daca toate record-urile din ds au aceeasi clasa,
	node->name = numele clasei respective
	return node;
	*/
    std::string _class = ds.dataValues[ds.dataValues.size() - 1];
    bool sameClass = true;
    for (int i = 1; i < ds.nrAttributes; ++i)
    {
        if (ds.dataValues[i] != _class)
        {
            sameClass = false;
            break;
        }
    }
    if (sameClass)
    {
        node->name = _class;
        return node;
    }

    int attribIdx = rand() % ds.attributes.size(); // alegem un atribut aleator
    node->name = ds.attributes[attribIdx].name; // nodul nou creat ia valoarea acestui atribut

    // cream cate o ramura pentru fiecare valoare a atributului
	for (int i = 0; i < ds.attributes[attribIdx].values.size(); i++)
	{
        std::string attribValue = ds.attributes[attribIdx].values[i]; // valoarea atributului este eticheta noii ramuri

        Dataset subset; // submultimea ce contine elementele din ds cu valoarea attribValue a atributului ales anterior
        subset.name = ds.name;
        subset.nrAttributes = ds.nrAttributes;
        subset.nrRecords = 0;
        for (int i = 0; i < ds.nrAttributes; ++i) // copiem intai atributele
        {
            subset.attributes.push_back(ds.attributes[i]);
        }
        for (int i = 0; i < ds.nrRecords; ++i) // parcurgem multimea de inregistrari
        {
            std::string currVal = ds.getDataValue(i, attribIdx);
            if (currVal == attribValue) // daca am gasit un element cu attribValue
            {
                for (int j = 0; j < ds.nrAttributes; ++j) // copiem inregistrarea respectiva
                {
                    subset.dataValues[subset.nrRecords * subset.nrAttributes + j] = currVal;
                }
                ++subset.nrRecords;
            }
        }

        if (subset.dataValues.empty())
        {
            // facem maximul pe numarul de aparitii ale claselor
            int classIndex = ds.nrAttributes - 1;
            int numberOfClasses = ds.attributes[classIndex].values.size();

            int maxClassCount = classCount(ds, ds.attributes[classIndex].values[0]);
            std::string maxClass = ds.attributes[classIndex].values[0];
            int currentClassCount;
            std::string currentClass;
            for (int i = 1; i < numberOfClasses; ++i)
            {
                currentClassCount = classCount(ds, ds.attributes[classIndex].values[i]);
                currentClass = ds.attributes[classIndex].values[i];

                if (currentClassCount > maxClassCount)
                {
                    maxClassCount = currentClassCount;
                    maxClass = currentClass;
                }
            }

            node->addChild(maxClass /* clasa care apare cel mai frecvent in ds */, attribValue);
        }
        else
        {
            node->addChild(RandomTree(subset, attribValue));
        }
	}

	return node;
}