#include "ttcpip.h"

#include "tconvert.h"

#ifdef _WIN32

#include <winsock2.h></winsock2.h>

#else

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

#include <signal.h></signal.h>

#include <stdio.h></stdio.h>

#include <unistd.h></unistd.h>

#include <sys types.h=""></sys>

#include <sys socket.h=""></sys>

#include <sys wait.h=""></sys>

#include <netinet in.h=""></netinet>

#include <netdb.h></netdb.h>

#endif

#include "tthreadmessage.h"

#include "tthread.h"

#ifndef _WIN32

#define SOCKET_ERROR -1

#endif

#include <string></string>

using namespace std;

#define MAXHOSTNAME 1024

int establish(unsigned short portnum, int &sock);

int get_connection(int s);

void fireman(int);

void do_something(int);

bool Sthutdown = false;

//#define TRACE

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

class TTcpIpServerImp {

public:

  TTcpIpServerImp(int port) : m_port(port), m_s(-1), m_server(0) {}

  int readData(int sock, QString &data);

  void onReceive(int sock, const QString &data);

  int m_s;  // socket id

  int m_port;

  TTcpIpServer *m_server;  // back pointer

  TThread::Mutex m_mutex;

};

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

int TTcpIpServerImp::readData(int sock, QString &data) {

  int cnt = 0;

  char buff[1025];

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

#ifdef _WIN32

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

    int err = WSAGetLastError();

    // GESTIRE L'ERRORE SPECIFICO

    return -1;

  }

#else

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

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

    perror("network server");

    close(sock);

    return -1;

  }

#endif

  if (cnt == 0) return 0;

#ifdef TRACE

  cout << buff << endl << endl;

#endif

  string aa(buff);

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

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

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

  string ssize;

  for (int i = x1; i < x2; ++i) ssize.push_back(buff[i]);

  int dataSize = std::stoi(ssize);

  unsigned long size = dataSize;

  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) - 1, 0)) < 0) {

      int err = WSAGetLastError();

      // GESTIRE L'ERRORE SPECIFICO

      return -1;

    }

#else

    if ((cnt = read(sock, buff, sizeof(buff) - 1)) < 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)) {

      buff[cnt] = '\0';

      data += QString(buff);

      // break;  // break out of loop

    } else {

      data += QString(buff);

    }

#ifdef TRACE

    cout << buff << endl << endl;

#endif

    size -= cnt;

  }

#ifdef TRACE

  cout << "read " << toString((int)data.length()) << " on " << dataSize << endl

       << endl;

#endif

  if (data.size() < dataSize) return -1;

#ifdef TRACE

  cout << data.toStdString() << endl;

#endif

  return 0;

}

#if 0

int TTcpIpServerImp::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 TTcpIpServerImp::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

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

void TTcpIpServerImp::onReceive(int sock, const QString &data) {

  QMutexLocker sl(&m_mutex);

  m_server->onReceive(sock, data);

}

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

TTcpIpServer::TTcpIpServer(int port) : m_imp(new TTcpIpServerImp(port)) {

  m_imp->m_server = this;

#ifdef _WIN32

  // Windows Socket startup

  WSADATA wsaData;

  WORD wVersionRequested = MAKEWORD(1, 1);

  int irc                = WSAStartup(wVersionRequested, &wsaData);

  if (irc != 0) throw("Windows Socket Startup failed");

#endif

}

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

TTcpIpServer::~TTcpIpServer() {

  if (m_imp->m_s != -1)

#ifdef _WIN32

    closesocket(m_imp->m_s);

  WSACleanup();

#else

    std::cout << "closing socket" << std::endl;

  close(m_imp->m_s);

#endif

}

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

int TTcpIpServer::getPort() const { return m_imp->m_port; }

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

static void shutdown_cb(int) { Sthutdown = true; }

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

class DataReader final : public TThread::Runnable {

public:

  DataReader(int clientSocket, std::shared_ptr<ttcpipserverimp> serverImp)</ttcpipserverimp>

      : m_clientSocket(clientSocket), m_serverImp(std::move(serverImp)) {}

  void run() override;

  int m_clientSocket;

  std::shared_ptr<ttcpipserverimp> m_serverImp;</ttcpipserverimp>

};

void DataReader::run() {

  QString data;

  int ret = m_serverImp->readData(m_clientSocket, data);

  if (ret != -1) {

    if (data == QString("shutdown"))

      Sthutdown = true;

    else

      m_serverImp->onReceive(m_clientSocket, data);

#ifdef _WIN32

    closesocket(m_clientSocket);

#else

    close(m_clientSocket);

#endif

  }

}

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

class DataReceiver final : public TThread::Runnable {

public:

  DataReceiver(int clientSocket, const QString &data,

               std::shared_ptr<ttcpipserverimp> serverImp)</ttcpipserverimp>

