#include "tfarmserver.h"

#include "tfarmexecutor.h"

#include "tfarmcontroller.h"

#include "tthreadmessage.h"

#include "tthread.h"

#include "tsystem.h"

#include "tsmartpointer.h"

#include "service.h"

#include "tlog.h"

#include "tfilepath_io.h"

#include "tcli.h"

#include <string></string>

#include <map></map>

#include <sstream></sstream>

#include <qstring></qstring>

#include <qprocess></qprocess>

#include <qcoreapplication></qcoreapplication>

#include <qeventloop></qeventloop>

#include "tthread.h"

#ifdef _WIN32

#include <iostream></iostream>

#else

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

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

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

#endif

//#define REDIRECT_OUPUT

#ifdef _WIN32

#define QUOTE_STR "\""

#define CASMPMETER "casmpmeter.exe"

#else

#define QUOTE_STR "'"

#define CASMPMETER "casmpmeter"

#endif

#ifndef _WIN32

#define NO_ERROR 0

#endif

#ifdef MACOSX

#include <sys sysctl.h="">  //To retrieve MAC HW infos</sys>

#endif

#ifdef LINUX

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

#endif

// forward declaration

class FarmServer;

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

namespace {

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

TFilePath getGlobalRoot() {

  TFilePath rootDir;

#ifdef _WIN32

  TFilePath name(L"SOFTWARE\\OpenToonz\\OpenToonz\\1.0\\FARMROOT");

  rootDir = TFilePath(TSystem::getSystemValue(name).toStdString());

#else

  // Leggo la localRoot da File txt

  Tifstream is(

      TFilePath("./OpenToonz_1.0.app/Contents/Resources/configfarmroot.txt"));

  if (is) {

    char line[1024];

    is.getline(line, 80);

    char *s = line;

    while (*s == ' ' || *s == '\t' || *s == '\n' || *s == '\"') s++;

    if (*s != '\0') {

      char *t = s;

      while (*t) t++;

      std::string pathName(s, t - 1);

      rootDir = TFilePath(pathName);

    }

  }

#endif

  return rootDir;

}

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

TFilePath getLocalRoot() {

  TFilePath lroot;

#ifdef _WIN32

  TFilePath name("SOFTWARE\\OpenToonz\\OpenToonz\\1.0\\TOONZROOT");

  lroot = TFilePath(TSystem::getSystemValue(name).toStdString()) +

          TFilePath("toonzfarm");

#else

  Tifstream is(

      TFilePath("./OpenToonz_1.0.app/Contents/Resources/configfarmroot.txt"));

  if (is) {

    char line[1024];

    is.getline(line, 80);

    char *s = line;

    while (*s == ' ' || *s == '\t' || *s == '\n' || *s == '\"') s++;

    if (*s != '\0') {

      char *t = s;

      while (*t) t++;

      std::string pathName(s, t - 1);

      lroot = TFilePath(pathName);

    }

  }

#endif

  return lroot;

}

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

TFilePath getBinRoot() {

#ifdef _WIN32

  return TSystem::getBinDir();

#else

  return getLocalRoot() + "bin";

#endif

}

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

bool dirExists(const TFilePath &dirFp) {

  bool exists = false;

#ifdef _WIN32

  TFileStatus fs(dirFp);

  exists = fs.isDirectory();

#else

  int acc = access(::to_string(dirFp).c_str(), 00);  // 00 == solo esistenza

  exists  = acc != -1;

#endif

  return exists;

}

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

bool myDoesExists(const TFilePath &fp) {

  bool exists = false;

#ifdef _WIN32

  TFileStatus fs(fp);

  exists = fs.doesExist();

#else

  int acc = access(::to_string(fp).c_str(), 00);  // 00 == solo esistenza

  exists  = acc != -1;

#endif

  return exists;

}

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

inline bool isBlank(char c) { return c == ' ' || c == '\t' || c == '\n'; }

}  // anonymous namespace

//==============================================================================

//==============================================================================

class FarmServerService final : public TService {

public:

  FarmServerService(std::ostream &os)

      : TService("ToonzFarm Server", "ToonzFarm Server")

