#include "casmsubmitpage.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 "filebrowserpopup.h"

#include "casmconfigpanel.h"

#include "casmfileinfo.h"

#include "tfarmcontroller.h"

#include "application.h"

#include "util.h"

#include "tw/message.h"

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

class CasmSubmitPage::Data {

public:

  Data(CasmSubmitPage *cspage);

  ~Data() { delete m_casmTask; }

  void configureNotify(const TDimension &size);

  void browseCasmFiles();

  void submit();

  void loadCasm(const TFilePath &fp);

  CasmSubmitPage *m_cspage;

  TLabel *m_taskNameLabel;

  TTextField *m_taskNameTextField;

  TCheckBox *m_submitAsSuspended;

  TButton *m_submit;

  TLabel *m_filepathLabel;

  TTextField *m_filepathTextField;

  TButton *m_casmBrowseBtn;

  CasmConfigPanel *m_configPanel;

  CasmTask *m_casmTask;

};

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

CasmSubmitPage::Data::Data(CasmSubmitPage *cspage)

    : m_cspage(cspage), m_casmTask(0) {

  m_taskNameLabel = new TLabel(cspage);

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

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

  m_taskNameTextField = new TTextField(cspage);

  m_filepathLabel = new TLabel(cspage);

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

  m_filepathTextField = new TTextField(cspage);

  m_casmBrowseBtn     = new TButton(cspage);

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

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

  m_submit = new TButton(cspage);

  m_submit->setTitle("Submit");

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

  m_configPanel = new CasmConfigPanel(cspage);

}

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

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

  int x0 = 20;

  int y  = size.ly - 1 - 10;

  int x  = x0;

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

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

  x += 280;

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

  x += 150;

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

  x = x0;

  y -= 40;

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

  x = x0;

  y -= 40;

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

}

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

void CasmSubmitPage::Data::browseCasmFiles() {

  static FileBrowserPopup *popup = 0;

  if (!popup) {

    vector<string> fileTypes;</string>

    fileTypes.push_back("casm");

    popup = new FileBrowserPopup(m_cspage, fileTypes);

    popup->setOkAction(new TFileBrowserPopupAction<casmsubmitpage::data>(</casmsubmitpage::data>

        this, &CasmSubmitPage::Data::loadCasm));

  }

  if (!popup) return;

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

  if (fp != TFilePath()) 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 Casm");

}

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

void CasmSubmitPage::Data::submit() {

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

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

    return;

  }

  CasmTask *casm = m_configPanel->getTask();

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

  string nativeCmdLine("runcasm ");

  nativeCmdLine += casm->m_casmFile;

  nativeCmdLine += " ";

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

    nativeCmdLine += "-setup ";

    nativeCmdLine += casm->m_setupFile;

    nativeCmdLine += " ";

  }

  nativeCmdLine += casm->getCommandLine();

  string casmName = TFilePath(casm->m_casmFile).getName();

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

  TFarmTaskGroup task(casmName, nativeCmdLine, TSystem::getUserName(),

                      TSystem::getHostName(), stepCount);

  int ra = casm->m_start;

  for (;;) {

    CasmTask 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.m_casmFile;

    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;

      task.addTask(new TFarmTask(name, cmdLine, TSystem::getUserName(),

                                 TSystem::getHostName(), stepCount));

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

  }

}

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

#ifdef WIN32

void DisplayStruct(LPNETRESOURCE lpnr) {

  string info;

  if (lpnr->lpLocalName) {

    info += lpnr->lpLocalName;

    info += " = ";

  }

  info += lpnr->lpRemoteName;

  MessageBox(NULL, info.c_str(), "Connection info", 0);

}