      : m_clientSocket(clientSocket)

      , m_data(data)

      , m_serverImp(std::move(serverImp)) {}

  void run() override;

  int m_clientSocket;

  QString m_data;

  std::shared_ptr<ttcpipserverimp> m_serverImp;</ttcpipserverimp>

};

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

void DataReceiver::run() {

  m_serverImp->onReceive(m_clientSocket, m_data);

#ifdef _WIN32

  closesocket(m_clientSocket);

#else

  close(m_clientSocket);

#endif

}

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

void TTcpIpServer::run() {

  try {

#ifdef _WIN32

    int err = establish(m_imp->m_port, m_imp->m_s);

    if (!err && m_imp->m_s != -1) {

      int t;  // client socket

      while (!Sthutdown) /* loop for connections */

      {

        if ((t = get_connection(m_imp->m_s)) < 0) /* get a connection */

        {

          m_exitCode = WSAGetLastError();

          // GESTIRE LA CONDIZIONE DI ERRORE

          return;

        }

        QString data;

        int ret = m_imp->readData(t, data);

        if (ret != -1 && data != "") {

          if (data == QString("shutdown")) {

            // DebugBreak();

            Sthutdown = true;

          } else {

            // creo un nuovo thread per la gestione dei dati ricevuti

            TThread::Executor executor;

            executor.addTask(new DataReceiver(t, data, m_imp));

          }

        } else {

          ::shutdown(t, 1);

        }

      }

    } else {

      m_exitCode = err;

      return;

    }

#else  // !_WIN32

    int err = establish(m_imp->m_port, m_imp->m_s);

    if (!err && m_imp->m_s != -1) {

//      signal(SIGCHLD, fireman);           /* this eliminates zombies */

#ifdef MACOSX

      struct sigaction sact;

      sact.sa_handler = shutdown_cb;

      sigaction(SIGUSR1, &sact, 0);

#else

      sigset(SIGUSR1, shutdown_cb);

#endif

      int t;

      while (!Sthutdown) /* loop for connections */

      {

        if ((t = get_connection(m_imp->m_s)) < 0) /* get a connection */

        {

          if (errno == EINTR) /* EINTR might happen on accept(), */

            continue;         /* try again */

          perror("accept");   /* bad */

          m_exitCode = errno;

          return;

        }

        TThread::Executor executor;

        executor.addTask(new DataReader(t, m_imp));

      }

    } else {

      m_exitCode = err;

      return;

    }

#endif  // _WIN32

  } catch (...) {

    m_exitCode = 2000;

    return;

  }

  m_exitCode = 0;

}

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

int TTcpIpServer::getExitCode() const { return m_exitCode; }

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

void TTcpIpServer::sendReply(int socket, const QString &reply) {

  string replyUtf8 = reply.toStdString();

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

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

  header += QString("#$#THE");

  string packet = header.toStdString() + replyUtf8;

  //  string packet = reply;;

  int nLeft = packet.size();

  int idx   = 0;

  while (nLeft > 0) {

#ifdef _WIN32

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

#else

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

#endif

    if (ret == SOCKET_ERROR) {

      // Error

    }

    nLeft -= ret;

    idx += ret;

  }

  ::shutdown(socket, 1);

}

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

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

int establish(unsigned short portnum, int &sock) {

  char myname[MAXHOSTNAME + 1];

  struct sockaddr_in sa;

  struct hostent *hp;

  memset(&sa, 0, sizeof(struct sockaddr_in)); /* clear our address */

  gethostname(myname, MAXHOSTNAME);           /* who are we? */

  hp = gethostbyname(myname);                 /* get our address info */

  if (hp == NULL)                             /* we don't exist !? */

    return (-1);

  sa.sin_family = hp->h_addrtype; /* this is our host address */

  sa.sin_port   = htons(portnum); /* this is our port number */

  if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) /* create socket */

  {

#ifdef _WIN32

    int err = WSAGetLastError();

    return err;

#else

    return errno;

#endif

  }

  if (::bind(sock, (struct sockaddr *)&sa, sizeof(struct sockaddr_in)) < 0) {

#ifdef _WIN32

    int err = WSAGetLastError();

    closesocket(sock);

    return err;

#else

    return errno;

    close(sock);

#endif

  }

  return listen(sock, 3); /* max # of queued connects */

}

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

/* wait for a connection to occur on a socket created with establish() */

int get_connection(int s) {

  int t; /* socket of connection */

  if ((t = accept(s, NULL, NULL)) < 0) /* accept connection if there is one */

    return (-1);

  return (t);

}

#ifndef _WIN32

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

/* as children die we should get catch their returns or else we get

 * zombies, A Bad Thing.  fireman() catches falling children.

 */

void fireman(int) {

  while (waitpid(-1, NULL, WNOHANG) > 0)

    ;

}

#endif