#include "submitpage.h"

#include "dependedlist.h"

#include "tfilepath.h"

#include "tconvert.h"

#include "tsystem.h"

#include "tw/mainshell.h"

#include "tw/textfield.h"

#include "tw/label.h"

#include "tw/optionmenu.h"

#include "tw/button.h"

#include "tw/checkbox.h"

#include "tw/keycodes.h"

#include "tw/event.h"

#include "filebrowserpopup.h"

#include "casmconfigpanel2.h"

#include "scriptconfigpanel.h"

#include "casmfileinfo.h"

#include "tfarmcontroller.h"

#include "application.h"

#include "util.h"

#include "tw/message.h"

#ifdef ZCOMP

#include "zrenderconfigpanel.h"

#include "zrendertask.h"

#endif

#include <map></map>

using namespace std;

#ifdef __sgi

#define TERMINAL "xwsh"

#else

#define TERMINAL "xterm"

#endif

using namespace TwConsts;

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

class TextFieldChanger : public TTextField::Action {

  SubmitPage *m_submit;

  bool m_isName;

public:

  TextFieldChanger(SubmitPage *submit, bool isName)

      : m_submit(submit), m_isName(isName) {}

  void sendCommand(wstring name) {

    m_submit->onTextField(toString(name), m_isName);

  }

};

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

class SubmitPage::Data {

  class FilePathField : public TTextField {

    SubmitPage::Data *m_data;

  public:

    FilePathField(SubmitPage::Data *data, TWidget *parent, string name = "")

        : TTextField(parent, name), m_data(data) {}

    void onFocusChange(bool on) {

      if (!on) close();

      TWidget::onFocusChange(on);

    }

    void close() {

      static wstring oldText;

      if (oldText != m_text) {

        TFilePath fp(m_text);

        try {

          wstring uncString;

          try {

            uncString = toWideString(convertToUncString(fp));

            m_text    = uncString;

            m_data->load(fp);

          } catch (TException &) {

            TFileStatus fs(fp);

            if (fs.doesExist() && !fs.isDirectory())

              m_data->load(fp);

            else if (m_data->m_task)

              m_data->m_task->setFilePath(toString(m_text));

          }

          oldText = m_text;

        } catch (...) {

        }

      }

      invalidate();

    }

    void keyDown(int key, unsigned long flags, const TPoint &p) {

      if (key == TK_Return)

        close();

      else

        TTextField::keyDown(key, flags, p);

    }

  };

public:

  Data(SubmitPage *page);

  ~Data();

  void configureNotify(const TDimension &size);

  void browseCasmFiles();

  void submit();

  void submitCasm(CasmTask2 *casm);

  void submitScript(ScriptTask *script);

  void load(const TFilePath &fp);

  void onTaskType(string type);

  SubmitPage *m_page;

  TLabel *m_taskTypeLbl;

  TOptionMenu *m_taskType;

  TLabel *m_taskNameLbl;

  TTextField *m_taskNameTextField;

  TCheckBox *m_submitAsSuspended;

  TButton *m_submit;

  TLabel *m_filepathLbl;

  FilePathField *m_filepathTextField;

  TButton *m_casmBrowseBtn;

  TLabel *m_priorityLbl;

  TNumField *m_priority;

  TLabel *m_depListLbl;

  DependedList *m_depList;

  SubmitPageTask *m_task;

  std::map<string, *="" submitpagetask=""> m_tasks;</string,>

  TaskConfigPanel *m_configPanel;

  std::map<string, *="" taskconfigpanel=""> m_configPanels;</string,>

};

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

SubmitPage::Data::Data(SubmitPage *page) : m_page(page), m_task(0) {

  m_taskTypeLbl = new TLabel(page);

  m_taskTypeLbl->setText("Task type:");

  m_taskType = new TOptionMenu(page);

  m_taskType->addOption("Casm");

  m_taskType->addOption("Script");

  m_taskType->setAction(new TOptionMenuAction<submitpage::data>(</submitpage::data>

      this, &SubmitPage::Data::onTaskType));

  m_configPanel = new CasmConfigPanel2(page);

  m_configPanels.insert(make_pair(string("Casm"), m_configPanel));

  m_configPanels.insert(

      make_pair(string("Script"), new ScriptConfigPanel(page)));

  std::map<string, *="" taskconfigpanel="">::iterator it = m_configPanels.begin();</string,>

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

    TaskConfigPanel *configPanel = it->second;

    if (configPanel != m_configPanel) configPanel->hide();

  }

  m_taskNameLbl = new TLabel(page);

  m_taskNameLbl->setText("Task Name:");

  m_taskNameTextField = new TTextField(page);

  m_taskNameTextField->addAction(new TextFieldChanger(page, true));

  m_submitAsSuspended = new TCheckBox(page, "Submit as Suspended");

  m_filepathLbl = new TLabel(page);

  m_filepathLbl->setText("File Path:");

  m_filepathTextField = new FilePathField(this, page);

  // m_filepathTextField->addAction(new TextFieldChanger(page, false));

  m_casmBrowseBtn = new TButton(page);

  m_casmBrowseBtn->setTitle("...");

  tconnect(*m_casmBrowseBtn, this, &SubmitPage::Data::browseCasmFiles);

  m_submit = new TButton(page);

  m_submit->setTitle("Submit");

  tconnect(*m_submit, this, &SubmitPage::Data::submit);

  m_priorityLbl = new TLabel(page);

  m_priorityLbl->setText("Priority:");

  m_priority = new TNumField(page);

  m_priority->setIsInteger(true);

  m_priority->setRange(1, 100);

  m_priority->setValue(50);

  m_depListLbl = new TLabel(page);

  m_depListLbl->setText("Task Dependencies:");

  m_depList = new DependedList(page);

}

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

