#include "ttcpip.h"

#include "tconvert.h"

#ifdef _WIN32

#include <Winsock2.h>

#else

#include <errno.h> /* obligatory includes */

#include <signal.h>

#include <stdio.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/wait.h>

#include <netinet/in.h>

#include <netdb.h>

#endif

#ifndef _WIN32

#define SOCKET_ERROR -1

#endif

//------------------------------------------------------------------------------

TTcpIpClient::TTcpIpClient()

{

#ifdef _WIN32

	WSADATA wsaData;

	WORD wVersionRequested = MAKEWORD(1, 1);

	int irc = WSAStartup(wVersionRequested, &wsaData);

#endif

}

//------------------------------------------------------------------------------

TTcpIpClient::~TTcpIpClient()

{

#ifdef _WIN32

	WSACleanup();

#endif

}

//------------------------------------------------------------------------------

int TTcpIpClient::connect(const QString &hostName, const QString &addrStr, int port, int &sock)

{

/*

  if (!addrStr.empty())

  {

    unsigned long ipAddr = inet_addr(addrStr.c_str());

  }

*/

#if QT_VERSION >= 0x050500

	struct hostent *he = gethostbyname(hostName.toUtf8());

#else

	struct hostent *he = gethostbyname(hostName.toAscii());

#endif

	if (!he) {

#ifdef _WIN32

		int err = WSAGetLastError();

#else

#endif

		return HOST_UNKNOWN;

	}

	int socket_id = socket(AF_INET, SOCK_STREAM, 0);

	struct sockaddr_in addr;

	memset((char *)&addr, 0, sizeof addr);

	addr.sin_family = he->h_addrtype;

	addr.sin_port = htons(port);

	memcpy((char *)&(addr.sin_addr), he->h_addr, he->h_length);

	int rcConnect = ::connect(socket_id, (struct sockaddr *)&(addr), sizeof addr);

	if (rcConnect == SOCKET_ERROR) {

		sock = -1;

#ifdef _WIN32

		int err = WSAGetLastError();

		switch (err) {

		case WSAECONNREFUSED:

			err = CONNECTION_REFUSED;

			break;

		case WSAETIMEDOUT:

			err = CONNECTION_TIMEDOUT;

			break;

		default:

			err = CONNECTION_FAILED;

			break;

		}

		closesocket(socket_id);

		return err;

#else

		close(socket_id);

		return CONNECTION_FAILED;

#endif

	}

	sock = socket_id;

	return OK;

}

/*

int TTcpIpClient::connect(const std::string &hostName, const std::string &addrStr, int port, int &sock)

{

  struct hostent *he = gethostbyname (hostName.c_str());

  if (!he)

  {

#ifdef _WIN32

    int err = WSAGetLastError();

#else

#endif

    return HOST_UNKNOWN;

  }

  int socket_id = socket (AF_INET, SOCK_STREAM,0);

  struct sockaddr_in addr;

  memset((char*)&addr, 0, sizeof addr);

  addr.sin_family = he->h_addrtype;

  addr.sin_port = htons(port);

  memcpy((char *)&(addr.sin_addr), he->h_addr, he->h_length);

  int rcConnect = ::connect (socket_id, (struct sockaddr *)&(addr), sizeof addr);

  if (rcConnect == SOCKET_ERROR)

  {

    sock = -1;

#ifdef _WIN32

    int err = WSAGetLastError();

    switch (err)

    {

     case WSAECONNREFUSED:

        return CONNECTION_REFUSED;

     case WSAETIMEDOUT:

        return CONNECTION_TIMEDOUT;

     default:

        return CONNECTION_FAILED;

    }

#else

    return CONNECTION_FAILED;

#endif

  }

  sock = socket_id;

  return OK;

}

*/

//------------------------------------------------------------------------------

int TTcpIpClient::disconnect(int sock)

{

#ifdef _WIN32

	closesocket(sock);

#else

	close(sock);

#endif

	return OK;

}

//------------------------------------------------------------------------------

int TTcpIpClient::send(int sock, const QString &data)

{

	std::string dataUtf8 = data.toStdString();

	QString header("#$#THS01.00");

	header += QString::number((int)dataUtf8.size());

	header += "#$#THE";

	std::string packet = header.toStdString() + dataUtf8;

	//  string packet = data;;

	int nLeft = packet.size();

	int idx = 0;

	while (nLeft > 0) {

#ifdef _WIN32

		int ret = ::send(sock, packet.c_str() + idx, nLeft, 0);

#else

		int ret = write(sock, packet.c_str() + idx, nLeft);

#endif

		if (ret == SOCKET_ERROR) {

// Error

#ifdef _WIN32

			int err = WSAGetLastError();

#else

#endif

			return SEND_FAILED;

		}

		nLeft -= ret;

		idx += ret;

	}

	shutdown(sock, 1);

	return OK;

}

