#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 "tversion.h"

using namespace TVER;

#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>

#endif

// #define REDIRECT_OUTPUT

#ifdef _WIN32

#define QUOTE_STR "\""

#define CASMPMETER "casmpmeter.exe"

#else

#define QUOTE_STR "'"

#define CASMPMETER "casmpmeter"

#endif

#ifndef _WIN32

#define NO_ERROR 0

#endif

// forward declaration

class FarmServer;

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

namespace {

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

TFilePath getGlobalRoot() {

  TVER::ToonzVersion tver;

  TFilePath rootDir;

#ifdef _WIN32

  std::string regpath = "SOFTWARE\\" + tver.getAppName() + "\\" +

                        tver.getAppName() + "\\" + tver.getAppVersionString() +

                        "\\FARMROOT";

  TFilePath name(regpath);

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

#else

// Leggo la localRoot da File txt

#ifdef MACOSX

  // If MACOSX, change to MACOSX path

  std::string unixpath =

      "./" + tver.getAppName() + ".app/Contents/Resources/configfarmroot.txt";

#else

  // set path to something suitable for most linux (Unix?) systems

  std::string unixpath = "/etc/" + tver.getAppName() + "/opentoonz.conf";

#endif

  TFilePath name(unixpath);

  Tifstream is(name);

  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() {

  TVER::ToonzVersion tver;

  TFilePath lroot;

#ifdef _WIN32

  QString regpath = QString::fromStdString(

      "SOFTWARE\\" + tver.getAppName() + "\\" + tver.getAppName() + "\\" +

      tver.getAppVersionString() + "\\FARMROOT");

  TFilePath name(regpath);

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

          TFilePath("toonzfarm");

#else

#ifdef MACOSX

  // If MACOSX, change to MACOSX path

  std::string unixpath =

      "./" + tver.getAppName() + ".app/Contents/Resources/configfarmroot.txt";

#else

  // set path to something suitable for most linux (Unix?) systems

#ifdef FREEBSD

  std::string unixpath =

      "/usr/local/etc/" + tver.getAppName() + "/opentoonz.conf";

#else

  std::string unixpath = "/etc/" + tver.getAppName() + "/opentoonz.conf";

#endif

#endif

  TFilePath name(unixpath);

  Tifstream is(name);

  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, std::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,>

  std::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);

    std::swap(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 std::vector<tfilepath> &);</tfilepath>

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

  // TFarmServer overrides

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

  int terminateTask(const QString &taskid) override;

  int getTasks(std::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;

  std::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 &);

};

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

static QString getExeName(bool isComposer) {

  QString name = isComposer ? "tcomposer" : "tcleanup";

#ifdef _WIN32

  return name + ".exe ";

#elif defined(MACOSX)

  TVER::ToonzVersion tver;

  return "\"./" + QString::fromStdString(tver.getAppName()) +

         ".app/Contents/MacOS/" + name + "\" ";

#else

  return name;

#endif

}

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

void Task::run() {

  QString cmdline;

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

  // remap commandLine to local executable

  QStringList l   = m_cmdline.split(" ");

  QString appName = l.at(0);

  // m_log->info(appName);

  if (appName.contains("tcomposer") || appName.contains("tcleanup")) {

    bool m_isComposerTask = appName.contains("tcomposer");

    // m_log->info(QString::number(m_isComposerTask));

    appName = getExeName(m_isComposerTask);

    // m_log->info(appName);

    int i   = 0;

    cmdline = appName;

    // m_log->info(cmdline);

    for (i = 1; i < l.size(); i++) {

      cmdline += " ";

      cmdline += l.at(i);

      // m_log->info(cmdline);

    }

    // m_log->info("remap commandLine to local executable");

    // m_log->info(appName);

  } else {

    cmdline = m_cmdline;

  }

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

  QString logMsg("Starting task at ");

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

  logMsg += "\n";

  logMsg += "\"" + cmdline + "\"";

  logMsg += "\n\n";

  m_log->info(logMsg);

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

#ifdef _WIN32

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

#endif

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

    cmdline = "cmd /C " + cmdline;

  else

    cmdline = 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

    for (auto const &appPath : m_server->m_appPaths) {

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

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

        break;

      }

    }

  }

#endif  // LEVO

  // cout << exename << endl;

  // cout << cmdline << endl;

  // parse command line

  QString prgName;

  QString argsStr = "";

  int sepPos      = cmdline.indexOf(" ");

  if (sepPos == -1) {

    prgName = cmdline;

  } else {

    prgName = cmdline.left(sepPos);

    argsStr = cmdline.right(cmdline.size() - sepPos - 1);

  }

  QProcess process;

  process.setProgram(prgName);

#if defined(_WIN32)

  process.setNativeArguments(argsStr);

#else

#if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))

  process.setArguments(argsStr.split(" ", Qt::SkipEmptyParts));

#else

  process.setArguments(argsStr.split(" ", QString::SkipEmptyParts));

#endif

#endif

  process.start();

  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 std::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") {

      std::vector<qstring> tasks;</qstring>

      int ret = getTasks(tasks);

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

      reply += ",";

      for (auto const &e : tasks) {

        reply += e;

        reply += ",";

      }

      if (!reply.isEmpty()) reply = 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

                              taskid.toUtf8());  // job name

  if (hJob != NULL) {

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

                                  2);    // exit code

  }

#else

#endif

  return 0;

}

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

int FarmServer::getTasks(std::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

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

  // 500 MB

  hwInfo.m_totPhysMem   = TSystem::getMemorySize(true);

  hwInfo.m_availPhysMem = TSystem::getFreeMemorySize(true);

  hwInfo.m_totVirtMem   = 500000000;

  hwInfo.m_availVirtMem = 500000000;

  hwInfo.m_cpuCount     = TSystem::getProcessorCount();

#ifdef __sgi

  hwInfo.m_type         = Irix;

#else

  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);

  std::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 (STRICMP(hostname.toUtf8(), name.c_str()) == 0) {

      addr = QString(ipAddress.c_str());

      return true;

    }

  }

  return false;

}

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

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

  // Initialize thread components

  TThread::init();

  TVER::ToonzVersion tver;

#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 " + ::to_string(lRootDir) +

              " 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 (" +

                       ::to_string(gRootDir) + ")");

    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);

  }

  std::string appverinfo = tver.getAppVersionInfo("Farm Server") + "\n\n";

  m_userLog->info(appverinfo.c_str());

  // 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";