SubmitPage::Data::~Data() {

  std::map<string, *="" submitpagetask="">::iterator it = m_tasks.begin();</string,>

  while (it != m_tasks.end()) {

    delete it->second;

    ++it;

  }

  std::map<string, *="" taskconfigpanel="">::iterator it1 = m_configPanels.begin();</string,>

  while (it1 != m_configPanels.end()) {

    delete it1->second;

    ++it1;

  }

}

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

void SubmitPage::Data::configureNotify(const TDimension &size) {

  int x0 = 20;

  int y  = size.ly - 1 - 10;

  int x  = x0;

  m_taskTypeLbl->setGeometry(x, y - 15, x + 100, y);

  m_taskType->setGeometry(x + 104, y - 15, x + 200, y);

  x = x0;

  y -= 40;

  m_taskNameLbl->setGeometry(x, y - 15, x + 100, y);

  m_taskNameTextField->setGeometry(x + 104, y - 15, x + 250, y);

  x += 280;

  m_priorityLbl->setGeometry(x, y - 15, x + 50, y);

  m_priority->setGeometry(x + 54, y - 15, x + 100, y);

  m_submitAsSuspended->setGeometry(x + 130, y - 15, x + 280, y);

  x += 310;

  m_submit->setGeometry(x, y - 15, x + 80, y);

  x = x0;

  y -= 40;

  m_filepathLbl->setGeometry(x, y - 15, x + 100, y);

  m_filepathTextField->setGeometry(x + 104, y - 15, x + 650, y);

  m_casmBrowseBtn->setGeometry(x + 660, y - 15, x + 680, y);

  y -= 40;

  x = x0;

  m_depListLbl->setGeometry(x, y - 15, x + 160, y);

  y -= 20;

  m_depList->setGeometry(x + 10, y - 80, size.lx - 1, y);

  x = x0;

  y -= 90;

  // m_configPanel->setGeometry(0,0,size.lx-1,y);

  std::map<string, *="" taskconfigpanel="">::iterator it;</string,>

  it = m_configPanels.begin();

  for (; it != m_configPanels.end(); ++it)

    it->second->setGeometry(0, 0, size.lx - 1, y);

}

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

void SubmitPage::Data::browseCasmFiles() {

  static FileBrowserPopup *puCasm   = 0L;

  static FileBrowserPopup *puScript = 0L;

  FileBrowserPopup *popup;

  if (m_taskType->getText() == "Casm") {

    if (!puCasm) {

      vector<string> fileTypes;</string>

      fileTypes.push_back("casm");

      puCasm = new FileBrowserPopup(m_page, fileTypes);

      puCasm->setOkAction(new TFileBrowserPopupAction<submitpage::data>(</submitpage::data>

          this, &SubmitPage::Data::load));

    }

    popup = puCasm;

  } else if (m_taskType->getText() == "Script") {

    if (!puScript) {

      vector<string> fileTypes;</string>

#ifdef WIN32

      fileTypes.push_back("bat");

#else

      fileTypes.push_back("csh");

      fileTypes.push_back("sh");

      fileTypes.push_back("tcsh");

#endif

      puScript = new FileBrowserPopup(m_page, fileTypes);

      puScript->setOkAction(new TFileBrowserPopupAction<submitpage::data>(</submitpage::data>

          this, &SubmitPage::Data::load));

    }

    popup = puScript;

  }

  if (!popup) return;

  TFilePath fp = Application::instance()->getCurrentFolder();

  /*

E'stato necessario fare questo controllo perche' il popup non e' in grado

di impostare opportunamente le cose

*/

  wstring path = fp.getWideString();

  if (fp != TFilePath() && (path[0] != '\\')) popup->setCurrentDir(fp);

  TDimension d = TMainshell::getMainshell()->getSize();

#ifdef WIN32

  HDC hdc = GetDC(0);

  d.lx    = GetDeviceCaps(hdc, HORZRES);

  d.ly    = GetDeviceCaps(hdc, VERTRES);

  ReleaseDC(0, hdc);

#endif

  d -= popup->getSize();

  // TDimension d = TMainshell::getMainshell()->getSize() - popup->getSize();

  popup->popup(TPoint(d.lx / 2, d.ly / 2));

  popup->setCaption("Load " + m_taskType->getText());

}

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

