#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
 
#include "tthreadmessage.h"
#include "tthread.h"
#ifndef _WIN32
#define SOCKET_ERROR -1
#endif
 
#include <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)
      : m_clientSocket(clientSocket), m_serverImp(std::move(serverImp)) {}
 
  void run() override;
 
  int m_clientSocket;
  std::shared_ptr<TTcpIpServerImp> m_serverImp;
};
 
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)
      : 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;
};
 
//---------------------------------------------------------------------
 
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