#include "brain/neural_network.h"
#include "brain/neuron.h"

NeuralNetwork::NeuralNetwork(std::istream &&networkConfigFile, int numberOfSensors, int numberOfOutputs)
{
    _biasNode = std::make_shared<BiasNode>();
    
    for (int i=0; i<numberOfSensors; ++i)
    {
	_sensors.push_back(std::make_shared<Sensor>(i));
    }
    for (int i=0; i<numberOfOutputs; ++i)
    {
	_outputs.push_back(std::make_shared<Neuron>(i));
    }

    parseFile(std::move(networkConfigFile));
}

NeuralNetwork::NeuralNetwork(std::istream &&networkConfigFile, std::vector<bool> sensorInitialValues, int numberOfOutputs)
{
    _biasNode = std::make_shared<BiasNode>();
    
    for (int i=0; i<sensorInitialValues.size(); ++i)
    {
	auto sensor = std::make_shared<Sensor>(i);
	sensor->setActivation(sensorInitialValues.at(i) ? 1 : 0);
	_sensors.push_back(sensor);
    }
    for (int i=0; i<numberOfOutputs; ++i)
    {
	_outputs.push_back(std::make_shared<Neuron>(i));
    }

    parseFile(std::move(networkConfigFile));
}

void NeuralNetwork::parseFile(std::istream &&file)
{
    double weight;
    for (std::string src, dest;
	 file >> src && file >> dest && file >> weight; )
    {
	char srcType = src.at(0);
	int srcId = std::stoi(src.substr(1));
	char destType = dest.at(0);
	int destId = std::stoi(dest.substr(1));

	std::shared_ptr<NeuralNode> source;
	std::shared_ptr<Neuron> destination;
	switch (srcType)
	{
	case 's':
	    source = findOrAddSensor(srcId);
	    break;
	case 'b':
	    source = _biasNode;
	    break;
	case 'n':
	    source = findOrAddNeuron(srcId);
	    break;
	default:
	    throw 1;
	}
	switch (destType)
	{
	case 'n':
	    destination = findOrAddNeuron(destId);
	    break;
	default:
	    throw 1;
	}

	addLink(source, destination, weight);
    }
	 
}

void NeuralNetwork::addLink(std::shared_ptr<NeuralNode> source, std::shared_ptr<Neuron> destination, double weight)
{
    auto link = std::make_shared<NeuralLink>(source, weight);
    destination->addInput(link);
}

std::shared_ptr<Sensor> NeuralNetwork::findOrAddSensor(int id)
{
    std::shared_ptr<Sensor> result;
    for (auto node : _sensors)
    {
	if (node->id() == id)
	{
	    result = node;
	    break;
	}
    }
    if (!result)
    {
	result = std::make_shared<Sensor>(id);
	_sensors.push_back(result);
    }
    return result;
}

std::shared_ptr<Neuron> NeuralNetwork::findOrAddNeuron(int id)
{
    std::shared_ptr<Neuron> result;
    for (auto node : _hiddenNodes)
    {
	if (node->id() == id)
	{
	    result = node;
	    break;
	}
    }
    if (result)
    {
	return result;
    }
    for (auto node : _outputs)
    {
	if (node->id() == id)
	{
	    result = node;
	    break;
	}
    }
    if (result)
    {
	return result;
    }
    
    result = std::make_shared<Neuron>(id);
    _hiddenNodes.push_back(result);
    return result;
}

void NeuralNetwork::setInput(int inputIndex, double activation)
{
    for (auto sensor : _sensors)
    {
	if (sensor->id() == inputIndex)
	{
	    sensor->setActivation(activation);
	    break;
	}
    }
}

int NeuralNetwork::findMaxOutputIndex() const
{
    double currentMaxActivation = 0;
    int currentMaxIndex = 0;
    for (auto output : _outputs)
    {
	double activation = output->activation();
	if (activation >= currentMaxActivation)
	{
	    currentMaxActivation = activation;
	    currentMaxIndex = output->id();
	}
    }
    return currentMaxIndex;
}