void SubmitPage::Data::load(const TFilePath &fp) {

  if (!TFileStatus(fp).doesExist()) {

    string msg = toString(fp.getWideString()) + "\n";

    msg += "File not found\n";

    msg += "Please verify that the path and file name are correct";

    m_filepathTextField->setText(toString(fp.getWideString()));

    TMessage::error(msg);

    return;

  }

  string uncString = toString(fp.getWideString());

  if (toString(m_filepathTextField->getText()) != uncString) try {

      uncString = convertToUncString(fp);

    } catch (TException &e) {

      if (!TFileStatus(fp).doesExist()) {

        TMessage::error(toString(e.getMessage()));

        return;

      }

      uncString = toString(fp.getWideString());

    }

  Application::instance()->setCurrentFolder(fp.getParentDir());

  m_filepathTextField->setText(uncString);

  m_taskNameTextField->setText(TFilePath(uncString).getName());

  string type = m_taskType->getText();

#ifdef WIN32

  if (type == "Casm") {

    int x = uncString.find("\\", 2);

    while (x != string::npos) {

      uncString.replace(x, 1, "/", 0, 1);

      x = uncString.find("\\", x + 1);

    }

  }

#endif

  if (type == "Casm")

    m_task = new CasmTask2;

  else if (type == "Script")

    m_task = new ScriptTask;

  else

    assert(false);

  std::map<string, *="" submitpagetask="">::iterator it = m_tasks.find(type);</string,>

  if (it != m_tasks.end()) {

    delete it->second;

    it->second = m_task;

  } else

    m_tasks.insert(std::make_pair(type, m_task));

  m_task->setFileArg(uncString);

  m_depList->clearAll();

  m_configPanel->setTask(m_task);

}

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

void SubmitPage::Data::submit() {

  if (toString(m_filepathTextField->getText()) == "") {

    TMessage::error("You must load a file");

    return;

  }

  try {

    CasmTask2 *casm    = dynamic_cast<casmtask2 *="">(m_task);</casmtask2>

    ScriptTask *script = dynamic_cast<scripttask *="">(m_task);</scripttask>

#ifdef ZCOMP

    ZRenderTask *zrender = dynamic_cast<zrendertask *="">(m_task);</zrendertask>

#endif

    if (casm) {

      casm->checkNameUnc();

      submitCasm(casm);

    } else if (script) {

      script->checkNameUnc();

      submitScript(script);

    }

#ifdef ZCOMP

    else if (zrender) {

      zrender->checkNameUnc();

      submitZRender(zrender);

    }

#endif

    else {

      TMessage::error("Verify if " + toString(m_filepathTextField->getText()) +

                      " is correct");

      return;

    }

  } catch (TException &e) {

    TMessage::error(toString(e.getMessage()));

  }

}

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

void SubmitPage::Data::submitCasm(CasmTask2 *casm) {

  TFarmController *controller = Application::instance()->getController();

  string nativeCmdLine("runcasm ");

  nativeCmdLine += casm->getFilePath();

  nativeCmdLine += " ";

  if (casm->m_setupFile != "") {

    nativeCmdLine += "-setup ";

    nativeCmdLine += casm->m_setupFile;

    nativeCmdLine += " ";

  }

  nativeCmdLine += casm->getCommandLine();

  string casmName = casm->getName();

  string user   = TSystem::getUserName();

  string host   = TSystem::getHostName();

  int stepCount = casm->m_end - casm->m_start + 1;

  TFarmTaskGroup task(casmName, nativeCmdLine, user, host, stepCount,

                      (int)m_priority->getValue());

  map<string, string=""> dep             = casm->getDependencies();</string,>

  map<string, string="">::iterator itDep = dep.begin();</string,>

  for (; itDep != dep.end(); ++itDep) task.m_dependencies->add((*itDep).first);

  int ra = casm->m_start;

  int subCount = casm->m_end / casm->m_taskChunksize;

  if (casm->m_end % casm->m_taskChunksize) subCount++;

  if (subCount != 1)

    for (;;) {

      CasmTask2 subcasm(*casm);

      string cmdLine("runcasm ");

      int rb = tmin(ra + casm->m_taskChunksize - 1, casm->m_end);

      subcasm.m_start = ra;

      subcasm.m_end   = rb;

      cmdLine += subcasm.getFilePath();

      cmdLine += " ";

      if (subcasm.m_setupFile != "") {

        cmdLine += "-setup ";

        cmdLine += subcasm.m_setupFile;

        cmdLine += " ";

      }

      cmdLine += subcasm.getCommandLine();

      cmdLine += " -nowait ";

      try {

        string name = casmName + " " + toString(ra) + "-" + toString(rb);

        stepCount   = rb - ra + 1;

        TFarmTask *subTask = new TFarmTask(name, cmdLine, user, host, stepCount,

                                           (int)m_priority->getValue());

        subTask->m_dependencies =

            new TFarmTask::Dependencies(*task.m_dependencies);

        task.addTask(subTask);

      } catch (TException &e) {

        TMessage::error(toString(e.getMessage()));

      }

      if (rb == casm->m_end) break;

      ra = rb + 1;

    }

  try {

    controller->addTask(task, m_submitAsSuspended->isSelected());

  } catch (TException &e) {

    TMessage::error(toString(e.getMessage()));

  }

}

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