//------------------------------------------------------------------------------

int readData(int sock, QString &data)

{

	int cnt = 0;

	char buff[1024];

	memset(buff, 0, sizeof(buff));

#ifdef _WIN32

	if ((cnt = recv(sock, buff, sizeof(buff), 0)) < 0) {

		int err = WSAGetLastError();

		// GESTIRE L'ERRORE SPECIFICO

		return -1;

	}

#else

	if ((cnt = read(sock, buff, sizeof(buff))) < 0) {

		printf("socket read failure %d\n", errno);

		perror("network server");

		close(sock);

		return -1;

	}

#endif

	if (cnt == 0)

		return 0;

	std::string aa(buff);

	int x1 = aa.find("#$#THS01.00");

	x1 += sizeof("#$#THS01.00") - 1;

	int x2 = aa.find("#$#THE");

	std::string ssize;

	for (int i = x1; i < x2; ++i)

		ssize.push_back(buff[i]);

	int size = toInt(ssize);

	data = QString(buff + x2 + sizeof("#$#THE") - 1);

	size -= data.size();

	while (size > 0) {

		memset(buff, 0, sizeof(buff));

#ifdef _WIN32

		if ((cnt = recv(sock, buff, sizeof(buff), 0)) < 0) {

			int err = WSAGetLastError();

			// GESTIRE L'ERRORE SPECIFICO

			return -1;

		}

#else

		if ((cnt = read(sock, buff, sizeof(buff))) < 0) {

			printf("socket read failure %d\n", errno);

			perror("network server");

			close(sock);

			return -1;

		}

#endif

		else if (cnt == 0) {

			break; // break out of loop

		} else if (cnt < (int)sizeof(buff)) {

			data += QString(buff);

			//break;  // break out of loop

		} else {

			data += QString(buff);

		}

		size -= cnt;

	}

	if (data.size() < size)

		return -1;

	return 0;

}

#if 0

int readData(int sock, string &data)

{

  int cnt = 0;

  char buff[1024];

  do

  {

    memset (buff,0,sizeof(buff));

#ifdef _WIN32

    if (( cnt = recv(sock, buff, sizeof(buff), 0)) < 0 )

    {

      int err = WSAGetLastError();

      // GESTIRE L'ERRORE SPECIFICO

      return -1;

    }

#else

    if (( cnt = read (sock, buff, sizeof(buff))) < 0 )

    {

      printf("socket read failure %d\n", errno);

      perror("network server");

      close(sock);

      return -1;

    }

#endif

    else

    if (cnt == 0)

      break;  // break out of loop

    data += string(buff);

  }

  while (cnt != 0);  // do loop condition

  return 0;

}

#endif

//#define PRIMA

#ifdef PRIMA

int readData(int sock, string &data)

{

	int cnt = 0;

	char buff[1024];

	do {

		memset(buff, 0, sizeof(buff));

#ifdef _WIN32

		if ((cnt = recv(sock, buff, sizeof(buff), 0)) < 0) {

			int err = WSAGetLastError();

			// GESTIRE L'ERRORE SPECIFICO

			return -1;

		}

#else

		if ((cnt = read(sock, buff, sizeof(buff))) < 0) {

			printf("socket read failure %d\n", errno);

			perror("network server");

			close(sock);

			return -1;

		}

#endif

		else if (cnt == 0) {

			break; // break out of loop

		} else if (cnt < sizeof(buff)) {

			data += string(buff);

			//break;  // break out of loop

		} else {

			data += string(buff);

		}

	} while (cnt != 0); // do loop condition

	return 0;

}

#endif

//------------------------------------------------------------------------------

int TTcpIpClient::send(int sock, const QString &data, QString &reply)

{

	if (data.size() > 0) {

		int ret = send(sock, data);

		if (ret == 0)

			ret = readData(sock, reply);

		return ret;

	}

	return OK;

}

/*

int TTcpIpClient::send(int sock, const std::string &data, string &reply)

{

  int ret = send(sock, data);

  if (ret == 0)

    ret = readData(sock, reply);

  return ret;

}

*/