#include <iostream>
#include <sys/types.h>
#include <sys/wait.h>
#include "tinyxml.h"
#include "tinystr.h"
#include "socket/ServerSocket.h"
#include "socket/SocketException.h"

using namespace std;

#define SERVER_PORT 30000

struct CE_Info {
	int numUtilities;
	int numParameters;
	int numObservables;
};

struct Utility {
	string name;
	string units;
	string goal;
	float target;
    float value;
};
struct Affect {
	Utility * u;
	string relation;
};
struct Parameter {
	string name;
	string units;
	float min;
	int numAffects;
	Affect affection_list[10];
	float max;
	float step;
    float value;
};

struct Observable {
	string name;
	Affect affection_list[10];
	int numAffects;
    float value;
};

void print_current_config(Utility * uList[], Parameter * pList[], Observable * oList[], CE_Info * ce_info) {
	int i = 0;
	int j = 0;

	for(i = 0; i < ce_info->numUtilities ; i++) {
		cout << "Utility:  " << uList[i]->name << endl;
		cout << "     Units:  " << uList[i]->units << endl;
		cout << "     Goal:   " << uList[i]->goal << endl;
		cout << "     Target: " << uList[i]->target << endl;
	}

	for(i = 0; i < ce_info->numParameters; i++) {
		cout << "Parameter:  " << pList[i]->name << endl;
		cout << "       Units:   " << pList[i]->units << endl;
		cout << "       Min:     " << pList[i]->min << endl;
		cout << "       Max:     " << pList[i]->max << endl;
		cout << "       Step:    " << pList[i]->step << endl;
		for(j = 0; j < pList[i]->numAffects; j++) {
			cout << "       Affect: " << pList[i]->affection_list[j].u->name << " -> " << pList[i]->affection_list[j].relation << endl;
		}
	}
	
    for(i = 0; i < ce_info->numObservables; i++) {
		cout << "Observable:  " << oList[i]->name << endl;
		for(j = 0; j < oList[i]->numAffects; j++) {
			cout << "       Affect: " << oList[i]->affection_list[j].u->name << " -> " << oList[i]->affection_list[j].relation << endl;
		}
	}
}