void SubmitPage::Data::submitScript(ScriptTask *script) {

  TFarmController *controller = Application::instance()->getController();

  string nativeCmdLine = script->getCommandLine();

  string scriptName = script->getName();

  string user       = TSystem::getUserName();

  string host       = TSystem::getHostName();

  TFarmTask task(scriptName, nativeCmdLine, user, host, 1,

                 (int)m_priority->getValue());

  map<string, string=""> dep             = script->getDependencies();</string,>

  map<string, string="">::iterator itDep = dep.begin();</string,>

  for (; itDep != dep.end(); ++itDep) task.m_dependencies->add((*itDep).first);

#ifdef WIN32

  task.m_platform = Windows;

#else

  task.m_platform = Irix;

#endif

  try {

    controller->addTask(task, m_submitAsSuspended->isSelected());

  } catch (TException &e) {

    TMessage::error(toString(e.getMessage()));

  }

}

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

void SubmitPage::Data::onTaskType(string type) {

  std::map<string, *="" taskconfigpanel="">::iterator it;</string,>

  it = m_configPanels.find(type);

  if (it != m_configPanels.end()) {

    m_configPanel->hide();

    TaskConfigPanel *configPanel = it->second;

    m_configPanel                = configPanel;

    m_configPanel->show();

    std::map<string, *="" submitpagetask="">::iterator it1 = m_tasks.find(type);</string,>

    if (it1 != m_tasks.end()) {

      m_task = it1->second;

      m_depList->setList(m_task->getDependencies());

      m_filepathTextField->setText(m_task->getFilePath());

      m_taskNameTextField->setText(m_task->getName());

      m_configPanel->setTask(m_task);

    } else {

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

      m_depList->setList(tasks);

      m_taskNameTextField->setText("");

      m_filepathTextField->setText("");

    }

  }

}

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

SubmitPage::SubmitPage(TWidget *parent) : TabPage(parent, "Submit Task") {

  m_data = new SubmitPage::Data(this);

}

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

SubmitPage::~SubmitPage() { delete m_data; }

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

void SubmitPage::configureNotify(const TDimension &size) {

  m_data->configureNotify(size);

}

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

void SubmitPage::onActivate() {}

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

void SubmitPage::onDeactivate() {}

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

SubmitPageTask *SubmitPage::getTask() const { return m_data->m_task; }

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

void SubmitPage::setTask(SubmitPageTask *task) {

  string type        = "Casm";

  CasmTask2 *casm    = dynamic_cast<casmtask2 *="">(task);</casmtask2>

  ScriptTask *script = dynamic_cast<scripttask *="">(task);</scripttask>

#ifdef ZCOMP

  ZRenderTask *zrender = dynamic_cast<zrendertask *="">(task);</zrendertask>

#endif

  if (casm)

    m_data->m_task = casm;

  else if (script) {

    m_data->m_task = script;

    type           = "Script";

  }

#ifdef ZCOMP

  else if (zrender) {

    m_data->m_task = zrender;

    type           = "ZComp";

  }

#endif

  else {

    assert(false);

  }

  std::map<string, *="" submitpagetask="">::iterator it = m_data->m_tasks.find(type);</string,>

  if (it == m_data->m_tasks.end()) {

    m_data->m_tasks.insert(std::make_pair(type, m_data->m_task));

  } else

    it->second = m_data->m_task;

  std::map<string, *="" taskconfigpanel="">::iterator it1 =</string,>

      m_data->m_configPanels.find(type);

  if (it1 != m_data->m_configPanels.end()) {

    it1->second->setTask(task);

    m_data->m_configPanel = it1->second;

  }

}

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

void SubmitPage::onTextField(const string &name, bool isName) {

  if (!m_data->m_task) return;

  if (isName)

    m_data->m_task->setName(name);

  else

    m_data->m_task->setFilePath(name);

}