      , m_os(os)

      , m_userLog(0) {}

  ~FarmServerService() { delete m_userLog; }

  void onStart(int argc, char *argv[]) override;

  void onStop() override;

  void loadControllerData(QString &hostName, string &ipAddr, int &port);

#ifdef _WIN32

  void loadDiskMountingPoints(const TFilePath &fp);

  void mountDisks();

  void unmountDisks();

  std::map<std::string, std::string=""> m_disks;</std::string,>

  vector<std::string> m_disksMounted;</std::string>

#endif

  int m_port;

  QString m_addr;

  FarmServer *m_farmServer;

  std::ostream &m_os;

  TUserLog *m_userLog;

};

FarmServerService service(std::cout);

//==============================================================================

//==============================================================================

class FarmControllerProxy final : public TSmartObject {

  TFarmController *m_controller;

public:

  FarmControllerProxy(TFarmController *controller) : m_controller(controller) {}

  ~FarmControllerProxy() { delete m_controller; }

  TFarmController *getController() const { return m_controller; }

private:

  // not implemented

  FarmControllerProxy(const FarmControllerProxy &);

  FarmControllerProxy &operator=(const FarmControllerProxy &);

};

// non posso usare lo smartpointer di tnzcore perche' non linka su .NET

class FarmControllerProxyP {

  FarmControllerProxy *m_proxy;

public:

  FarmControllerProxyP() : m_proxy(0) {}

  ~FarmControllerProxyP() {

    if (m_proxy) m_proxy->release();

  }

  FarmControllerProxyP(const FarmControllerProxyP &src) : m_proxy(src.m_proxy) {

    if (m_proxy) m_proxy->addRef();

  }

  FarmControllerProxyP &operator=(const FarmControllerProxyP &src) {

    FarmControllerProxyP tmp(*this);

    tswap(tmp.m_proxy, m_proxy);

    return *this;

  }

  FarmControllerProxyP &operator=(TFarmController *controller) {

    if (m_proxy && m_proxy->getController() == controller) return *this;

    if (m_proxy) m_proxy->release();

    m_proxy = new FarmControllerProxy(controller);

    m_proxy->addRef();

    return *this;

  }

  TFarmController *operator->() { return getPointer(); }

  TFarmController *getPointer() const {

    return m_proxy ? m_proxy->getController() : 0;

  }

};

//==============================================================================

//==============================================================================

class FarmServer final : public TFarmExecutor, public TFarmServer {

public:

  FarmServer(int port, TUserLog *log);

  ~FarmServer();

  void setController(const ControllerData &data) {

    m_controllerData            = data;

    TFarmController *controller = 0;

    TFarmControllerFactory factory;

    factory.create(data, &controller);

    m_controller = controller;

  }

  TFarmController *getController() const { return m_controller.getPointer(); }

  void setAppPaths(const vector<tfilepath> &);</tfilepath>

  QString execute(const vector<qstring> &argv) override;</qstring>

  // TFarmServer overrides

  int addTask(const QString &taskid, const QString &cmdline) override;

  int terminateTask(const QString &taskid) override;

  int getTasks(vector<qstring> &tasks) override;</qstring>

  void queryHwInfo(HwInfo &hwInfo) override;

  void attachController(const ControllerData &data);

  void attachController(const QString &name, const QString &addr,

                        int port) override {

    attachController(ControllerData(name, addr, port));

  }

  void detachController(const ControllerData &data);

  void detachController(const QString &name, const QString &addr,

                        int port) override {

    detachController(ControllerData(name, addr, port));

  }

  // class specific methods

  void removeTask(const QString &id);

private:

  TThread::Executor *m_executor;

  ControllerData m_controllerData;

  FarmControllerProxyP m_controller;

  TThread::Mutex m_mux;

  vector<qstring> m_tasks;</qstring>

  TUserLog *m_userLog;

public:

  // vector<tfilepath> m_appPaths;</tfilepath>

private:

  // not implemented

  FarmServer(const FarmServer &);

  FarmServer &operator=(const FarmServer &);

};

//===================================================================

//===================================================================