int parse_ce_config( TiXmlDocument * doc , Utility * u[], Parameter * p[], Observable * o[], CE_Info * ce_info) {

	TiXmlElement* pElem;	//!current element
	TiXmlElement* pChild;	//!current child of pElem
	TiXmlElement* pChild1;	//!current child of pElem
	TiXmlElement* pSecondChild;	//!current child of pElem
	TiXmlHandle hDoc(doc);	//!handle to xml document
	TiXmlHandle hRoot(0); //! handle to root element 

	int count = 0;
	int i = 0;
	int j = 0;
	int k = 0;

	pElem = hDoc.FirstChildElement().Element();
	if(!pElem) { cout << "no valid root! quit-ing function!" << endl; return 0; }
	hRoot = TiXmlHandle(pElem);

	// Pull utility information from XML file.

	pElem = hRoot.FirstChild("utilities").Element();
	pChild1 = hRoot.Child("utilities",count).Element();


	for(pChild = pChild1->FirstChildElement("utility"); pChild; pChild = pChild->NextSiblingElement())
     	{
		u[i] = new Utility;
   		const char *uName = pChild->Attribute("name");
   		if(uName) u[i]->name = uName;	
		const char *uUnits = pChild->Attribute("units");
   		if(uUnits) u[i]->units = uUnits;
   		const char *uGoal = pChild->Attribute("goal");
   		if(uGoal) u[i]->goal = uGoal;
   		if(pChild->QueryFloatAttribute("target",&u[i]->target) != TIXML_SUCCESS) u[i]->target = -1;
		i++;
	}
	ce_info->numUtilities = i;	
	cout << "Parsed " << ce_info->numUtilities << " utilities." << endl;

	// Pull observable information from XML file.
	i = 0;
	pElem = hRoot.FirstChild("observables").Element();
	pChild1 = hRoot.Child("observables",count).Element();
	
	for(pChild = pChild1->FirstChildElement("observable"); pChild; pChild = pChild->NextSiblingElement())
     	{

   		const char *oName = pChild->Attribute("name");
		o[i] = new Observable;

   		if(oName) o[i]->name = oName;
		
		j = 0;
		for(pSecondChild = pChild->FirstChildElement("affect"); pSecondChild; pSecondChild = pSecondChild->NextSiblingElement())
		{
   			const char *oUtilName = pSecondChild->Attribute("utility");

   			// If a utility affects this parameter find the utility object and assign it
			if(oUtilName) {
				// Search for correct utility
				for(k=0;k<10;k++){
					if(u[k]->name == oUtilName) {
						o[i]->affection_list[j].u = u[k];
				 		break;
					}
				}
			}
			
			// Set relationship
			const char *oRelate = pSecondChild->Attribute("relationship");
   			if(oRelate) o[i]->affection_list[j].relation = oRelate;
			j++;
		}
		o[i]->numAffects = j; 
		i++;
	}
	ce_info->numObservables = i;	
	cout << "Parsed " << ce_info->numObservables << " observables." << endl;
	

	// Pull parameter information from XML file.
	pElem = hRoot.FirstChild("parameters").Element();
	pChild1 = hRoot.Child("parameters",count).Element();
	
	i = 0;
	for(pChild = pChild1->FirstChildElement("parameter"); pChild; pChild = pChild->NextSiblingElement())
     	{
		p[i] = new Parameter;

		const char *pName = pChild->Attribute("name");
   		if(pName) p[i]->name = pName;	
		const char *pUnits = pChild->Attribute("units");
   		if(pUnits) p[i]->units = pUnits;

   		if(pChild->QueryFloatAttribute("min",&p[i]->min) != TIXML_SUCCESS) p[i]->min = -1;
   		if(pChild->QueryFloatAttribute("max",&p[i]->max) != TIXML_SUCCESS) p[i]->max = -1;
   		if(pChild->QueryFloatAttribute("step",&p[i]->step) != TIXML_SUCCESS) p[i]->step = -1;
		
		j = 0;
		for(pSecondChild = pChild->FirstChildElement("affect"); pSecondChild; pSecondChild = pSecondChild->NextSiblingElement())
		{
   			const char *pUtilName = pSecondChild->Attribute("utility");
   			
			// If a utility affects this parameter find the utility object and assign it
			if(pUtilName) {
				// Search for correct utility
				for( k=0 ; u[k]!=NULL ; k++ ){
					if(u[k]->name == pUtilName) {
						p[i]->affection_list[j].u = u[k];	
						break;
					}
				}
			}
			
			// Set relationship
			const char *pRelate = pSecondChild->Attribute("relationship");
   			if(pRelate) {
				p[i]->affection_list[j].relation = pRelate;
			} else {
				cout << "Error: No relation found." << endl;
			}
			j++;
		
		}
		p[i]->numAffects = j; 
		i++;

	}
	ce_info->numParameters = i;	
	cout << "Parsed " << ce_info->numParameters << " parameters." << endl;
	return 1;
}


void error(char *msg)
{
    perror(msg);
    exit(1);
}

int ReceiveMessage(int socketfd, string message) {
	
	char buffer[256];
	int n;

	// Clear incoming data buffer
    	bzero(buffer,256);
    
	// Wait for incoming message
	n = read(socketfd,buffer,256);
	
	// Print message
    	if (n > 0) 
        	printf("Here is the received meessage: %s\n",buffer);
    	if(n == 0)
        	printf("Client closed the socket.\n");
	
    	return n;
}

int SendMessage(int socketfd, string message) {
	int n;

	message.append("\0000");	
	// Write message back to client
    	n = write(socketfd,message.c_str(),(message.size()+1));
    	if (n<0)
        	error("Error sending to client\n");
    	if(n == 0)
        	printf("Client closed the socket.\n");
	
    	return n;
}

void GetEnvironment() {

}

void Policy_ValidateSettings() {

}

