#include "tbaseserver.h"
 
#ifndef WIN32
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <unistd.h>
#endif
 
//#include "tcommon.h"
 
#include <string>
#include <vector>
using namespace std;
 
//-----------------------------------------------------------------------------
 
TBaseServer::TBaseServer(int port)
    : m_port(port), m_socketId(-1), m_stopped(false) {}
 
//-----------------------------------------------------------------------------
 
TBaseServer::~TBaseServer() {
  if (m_socketId != -1) stop();
}
 
//-----------------------------------------------------------------------------
 
void TBaseServer::start() {
#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");
#else
  int c;
  FILE *fp;
  register int ns;
#endif
 
  if ((m_socketId = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
#ifdef WIN32
    char szError[1024];
    wsprintf(szError, TEXT("Allocating socket failed. Error: %d"),
             WSAGetLastError());
    throw(szError);
#else
    throw("Allocating socket failed.");
#endif
  }
 
  struct sockaddr_in myname;
  myname.sin_family      = AF_INET;
  myname.sin_port        = htons(m_port);
  myname.sin_addr.s_addr = INADDR_ANY;
 
  if (bind(m_socketId, (sockaddr *)&myname, sizeof myname) < 0) {
    throw("Unable to bind to connection");
  }
 
#ifdef TRACE
  cout << "Listening ..." << endl;
#endif
 
  // length of the queue of pending connections
  int maxPendingConnections = 5;
 
  if (listen(m_socketId, maxPendingConnections) < 0) {
    throw("Unable to start listening");
  }
 
  while (true) {
    register int clientSocket;
    if ((clientSocket = accept(m_socketId, 0, 0)) < 0) {
      if (m_stopped)
        return;
      else
        throw("Error accepting from client");
    }
 
    printf("ho accettato\n");
 
    char msgFromClient[1024];
    memset(msgFromClient, 0, sizeof(msgFromClient));
 
#ifdef WIN32
 
    // Receive data from the client.
    int iReturn = recv(clientSocket, msgFromClient, sizeof(msgFromClient), 0);
 
    // Verify that data was received. If yes, use it.
    if (iReturn == SOCKET_ERROR) {
      char szError[1024];
      wsprintf(szError,
               TEXT("No data is received, receive failed.") TEXT(" Error: %d"),
               WSAGetLastError());
 
      throw(szError);
    }
 
#else
    fp = fdopen(clientSocket, "r");
 
    printf("Partito!\n");
 
    int i = 0;
    while ((int)(c = fgetc(fp)) != EOF) {
      putchar(c);
      msgFromClient[i] = c;
    }
#endif
 
    printf("msg finito\n");
 
    char *argv[128];
    int argc = extractArgs(msgFromClient, argv);
 
    string reply = exec(argc, argv);
    reply += "\n";
 
    for (int i = 0; i < argc; ++i) delete[] argv[i];
 
    // Send the reply string from the server to the client.
    if (send(clientSocket, reply.c_str(), reply.length() + 1, 0) < 0) {
      char szError[1024];
 
#ifdef WIN32
      wsprintf(szError, TEXT("Sending data to the client failed. Error: %d"),
               WSAGetLastError());
#endif
 
      throw(szError);
    }
 
#ifndef WIN32
    close(clientSocket);
#endif
  }
}
 
//-----------------------------------------------------------------------------
 
void TBaseServer::stop() {
  //  TThread::ScopedLock sl(m_mutex);
 
  if (!m_stopped) {
    m_stopped = true;
 
#ifdef WIN32
    if (closesocket(m_socketId) != 0) {
      char szError[1024];
      wsprintf(szError, TEXT(" Error: %d"), WSAGetLastError());
 
      throw(szError);
    }
#else
    close(m_socketId);
#endif
 
    m_socketId = -1;
  }
}
 
//-----------------------------------------------------------------------------
 
int TBaseServer::extractArgs(char *s, char *argv[]) {
  string ss(s);
 
  string::size_type pos1 = 0;
  string::size_type pos2 = ss.find(",");
 
  vector<string> args;
  while (pos2 != string::npos) {
    string arg = ss.substr(pos1, pos2 - pos1);
    args.push_back(arg);
 
    pos1 = pos2 + 1;
    pos2 = ss.find(",", pos1);
  }
 
  string arg = ss.substr(pos1, ss.length() - pos1);
  args.push_back(arg);
 
  vector<string>::iterator it = args.begin();
  for (int i = 0; it != args.end(); ++it, ++i) {
    string arg = *it;
    argv[i]    = new char[arg.size() + 1];
    strcpy(argv[i], arg.c_str());
  }
 
  return args.size();
}