//

// class Task

//

//===================================================================

//===================================================================

class Task final : public TThread::Runnable {

public:

  Task(const QString &id, const QString &cmdline, TUserLog *log,

       FarmServer *server, const FarmControllerProxyP &controller)

      : m_id(id)

      , m_cmdline(cmdline)

      , m_log(log)

      , m_server(server)

      , m_controller(controller) {}

  void run() override;

private:

  QString m_id;

  QString m_cmdline;

  TUserLog *m_log;

  FarmServer *m_server;

  FarmControllerProxyP m_controller;

private:

  // not implemented

  Task(const Task &);

  Task &operator=(const Task &);

};

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

void Task::run() {

  QString logMsg("Starting task at ");

  logMsg += QDateTime::currentDateTime().toString();

  logMsg += "\n";

  logMsg += "\"" + m_cmdline + "\"";

  logMsg += "\n\n";

  m_log->info(logMsg);

// ===========

#ifdef _WIN32

  if (m_cmdline.contains("runcasm")) service.mountDisks();

#endif

  QString cmdline;

  if (m_cmdline.contains(".bat"))

    cmdline = "cmd /C " + m_cmdline;

  else

    cmdline = m_cmdline;

#ifdef LEVO

  else {

    // metto da parte il primo token della command line che e' il nome

    // dell'eseguibile

    // Attenzione: case sensitive!

    QStringList l = m_cmdline.split(" ");

    // assert(!"CONTROLLARE QUI");

    QString appName = l.at(1);

    int i;

    for (i = 2; i < l.size(); i++) cmdline += l.at(i);

    // cerco se il nome dell'applicazione e' tra quelle del file di

    // configurazione

    bool foundApp                  = false;

    vector<tfilepath>::iterator it = m_server->m_appPaths.begin();</tfilepath>

    for (; it != m_server->m_appPaths.end(); ++it) {

      TFilePath appPath = *it;

      if (appPath.getName() == appName.toStdString()) {

        exename = QString::fromStdWString(appPath.getWideString());

        break;

      }

    }

  }

#endif  // LEVO

  // cout << exename << endl;

  // cout << cmdline << endl;

  QProcess process;

  process.start(cmdline);

  process.waitForFinished(-1);

  int exitCode  = process.exitCode();

  int errorCode = process.error();

  bool ret      = (errorCode != QProcess::UnknownError) || exitCode;

  // int ret=QProcess::execute(/*"C:\\depot\\vincenzo\\toonz\\main\\x86_debug\\"

  // +*/cmdline);

  if (ret != 0) {

    QString logMsg("Task aborted ");

    logMsg += "\n\n";

    m_log->warning(logMsg);

    m_controller->taskSubmissionError(m_id, exitCode);

  } else {

    logMsg = "Task completed at ";

    logMsg += QDateTime::currentDateTime().toString();

    logMsg += "\n\n";

    m_log->info(logMsg);

    m_controller->taskCompleted(m_id, exitCode);

    // CloseHandle(hJob);

  }

  m_server->removeTask(m_id);

  //************* COMMENTATO A CAUSA DI UN PROBLEMA SU XP

  // ora i dischi vengono montati al primo task di tipo "runcasm"

  // e smontati allo stop del servizio

  // service.unmountDisks();

}

//==============================================================================

//==============================================================================

FarmServer::FarmServer(int port, TUserLog *log)

    : TFarmExecutor(port), m_controller(), m_userLog(log) {

  TFarmServer::HwInfo hwInfo;

  queryHwInfo(hwInfo);

  m_executor = new TThread::Executor;

  m_executor->setMaxActiveTasks(1);

}

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

FarmServer::~FarmServer() { delete m_executor; }

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

