#include "brain/neural_network.h"
#include "brain/neuron.h"
#include <limits>

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

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

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

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

void NeuralNetwork::parseFile(std::istream &&file)
{
    double weight;
    char srcType;
    int srcId;
    int destId;

    while (file.get(srcType) &&
	   file >> srcId &&
	   file.ignore(std::numeric_limits<std::streamsize>::max(), 'n') &&
	   file >> destId &&
	   file >> weight &&
	   file.ignore(std::numeric_limits<std::streamsize>::max(), '\n'))
    {
	
	std::shared_ptr<NeuralNode> source;
	std::shared_ptr<Neuron> destination;
	switch (srcType)
	{
	case 's':
	    source = findOrAddSensor(srcId);
	    break;
	case 'b':
	    source = _biasNode;
	    break;
	default:
	    source = findOrAddNeuron(srcId);
	}
	destination = findOrAddNeuron(destId);
	
	addLink(source, destination, weight);
    }
	 
}

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

std::shared_ptr<Sensor> NeuralNetwork::findOrAddSensor(int id)
{
    auto sensor = _sensors[id];
    if (!sensor)
    {
	sensor = std::make_shared<Sensor>(id);
	_sensors[id] = sensor;
    }
    return sensor;
}

std::shared_ptr<Neuron> NeuralNetwork::findOrAddNeuron(int id)
{
    auto neuron = _neurons[id];
    if (!neuron)
    {
	neuron = std::make_shared<Neuron>(id);
	_neurons[id] = neuron;
    }
    return neuron;
}

void NeuralNetwork::setInput(int inputIndex, double activation)
{
    _sensors.at(inputIndex)->setActivation(activation);
}

int NeuralNetwork::findMaxOutputIndex() const
{
    double currentMaxActivation = 0;
    int currentMaxIndex = 0;
    for (unsigned int i=0; i<_outputs.size(); ++i)
    {
	double activation = _outputs[i]->activation();
	if (activation >= currentMaxActivation)
	{
	    currentMaxActivation = activation;
	    currentMaxIndex = i;
	}
    }
    return currentMaxIndex;
}