BOOL WINAPI EnumerateFunc(LPNETRESOURCE lpnr) {

  DWORD dwResult, dwResultEnum;

  HANDLE hEnum;

  DWORD cbBuffer = 16384;   // 16K is a good size

  DWORD cEntries = -1;      // enumerate all possible entries

  LPNETRESOURCE lpnrLocal;  // pointer to enumerated structures

  DWORD i;

  //

  // Call the WNetOpenEnum function to begin the enumeration.

  //

  dwResult = WNetOpenEnum(

      RESOURCE_CONNECTED /*RESOURCE_GLOBALNET*/,  // all network resources

      RESOURCETYPE_ANY,                           // all resources

      0,                                          // enumerate all resources

      lpnr,     // NULL first time the function is called

      &hEnum);  // handle to the resource

  if (dwResult != NO_ERROR) {

    //

    // Process errors with an application-defined error handler.

    //

    // NetErrorHandler(hwnd, dwResult, (LPSTR)"WNetOpenEnum");

    return FALSE;

  }

  //

  // Call the GlobalAlloc function to allocate resources.

  //

  lpnrLocal = (LPNETRESOURCE)GlobalAlloc(GPTR, cbBuffer);

  do {

    //

    // Initialize the buffer.

    //

    ZeroMemory(lpnrLocal, cbBuffer);

    //

    // Call the WNetEnumResource function to continue

    //  the enumeration.

    //

    dwResultEnum = WNetEnumResource(hEnum,       // resource handle

                                    &cEntries,   // defined locally as -1

                                    lpnrLocal,   // LPNETRESOURCE

                                    &cbBuffer);  // buffer size

    //

    // If the call succeeds, loop through the structures.

    //

    if (dwResultEnum == NO_ERROR) {

      for (i = 0; i < cEntries; i++) {

        // Call an application-defined function to

        //  display the contents of the NETRESOURCE structures.

        //

        DisplayStruct(&lpnrLocal[i]);

        // If the NETRESOURCE structure represents a container resource,

        //  call the EnumerateFunc function recursively.

        if (RESOURCEUSAGE_CONTAINER ==

            (lpnrLocal[i].dwUsage & RESOURCEUSAGE_CONTAINER))

          if (!EnumerateFunc(&lpnrLocal[i])) return FALSE;

        // TextOut(hdc, 10, 10, "EnumerateFunc returned FALSE.", 29);

      }

    }

    // Process errors.

    //

    else if (dwResultEnum != ERROR_NO_MORE_ITEMS) {

      // NetErrorHandler(hwnd, dwResultEnum, (LPSTR)"WNetEnumResource");

      break;

    }

  }

  //

  // End do.

  //

  while (dwResultEnum != ERROR_NO_MORE_ITEMS);

  //

  // Call the GlobalFree function to free the memory.

  //

  GlobalFree((HGLOBAL)lpnrLocal);

  //

  // Call WNetCloseEnum to end the enumeration.

  //

  dwResult = WNetCloseEnum(hEnum);

  if (dwResult != NO_ERROR) {

    //

    // Process errors.

    //

    // NetErrorHandler(hwnd, dwResult, (LPSTR)"WNetCloseEnum");

    return FALSE;

  }

  return TRUE;

}

#endif

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

void CasmSubmitPage::Data::loadCasm(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("");

    TMessage::error(msg);

    return;

  }

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

  string uncString = convertToUncString(fp);

  m_filepathTextField->setText(uncString);

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

#ifdef WIN32

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

  while (x != string::npos) {

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

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

  }

#endif

  TFilePath uncFilePath = TFilePath(uncString);

  CasmFileInfo casmFileInfo(uncFilePath);

  int start, end;

  bool interlaced;

  casmFileInfo.getFrameRange(start, end, interlaced);

  if (m_casmTask) delete m_casmTask;

  m_casmTask = new CasmTask;

  m_casmTask->m_casmFile = uncString;

  m_casmTask->m_start    = start;

  m_casmTask->m_end      = end;

  m_casmTask->m_step     = 1;

  m_configPanel->setTask(m_casmTask);

}

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

CasmSubmitPage::CasmSubmitPage(TWidget *parent)

    : TabPage(parent, "SubmitCasm") {

  m_data = new CasmSubmitPage::Data(this);

}

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

CasmSubmitPage::~CasmSubmitPage() {}

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

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

  m_data->configureNotify(size);

}

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

void CasmSubmitPage::onActivate() {}

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

void CasmSubmitPage::onDeactivate() {}