#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()-1); //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()) //daca nu mai sunt instante in subset
		{
			//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;
}