QString FarmServer::execute(const vector<qstring> &argv) {</qstring>

  if (argv.size() > 0) {

    if (argv[0] == "addTask" && argv.size() == 3) {

      // assert(!"Da fare");

      int ret = addTask(argv[1], argv[2]);

      return QString::number(ret);

    } else if (argv[0] == "terminateTask" && argv.size() > 1) {

      int ret = terminateTask(argv[1]);

      return QString::number(ret);

    } else if (argv[0] == "getTasks") {

      vector<qstring> tasks;</qstring>

      int ret = getTasks(tasks);

      QString reply(QString::number(ret));

      reply += ",";

      vector<qstring>::iterator it = tasks.begin();</qstring>

      for (; it != tasks.end(); ++it) {

        reply += *it;

        reply += ",";

      }

      if (!reply.isEmpty()) reply.left(reply.size() - 1);

      return reply;

    } else if (argv[0] == "queryHwInfo") {

      TFarmServer::HwInfo hwInfo;

      queryHwInfo(hwInfo);

      QString ret;

      ret += QString::number((unsigned long)hwInfo.m_cpuCount);

      ret += ",";

      ret += QString::number((unsigned long)(hwInfo.m_totPhysMem / 1024));

      ret += ",";

      ret += QString::number((unsigned long)(hwInfo.m_availPhysMem / 1024));

      ret += ",";

      ret += QString::number((unsigned long)(hwInfo.m_totVirtMem / 1024));

      ret += ",";

      ret += QString::number((unsigned long)(hwInfo.m_availVirtMem / 1024));

      ret += ",";

      ret += QString::number(hwInfo.m_type);

      return ret;

    } else if (argv[0] == "attachController" && argv.size() > 3) {

      int port;

      fromStr(port, argv[3]);

      attachController(ControllerData(argv[1], argv[2], port));

      return "";

    } else if (argv[0] == "detachController" && argv.size() > 3) {

      int port;

      fromStr(port, argv[3]);

      detachController(ControllerData(argv[1], argv[2], port));

      return "";

    }

  }

  return QString::number(-1);

  ;

}

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

int FarmServer::addTask(const QString &id, const QString &cmdline) {

  // std::cout << "Server: addTask" << id << cmdline << std::endl;

  QString lcmdline = cmdline;

  if (lcmdline.contains("runcasm")) {

    // il task e' runcasm

    TFilePath rootDir = getGlobalRoot();

    TFilePath logfilePath =

        (rootDir + "logs" + id.toStdString()).withType(".log");

    lcmdline +=

        " -logfile " + QString::fromStdWString(logfilePath.getWideString());

    TFilePath casmpmeterFp = getBinRoot() + CASMPMETER;

    lcmdline += " -ac " + QString::fromStdWString(casmpmeterFp.getWideString());

    lcmdline += " -ac_args " + QString(QUOTE_STR);

    lcmdline += "$count $total $frame $filename " + id + QUOTE_STR;

  }

  if (lcmdline.contains("zrender")) lcmdline += " -taskid " + id;

  if (lcmdline.contains("tcomposer")) {

    lcmdline += " -farm " + QString::number(m_controllerData.m_port) + "@" +

                m_controllerData.m_hostName;

    lcmdline += " -id " + id;

  }

  m_executor->addTask(new Task(id, lcmdline, m_userLog, this, m_controller));

  QMutexLocker sl(&m_mux);

  m_tasks.push_back(id);

  return 0;

}

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

int FarmServer::terminateTask(const QString &taskid) {

#ifdef _WIN32

  HANDLE hJob = OpenJobObject(MAXIMUM_ALLOWED,  // access right

                              TRUE,             // inheritance state

#if QT_VERSION >= 0x050500

                              taskid.toUtf8());  // job name

#else

                              taskid.toAscii());              // job name

#endif

  if (hJob != NULL) {

    BOOL res = TerminateJobObject(hJob,  // handle to job

                                  2);    // exit code

  }

#else

#endif

  return 0;

}

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

int FarmServer::getTasks(vector<qstring> &tasks) {</qstring>

  QMutexLocker sl(&m_mux);

  tasks = m_tasks;

  return m_tasks.size();

}

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

