/* client.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
//#include <inttypes.h>

#ifdef _WIN32
/* Headerfiles für Windows */
#include <winsock.h>
#include <io.h>
#include <conio.h>
//#include <signal.h>
#else
/* Headerfiles für UNIX/Linux */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <unistd.h>

#include <termios.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#endif

#ifdef _WIN32

#else
typedef int SOCKET;
void Sleep(long);
int getch(void);
int kbhit(void);
void pos(int, char*);
#endif

SOCKET connect_server(char *ip_addr, unsigned int port);
void communication_server(void);
void disconnect_server(SOCKET sock);


int main( int argc, char *argv[]) 
{
	communication_server();
	//printf("Status: %i\r\n\r\n", flash("ATmega4809_Uart_Treiber.hex"));
	
	return 0;	
}

void communication_server(void)
{
	//Adressen
	char ip_addr[] = "10.9.21.216";
	//char ip_addr[] = "localhost";
	//char ip_addr[] = "192.168.137.123";
	unsigned int port = 1234;
	
	SOCKET sock = connect_server(ip_addr, port);
	char rec;
	int connection_status = 0;
	unsigned int connection_try = 0;
	long int menue = 0;
	
	printf("[SYSTEM]: Kommunikationsmodul >client<\r\n[!] Menue\r\n[#] Verlassen\r\n\r\n");
	
	while(1)
	{
		Sleep(1);
		//if(connection_try++ > 2000) { connection_try = 0; rec = '&'; if(send(sock, &rec, 1, 0) < 0) {connection_status = 1; }}
		if(recv(sock, &rec, 1, 0) > 0) printf("%c", rec);
		
		if(kbhit())
		{
			rec = getch();
			if(rec == '#') { disconnect_server(sock); return; }
			if(rec == '!') 
			{ 
				printf("[SYSTEM]: Menue\r\n[f] flash\r\n[#] Verlassen\r\n");
				rec = getch();
				switch(rec)
				{
					case 'f': break;
					default: printf("[SYSTEM]: Menue Verlassen\r\n"); break;
				}
			}
			if(send(sock, &rec, 1, 0) < 0) {connection_status = 1; }
		}
		if(connection_status) //Erneuter Verbindungsaufbau
		{
			printf("[SYSTEM]: Verbindung Verloren, Wiederherstellung\r\n");
			disconnect_server(sock);
			sock = connect_server(ip_addr, port);
			connection_status = 0;
		}
	}
	
}

void disconnect_server(SOCKET sock)
{
	#ifdef _WIN32
	closesocket(sock);
	//Cleanup Winsock
	WSACleanup();
	#else
	close(sock);
	#endif
}

SOCKET connect_server(char *ip_addr, unsigned int port)
{
	struct sockaddr_in server;
	struct hostent *host_info;
	unsigned long addr = 0;
	unsigned long blocking_mode = 0;
	unsigned long connection_trys = 0;
	const int y = 1;

	SOCKET sock;

	#ifdef _WIN32
	// Initialisiere TCP für Windows ("winsock")
	WORD wVersionRequested;
	WSADATA wsaData;
	wVersionRequested = MAKEWORD (1, 1);
	if (WSAStartup (wVersionRequested, &wsaData) != 0) { printf("[SYSTEM]: Error Winsock\r\n"); return 0; }
	#else
	//sock = socket( AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0 );
	#endif

	sock = socket( AF_INET, SOCK_STREAM, 0 );
	
	#ifdef _WIN32
	#else
	 setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &y, sizeof(int));
	 #endif
	

	if (sock < 0) { printf("[SYSTEM]: Error Socket\r\n"); return 0; }

	//Erzeuge die Socketadresse des Servers. Sie besteht aus Typ, IP-Adresse und Portnummer.
	memset( &server, 0, sizeof (server));
	//ip_addr ist eine numerische IP-Adresse.
	if ((addr = inet_addr(ip_addr)) != INADDR_NONE) memcpy( (char *)&server.sin_addr, &addr, sizeof(addr));
	else
	{
		// Für den Fall der Fälle: Wandle den Servernamen bspw. "localhost" in eine IP-Adresse um.
		host_info = gethostbyname(ip_addr);
		if (NULL == host_info) { printf("[SYSTEM]: Unbekannter Server\r\n"); return 0; }
		// Server-IP-Adresse
		memcpy( (char *)&server.sin_addr, host_info->h_addr, host_info->h_length );
	}
	// IPv4-Verbindung
	server.sin_family = AF_INET;
	// Portnummer
	server.sin_port = htons( port );

	//Baue die Verbindung zum Server auf.
	#ifdef _WIN32
	while(1)
	{
		if(kbhit()) if(getch() == '#') return 0;
		if(connect(sock,(struct sockaddr*)&server,sizeof(server)) <0)
		{
			printf("[SYSTEM]: Verbinden... #%lu\r", connection_trys);
			connection_trys++;
		}
		else { printf("\r\n[SYSTEM]: Verbunden.\r\n"); connection_trys = 0; break; }
	}
	#else
		printf("[SYSTEM]: Verbinden... #%lu\r", connection_trys);
		while(1)
		{
			if(kbhit()) if(getch() == '#') return 0;
			if((connect(sock,(struct sockaddr*)&server,sizeof(server)) <0))
			{
				printf("[SYSTEM]: Verbinden... #%lu\r", connection_trys);
				connection_trys++;
			}
			else { printf("\r\n[SYSTEM]: Verbunden.\r\n"); connection_trys = 0; break; }
		}
	#endif
	
	//Non-blocking Modus fuer Eingehende Verbindungen (recv)
	blocking_mode = 1; //1=enable(nonblock active) 0=disable
	#ifdef _WIN32
	ioctlsocket(sock, FIONBIO, &blocking_mode);
	#else
	//ioctl(sock, O_NONBLOCK, &blocking_mode);
	fcntl(sock, F_SETFL, fcntl(sock, F_GETFL, 0) | O_NONBLOCK);
	#endif
	return sock;
}

#ifdef _WIN32

#else
/* msleep(): Sleep for the requested number of milliseconds. */
void Sleep(long msec)
{
	struct timespec ts;
	int res;

	if (msec < 0)
	{
		errno = EINVAL;
		return;
	}

	ts.tv_sec = msec / 1000;
	ts.tv_nsec = (msec % 1000) * 1000000;

	do {
		res = nanosleep(&ts, &ts);
	} while (res && errno == EINTR);

	return;
}

int kbhit(void)
{
	struct termios oldt, newt;
	int ch;
	int oldf;
	
	tcgetattr(STDIN_FILENO, &oldt);
	newt = oldt;
	newt.c_lflag &= ~(ICANON|ECHO);
	tcsetattr(STDIN_FILENO, TCSANOW, &newt);
	oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
	fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
	
	ch = getchar();
	
	tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
	fcntl(STDIN_FILENO, F_SETFL, oldf);
	
	if(ch != EOF)
	{
		ungetc(ch, stdin);
		return 1;
	}
	
	return 0;
}

int getch()
{
	static int ch = -1, fd = 0;
	struct termios neu, alt;
	fd = fileno(stdin);
	tcgetattr(fd, &alt);
	neu = alt;
	neu.c_lflag &= ~(ICANON|ECHO);
	tcsetattr(fd, TCSANOW, &neu);
	ch = getchar();
	tcsetattr(fd, TCSANOW, &alt);
	return ch;
}
#endif