#include <string>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <netdb.h>
#include <errno.h>
#include <syslog.h>
#include <pthread.h>
#include <math.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <sys/syscall.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <list>

#include "modelbahn.h"
#include "network.h"

Network::Network() {
	thread = 0;
	sessions.clear();
	thread_running = 0;
	pthread_mutex_init(&mtx, NULL);
	pthread_mutex_init(&mtxsessions, NULL);
}

Network::~Network() {
	list<Session*>::iterator iter;

	LockSessions();
	while ((iter = sessions.begin()) != sessions.end()) {
		Session *s = *iter;
		sessions.remove(*iter);
		delete s;
	}
	UnLockSessions();

	Stop();
};



void Network::ThreadProcess() {
	int i = 0;

	int timeout10s;
	int cycletime_max = 0;
	int cyclelooptime_max = 0;
	struct timeval tv_loop, tv;

	gettimeofday (&tv, NULL);
	gettimeofday (&tv_loop, NULL);
	timeout10s = tv.tv_sec + 10;

	while (running) {
		//
		// check network
		webserver.Loop();

		gettimeofday (&tv, NULL);
		i = (tv.tv_sec-tv_loop.tv_sec) * 1000 + (tv.tv_usec - tv_loop.tv_usec) / 1000;
		if (i > cycletime_max) cycletime_max = i;
		if (i < 100 && i > 0) usleep (100000 - i*1000);
		gettimeofday (&tv, NULL);
		i = (tv.tv_sec-tv_loop.tv_sec) * 1000 + (tv.tv_usec - tv_loop.tv_usec) / 1000;
		if (i > cyclelooptime_max) cyclelooptime_max = i;

		if (tv_loop.tv_sec > timeout10s) {
			timeout10s = tv.tv_sec + 10;
			debug ("max Cycletime: %dms   Cyclelooptime:%dms", cycletime_max, cyclelooptime_max);
			cycletime_max = 0;
			cyclelooptime_max = 0;
		}
		tv_loop = tv;
	}
	thread_running = 0;
};


int Network::Start() {
	int err;
	pthread_attr_t attr;
	mtx = { 0 };
	mtx = PTHREAD_MUTEX_INITIALIZER;

	//
	// start the webserver
	//
	webserver.SetupDocumentRoot("webinterface");
	webserver.SetupPorts(1080, 1081);
	webserver.Start();

	thread_running = 1;
	pthread_attr_init (&attr);
	pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_JOINABLE);
	err = pthread_create (&thread, &attr, ThreadEntry, this);
	if (err != 0) {
		debug ("pthread_create errror: %s", strerror (errno));
		running = 0;
		return 0;
	}
	return 1;
};


void Network::Stop() {
	webserver.Stop();
}


void Network::ChangeListPushToAll(string changes) {
	list<Session*>::iterator iter;

	LockSessions();
	for (iter = sessions.begin(); iter != sessions.end(); iter++) {
		if ((*iter)->GetSessionID() > 0) (*iter)->ChangeListPush(changes);
	}
	UnLockSessions();
};



Session *Network::GetSession(int sid) {
	Session *s = NULL;
	list<Session*>::iterator iter;

	LockSessions();
	for (iter = sessions.begin(); iter != sessions.end(); iter++) {
		if ((*iter)->GetSessionID() == sid) {
			s = *iter;
			break;
		}
	}
	UnLockSessions();

	return s;
};


int Network::ClientLoop(JSONParse *jpin, JSONParse *jpout) {
	int rid, sid;
	list<Session*>::iterator siter;
	Session *session = NULL;
	string value;
	string ssid;
	string srid;
	string s;
	int result = -1;
	struct timeval timer;

	timer_start(&timer);
	JSONParse jelement;

	if (jpin == NULL || jpout == NULL) return 0;
	jpout->Clear();

	if (!jpin->GetValue("sid", &ssid)) {
		debug ("jpin->GetValue error --> sid");
		return 0;
	}

	if (!jpin->GetValue("rid", &srid)) {
		debug ("jpin->GetValue error --> rid");
		return 0;
	}

	//
	try {
		rid = stoi (srid);
	}
	catch (...) {
		rid = 0;
		debug ("rid error");
	}

	try {
		sid = stoi (ssid);
	}
	catch (...) {
		sid = 0;
		debug ("sid error");
	}

	if (sid <= 0) {
		debug ("sid not set, gettin new SID");
		session = new Session(rid);
		sid = session->GetSessionID();
		LockSessions();
		sessions.push_back(session);
		UnLockSessions();
	}
	else {
		LockSessions();
		//
		// search for session
		session = NULL;
		for (siter = sessions.begin(); siter != sessions.end(); siter++) {
			if ((*siter)->GetRandomID() == rid && ((Session*)(*siter))->GetSessionID() == sid) {
				session = (*siter);
				break;
			}
		}
		UnLockSessions();
	}

	if (session) {
		JSONElement je;
		int retval;

		retval = session->ProcessData(jpin, jpout);

		if (retval) {
			je.Clear();
			je.Set("success", 1);
			jpout->AddObject(je);
			je.Clear();
			je.Set("serverstatus", server->GetStatus());
			jpout->AddObject(je);
			je.Clear();
			je.Set("simulation", simulation);
			jpout->AddObject(je);
		}
		else {
			je.Clear();
			je.Set("success", 0);
			jpout->AddObject(je);
			je.Clear();
			je.Set("serverstatus", "ERROR");
			jpout->AddObject(je);
		}
		result = 1;
	}
	else {
		// no session found
		result = 0;
	}

	return result;
};