#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();
}