void FarmServer::queryHwInfo(HwInfo &hwInfo) {

#ifdef _WIN32

  MEMORYSTATUS buff;

  GlobalMemoryStatus(&buff);

  hwInfo.m_totPhysMem   = buff.dwTotalPhys;

  hwInfo.m_availPhysMem = buff.dwAvailPhys;

  hwInfo.m_totVirtMem   = buff.dwTotalVirtual;

  hwInfo.m_availVirtMem = buff.dwAvailVirtual;

  hwInfo.m_cpuCount     = TSystem::getProcessorCount();

  hwInfo.m_type         = Windows;

#else

#ifdef __sgi

  hwInfo.m_cpuCount = sysconf(_SC_NPROC_CONF);

  hwInfo.m_type     = Irix;

#else

#ifdef MACOSX

  int mib[2];

  TINT64 physMemSize;

  size_t len;

  mib[0] = CTL_HW;

  mib[1] = HW_MEMSIZE;

  len    = sizeof(physMemSize);

  sysctl(mib, 2, &physMemSize, &len, NULL, 0);

#endif

#ifdef LINUX

  TINT64 physMemSize =

      (TINT64)sysconf(_SC_PHYS_PAGES) * (TINT64)sysconf(_SC_PAGE_SIZE);

#endif

  hwInfo.m_cpuCount = TSystem::getProcessorCount();

  // We can just retrieve the overall physical memory - the rest is defaulted to

  // 500 MB

  hwInfo.m_totPhysMem   = physMemSize;

  hwInfo.m_availPhysMem = 500000000;

  hwInfo.m_totVirtMem   = 500000000;

  hwInfo.m_availVirtMem = 500000000;

  hwInfo.m_type         = Linux;

#endif

#endif

}

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

void FarmServer::attachController(const ControllerData &data) {

  setController(data);

}

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

void FarmServer::detachController(const ControllerData &data) {

  if (m_controllerData == data) {

    // delete m_controller;

    m_controller = 0;

  }

}

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

void FarmServer::removeTask(const QString &id) {

  QMutexLocker sl(&m_mux);

  vector<qstring>::iterator it = find(m_tasks.begin(), m_tasks.end(), id);</qstring>

  if (it != m_tasks.end()) m_tasks.erase(it);

}

//==============================================================================

namespace {

std::string getLine(std::istream &is) {

  std::string out;

  char c;

  while (!is.eof()) {

    is.get(c);

    if (c != '\r')

      if (c != '\n')

        if (!is.fail())

          out.append(1, c);

        else

          break;

      else

        break;

  }

  return out;

}

}  // anonymous namespace

int inline STRICMP(const QString &a, const QString &b) {

  return a.compare(b, Qt::CaseSensitive);

}

int inline STRICMP(const char *a, const char *b) {

  QString str(a);

  return str.compare(QString(b), Qt::CaseSensitive);

}

static bool loadServerData(const QString &hostname, QString &addr, int &port) {

  TFilePath rootDir = getGlobalRoot();

  TFilePath fp = rootDir + "config" + "servers.txt";

#ifndef _WIN32

  int acc = access(::to_string(fp).c_str(), 00);  // 00 == solo esistenza

  bool fileExists = acc != -1;

  if (!fileExists) return false;

#endif

  Tifstream is(fp);

  if (!is.good()) return false;

  while (!is.eof()) {

    std::string line = getLine(is);

    std::istringstream iss(line);

    std::string name;

    std::string ipAddress;

    iss >> name >> ipAddress >> port;

    if (name[0] == '#') continue;

#if QT_VERSION >= 0x050500

    if (STRICMP(hostname.toUtf8(), name.c_str()) == 0)

#else

    if (STRICMP(hostname.toAscii(), name.c_str()) == 0)

#endif

    {

      addr = QString(ipAddress.c_str());

      return true;

    }

  }

  return false;

}

//==============================================================================