// Update operating settings
// This function will interact with the hardware "drivers"
void UpdateRadioSettings() {

}

void LoadCEConfiguration(int socketfd,Utility * uList[], Parameter * pList[], Observable * oList[], CE_Info * ce_info){
	int n,i,j;
	char counter[55];
	char var[50];
	int total_bytes;   

	printf("Sending configuration to CE.\n");
 
 	// utilities
	// Send number of utilities
	sprintf(counter,"%d",ce_info->numUtilities);
	SendMessage(socketfd,counter);
	// send utility	
    for(i = 0; i < ce_info->numUtilities; i++) {
		SendMessage(socketfd,uList[i]->name);
		SendMessage(socketfd,uList[i]->units);
		SendMessage(socketfd,uList[i]->goal);
		sprintf(var,"%f",uList[i]->target);
		SendMessage(socketfd,var);
	}

	// parameters
    sprintf(counter,"%i",ce_info->numParameters);
	SendMessage(socketfd,counter);
	for(i = 0; i < ce_info->numParameters; i++) {
		SendMessage(socketfd,pList[i]->name);
		SendMessage(socketfd,pList[i]->units);
		sprintf(var,"%f",pList[i]->min);
		SendMessage(socketfd,var);
		sprintf(var,"%f",pList[i]->max);
		SendMessage(socketfd,var);
		sprintf(var,"%f",pList[i]->step);
		SendMessage(socketfd,var);
		
		sprintf(counter,"%i",pList[i]->numAffects); 
		SendMessage(socketfd,counter);
		for(j = 0; j < pList[i]->numAffects; j++) {
			SendMessage(socketfd,pList[i]->affection_list[j].u->name);
			SendMessage(socketfd,pList[i]->affection_list[j].relation);
		}
	}

    // observables
	sprintf(counter,"%i",ce_info->numObservables);
	SendMessage(socketfd,counter);
	for(i = 0; i < ce_info->numObservables; i++) {
		SendMessage(socketfd,oList[i]->name);
		
		sprintf(counter,"%i",oList[i]->numAffects); 
		SendMessage(socketfd,counter);
		for(j = 0; j < oList[i]->numAffects; j++) {
			SendMessage(socketfd,oList[i]->affection_list[j].u->name);
			SendMessage(socketfd,oList[i]->affection_list[j].relation);
		}
	}
	
	printf("Configuration sent, waiting for ACK...\n");
	// Receive ACK for utils
        string message;
	n = ReceiveMessage(socketfd, message);
        cout << message << endl;
	printf("ACK received.\n");

}

void UpdateCEConfiguration() {

}

void ResetCEConfiguration(){

}

void LoadCEExperience(){

}

void UpdateCEExperience() {

}

void ResetCEExperience() {

}

void RequestCEOptimization() {

}

int UpdateRadioSettings(int sockfd, Utility *uList[], 
        Parameter *pList[], Observable *oList[],
        CE_Info *ce_info)
{
    char buffer[256];
    string message;
    int i;
    float var;

    // utility
    // numUtilities
    bzero(buffer,256);
    message.erase();
    ReceiveMessage(sockfd,message);
    ce_info->numUtilities = atoi(message.c_str());
    printf("number of utilities: %d\n", ce_info->numUtilities);
    for (i = 0; i < ce_info->numUtilities; i++){
        bzero(buffer,256);
        message.erase();
        ReceiveMessage(sockfd,message);
        var = atof(message.c_str());
        uList[i]->value = var;
        printf("utility %s, value: %f\n", 
                uList[i]->name, uList[i]->value);
    }
    
    // paramter
    // numparameters
    /*bzero(buffer,256);*/
    message.erase();
    ReceiveMessage(sockfd,message);
    ce_info->numParameters = atoi(message.c_str());
    printf("number of parameters: %d\n", ce_info->numParameters);
    for (i = 0; i < ce_info->numParameters; i++){
        /*bzero(buffer,256);*/
        message.erase();
        ReceiveMessage(sockfd,message);
        var = atof(message.c_str());
        pList[i]->value = var;
        printf("parameter %s, value: %f\n", 
                pList[i]->name, pList[i]->value);
    }

    // observable
    // numObservables
    /*bzero(buffer,256);
    ReceiveMessage(sockfd,buffer);*/
    message.erase();
    ReceiveMessage(sockfd,message);
    ce_info->numObservables = atoi(message.c_str());
    printf("number of observables: %d\n", ce_info->numObservables);
    for (i = 0; i < ce_info->numObservables; i++){
        /*bzero(buffer,256);
        ReceiveMessage(sockfd,buffer);*/
        message.erase();
        ReceiveMessage(sockfd,message);
        var = atof(message.c_str());
        oList[i]->value = var;
        printf("observable %s, value: %f\n", 
                oList[i]->name, oList[i]->value);
    }
}

