#include"network.h"
#include<fstream>


//remove all pointers to a link, and delete the link
bool Network::removeLink (NetLink* l) {
	
	bool flag=true;

	vector<NetLink *>::iterator link_itr;
	link_itr = find(l->out_node->in_links.begin(), l->out_node->in_links.end(), l);
	if( link_itr != l->out_node->in_links.end() )
		l->out_node->in_links.erase(link_itr);
	else flag=false;

	link_itr = find(l->in_node->out_links.begin(), l->in_node->out_links.end(), l);
	if( link_itr != l->in_node->out_links.end() )
		l->in_node->out_links.erase(link_itr);
	else flag=false;

	delete l;
	if(flag) num_links--;
	return flag;
}


bool Network::removeNode (NetNode* n) {

	vector<NetNode *>::iterator node_itr;
	node_itr = find(all_nodes.begin(), all_nodes.end(), n);

	if( node_itr != all_nodes.end() ) {

		//node is in network node list
		//delete all links coming in/going out of this node
		//remove node from list
		vector<NetLink *>::iterator link_itr;
		while( !n->in_links.empty() )
			removeLink( *(n->in_links.begin()) );
		while( !n->out_links.empty() )
			removeLink( *(n->out_links.begin()) );
		all_nodes.erase(node_itr);

		//remove node from in_nodes list
		node_itr = find(in_nodes.begin(), in_nodes.end(), n);
		if( node_itr != in_nodes.end() )
			in_nodes.erase(node_itr);

		//remove node from out_nodes list
		node_itr = find(out_nodes.begin(), out_nodes.end(), n);
		if( node_itr != out_nodes.end() )
			out_nodes.erase(node_itr);

		delete n;
		num_nodes--;
		return true;

	}
	else return false;
}

//in_or_out: -1 is out, 1 is in, 0 is neither
bool Network::addNode(NetNode* n, int in_or_out) {
	all_nodes.push_back(n);
	if(in_or_out < 0)
		out_nodes.push_back(n);
	else if(in_or_out > 0)
		in_nodes.push_back(n);
	num_nodes++;
	return true;
}

bool Network::clearActivationFlags() {

	//set all activation flags to false
	vector<NetNode*>::iterator node_itr;
	for(node_itr = all_nodes.begin(); node_itr != all_nodes.end(); node_itr++)
		(*node_itr)->activated = false;
	return true;
}

bool Network::outputsActive() {

	//check if all output nodes have been activated
	vector<NetNode*>::iterator node_itr;
	for(node_itr = out_nodes.begin(); node_itr != out_nodes.end(); node_itr++)
		if( !((*node_itr)->activated) )
			return false;
	return true;

}

bool Network::activateNetwork() {
	
	vector<NetNode*>::iterator node_itr;
	vector<NetLink*>::iterator link_itr;
	while(!outputsActive()) {
		for(node_itr = all_nodes.begin(); 
			node_itr != all_nodes.end(); 
			node_itr++) {
			float x = 0.f;
			bool flag=false;
			for(link_itr = (*node_itr)->in_links.begin(); 
				link_itr != (*node_itr)->in_links.end(); 
				link_itr++) {
				if( (*link_itr)->in_node->activated ) {
					flag=true;
					x += (*link_itr)->weight * (*link_itr)->in_node->value;
				}
				else {
					flag=false;
					break;	
				}
			}
			if(flag) {
				(*node_itr)->value = sigmoid(x);
				(*node_itr)->activated = true;
			}
		}
	}
	return true;
}

void Network::runNet(unsigned int in_count, float * inputs, unsigned int out_count, float * outputs) {
	int i;
	clearActivationFlags();
	for(i=0; i<in_count; i++) {
		in_nodes[i]->value = inputs[i];
		in_nodes[i]->activated = true;
	}
	activateNetwork();
	for(i=0; i<out_count; i++)
		outputs[i] = out_nodes[i]->value;
}

float Network::runNet(unsigned int in_count, float * inputs) {
	int i;
	clearActivationFlags();
	for(i=0; i<in_count; i++) {
		in_nodes[i]->value = inputs[i];
		in_nodes[i]->activated = true;
	}
	activateNetwork();
	return out_nodes[0]->value;
}

//input network from file
bool Network::inputFile(string& filename) {
	ifstream input;
	input.open(filename.c_str());
	if(!input.is_open())
		return false;

	int i;
	int type;
	float weight;
	unsigned int n_id, l_id, n_in, n_out;
	num_nodes=0;
	num_links=0;
	unsigned int num_n, num_l;

	vector<NetNode *> nodes;
	input>>num_n;
	for(i=0; i<num_n; i++) {
		input>>n_id;
		input>>type;
		nodes.push_back(new NetNode(type, n_id));
	}

	//create links and add to nodes
	//node numbers provided for links are based off place in the 
	//node list inside the file (implicit ordering), not id numbers
	NetLink* link;
	input>>num_l;
	for(i=0; i<num_l; i++) {
		input>>l_id;
		input>>n_in;
		input>>n_out;
		input>>weight;
		link = new NetLink(nodes[n_in], nodes[n_out], weight, l_id);
		nodes[n_in]->addLinkOut(link);
		nodes[n_out]->addLinkIn(link);
		num_links++;
	}

	//add nodes to network
	for(i=0; i<num_n; i++) {
		addNode(nodes[i], nodes[i]->type);
	}

	input.close();
	return true;
}

//output network to file
bool Network::outputFile(string& filename) {
	ofstream output;
	output.open(filename.c_str());
	if(!output.is_open())
		return false;

	int i, j;

	output<<num_nodes<<endl;

	for(i=0; i<num_nodes; i++) {
		output<<all_nodes[i]->id<<" "<<all_nodes[i]->type<<endl;
	}

	output<<num_links<<endl;

	vector<NetLink *>::iterator link_itr;
	for(i=0; i<num_nodes; i++) {
		for(link_itr = all_nodes[i]->out_links.begin();
			link_itr != all_nodes[i]->out_links.end();
			link_itr++) {
				
				output<<(*link_itr)->id<<" ";
				output<<i<<" ";
				for(j=0; j<num_nodes; j++) {
					if( all_nodes[j] == (*link_itr)->out_node ) {
						output<<j<<" "; break;
					}
				}
				output<<(*link_itr)->weight<<endl;
			}
	}
	output.close();
	return true;
}