void FarmServerService::onStart(int argc, char *argv[]) {

  // Initialize thread components

  TThread::init();

#ifdef _WIN32

//  DebugBreak();

#endif

  TFilePath lRootDir = getLocalRoot();

  TFileStatus fs(lRootDir);

  bool lRootDirExists = fs.isDirectory();

  if (!lRootDirExists) {

    std::string errMsg("Unable to start the Server");

    errMsg += "\n";

    errMsg += "The directory specified as Local Root does not exist";

    errMsg += "\n";

    addToMessageLog(errMsg);

// DEBUG MAC SERVIZIO (DA TOGLIERE)

#ifdef MACOSX

    system("echo 'local root does not exist' >> err.log");

#endif

    // exit the program

    setStatus(TService::Stopped, NO_ERROR, 0);

  }

  TFilePath gRootDir = getGlobalRoot();

  if (::to_string(gRootDir) == "") {

    std::string errMsg("Unable to get TFARMGLOBALROOT environment variable");

    addToMessageLog(errMsg);

// DEBUG MAC SERVIZIO (DA TOGLIERE)

#ifdef MACOSX

    system("echo 'Unable to set the global root' >> err.log");

#endif

    // exit the program

    setStatus(TService::Stopped, NO_ERROR, 0);

  }

  bool gRootDirExists = dirExists(gRootDir);

  ;

  if (!gRootDirExists) {

    std::string errMsg("Unable to start the Server");

    errMsg += "\n";

    errMsg += "The directory " + ::to_string(gRootDir) +

              " specified as Global Root does not exist";

    ;

    addToMessageLog(errMsg);

// DEBUG MAC SERVIZIO (DA TOGLIERE)

#ifdef MACOSX

    system("echo 'Global root does not exist' >> err.log");

#endif

    // exit the program

    setStatus(TService::Stopped, NO_ERROR, 0);

  }

  // legge dal file di configurazione le informazioni sul controller

  TFilePath fp = gRootDir + "config" + "controller.txt";

  ControllerData controllerData;

  try {

    ::loadControllerData(fp, controllerData);

  } catch (TException &e) {

    std::string errMsg("Unable to start the Server");

    errMsg += "\n";

    errMsg += ::to_string(e.getMessage());

    addToMessageLog(errMsg);

    setStatus(TService::Stopped, NO_ERROR, 0);  // exit the program

  }

  if (isRunningAsConsoleApp()) {

    // i messaggi verranno ridiretti sullo standard output

    m_userLog = new TUserLog();

  } else {

    TFilePath logFilePath = lRootDir + "server.log";

    m_userLog             = new TUserLog(logFilePath);

  }

  m_userLog->info("ToonzFarm Server 1.0");

  // legge dal file di configurazione dei server il numero di porta da

  // utilizzare

  bool ret = loadServerData(TSystem::getHostName(), m_addr, m_port);

  if (!ret) {

    QString msg("Unable to get the port number of ");

    msg += TSystem::getHostName();

    msg += " from the servers config file";

    msg += "\n";

    msg += "Using the default port number 8002";

    msg += "\n";

    msg += "\n";

    m_userLog->info(msg);

    m_port = 8002;

  }

#ifdef __sgi

  {

    std::ofstream os("/tmp/.tfarmserverd.dat");

    os << m_port;

  }

#endif

  m_farmServer = new FarmServer(m_port, m_userLog);

  m_farmServer->setController(controllerData);

  try {

    m_farmServer->getController()->attachServer(TSystem::getHostName(), m_addr,

                                                m_port);

  } catch (TException const &) {

  }

#ifdef _WIN32

  TFilePath diskMountingsFilePath = lRootDir + "config" + "diskmap.cfg";

  if (myDoesExists(diskMountingsFilePath)) {

    loadDiskMountingPoints(diskMountingsFilePath);

    // i dischi vengono montati al primo task di tipo "runcasm"

    // e smontati allo stop del servizio

    // mountDisks();

  }

#endif

  // Carica da un file di configurazione i path dei programmi da lanciare.

  // Per tutti i programmi il cui path non e' contenuto nel file di

  // configurazione

  // si assume che il path del folder del programma sia specificato

  // nella variabile di sistema PATH

  QEventLoop eventLoop;

  // Connect the server's listening finished signal to main loop quit.

  QObject::connect(m_farmServer, SIGNAL(finished()), &eventLoop, SLOT(quit()));

  // Run the TcpIp server's listening state

  m_farmServer->start();

  // Main loop starts here

  eventLoop.exec();

  //----------------------Farm server loops here------------------------

  int rc = m_farmServer->getExitCode();