void RunSimulator(int socketfd, Utility * uList[], 
        Parameter * pList[], Observable * oList[], 
        CE_Info * ce_info) {

	// Set fake past environment -  
	LoadCEExperience();
	
	// Set fake current environment params = current environment
	RequestCEOptimization();

	// Act like we are updating the hardware tranmission settings
	UpdateRadioSettings(socketfd, uList, pList, oList, ce_info);

	// Send back fake utility values
	UpdateCEExperience();	
}

void StartMessaging(int socketfd, Utility * uList[], Parameter * pList[], Observable * oList[], CE_Info * ce_info) {

	LoadCEConfiguration(socketfd, uList, pList, oList, ce_info);

	RunSimulator(socketfd, uList, pList, oList, ce_info);
}

int StartShell(int port,Utility * uList[], Parameter * pList[], Observable * oList[], CE_Info * ce_info) {
   	// Start socket server
     	int sockfd, newsockfd, clilen;
     	struct sockaddr_in serv_addr, cli_addr;

     	// Setup server socket connection
        sockfd = socket(AF_INET, SOCK_STREAM, 0);
     	if (sockfd < 0) 
        	error("ERROR opening socket");
     	bzero((char *) &serv_addr, sizeof(serv_addr));
     	serv_addr.sin_family = AF_INET;
     	serv_addr.sin_port = htons(port);
     	serv_addr.sin_addr.s_addr = INADDR_ANY;
     	if (bind(sockfd, (struct sockaddr *) &serv_addr,
             	sizeof(serv_addr)) < 0) 
              	error("ERROR on binding");
     	listen(sockfd,5);
     	clilen = sizeof(cli_addr);

	//while(1) {
     		newsockfd = accept(sockfd, 
              		(struct sockaddr *) &cli_addr, 
              		(socklen_t*)&clilen);
     		if (newsockfd < 0) 
          		error("ERROR on accept");

		// Begin parsing the messages
		StartMessaging(newsockfd, uList, pList, oList, ce_info);
	//}
	return 0;
}

int main(int argc, char* argv[]) {


	// CognitiveEngine CE;
	// CognitiveEngineShell Shell;
	string pFilename; 
	int pid;

	Utility * uList[10];
	Parameter * pList[10];
	Observable * oList[10];
	CE_Info ce_info;

	if(argc < 2) { 
		cout << "Warning no XML file specific using default: example.xml" << endl;
		pFilename = "example.xml";
	} else {  
		pFilename = argv[1];
	}

	TiXmlDocument doc( pFilename.c_str() );
	bool loadOkay = doc.LoadFile();
	if (!loadOkay)
	{
		cout << "Loading " << pFilename << " failed." << endl;
		return 0;
	}

	cout << "Attemping to parse " << pFilename << "." << endl;
	parse_ce_config( &doc , uList, pList, oList, &ce_info);
	cout << "Configuration file parsing completed." << endl;

    //print_current_config(uList, pList, oList, &ce_info);
	
    pid = fork();
	if(pid == 0) {
		// In child process - open policy engine port.
	//	StartShell(30000,uList, pList, oList, &ce_info);
	} else {
		// In parent process - open cognitive engine port.
		StartShell(30002,uList, pList, oList, &ce_info);
	} 
	

   return 1;
}