#include "taskstatuspage.h"
#include "tw/treeview.h"
#include "tw/colors.h"
#include "tfarmcontroller.h"
#include "application.h"
#include "tw/mainshell.h"
#include "tw/textfield.h"
#include "tw/label.h"
#include "tw/scrollbar.h"
#include "tw/event.h"
#include "textlist.h"
 
#include "tw/message.h"
 
#include "pixmaps.h"
 
#include <vector>
using namespace std;
 
using namespace TwConsts;
 
namespace {
class TaskTreeItemRoot : public TTreeViewItem {
public:
  TaskTreeItemRoot(TTreeViewItem *parent = 0) : TTreeViewItem(parent) {}
 
  wstring getName() const { return toWideString("tasks"); }
 
  TDimension getIconSize() const { return TDimension(32, 30); }
 
  void drawIcon(TTreeView *w, const TPoint &origin) {
    TRect rect(origin, getIconSize());
    rect = rect.enlarge(-3);
    w->rectwrite(tasks_icon, rect.getP00());
  }
};
 
class TaskTreeItem : public TTreeViewItem {
public:
  TaskTreeItem(TTreeViewItem *parent, string &id, string &name,
               TaskState status)
      : TTreeViewItem(parent), m_id(id) {
    /*
setIsLeaf(true);
if(task.m_parentId =="")
setIsLeaf(false);
*/
    m_name   = " <" + m_id + "> " + name;
    m_status = status;
  }
 
  wstring getName() const { return toWideString(m_name); }
 
  string getId() const { return m_id; }
 
  TDimension getIconSize() const { return TDimension(24, 22); }
 
  void drawIcon(TTreeView *w, const TPoint &origin) {
    TRect rect(origin, getIconSize());
    rect = rect.enlarge(-3);
    switch (m_status) {
    case Suspended:
      w->rectwrite(casm_suspended, rect.getP00());
      break;
    case Waiting:
      w->rectwrite(casm_waiting, rect.getP00());
      break;
    case Running:
      w->rectwrite(casm_computing, rect.getP00());
      break;
    case Completed:
      w->rectwrite(casm_done, rect.getP00());
      break;
    case Aborted:
      w->rectwrite(casm_done_with_errors, rect.getP00());
      break;
      // case TaskUnknown:
    }
  }
 
  string m_name;
  string m_id;
  TaskState m_status;
};
 
class SubtaskTreeItem : public TaskTreeItem {
public:
  SubtaskTreeItem(TaskTreeItem *parent, string &id, string &name,
                  TaskState status)
      : TaskTreeItem(parent, id, name, status) {
    setIsLeaf(true);
  }
 
  void drawIcon(TTreeView *w, const TPoint &origin) {
    TRect rect(origin, getIconSize());
    rect = rect.enlarge(-3);
    switch (m_status) {
    case Suspended:
      w->rectwrite(suspended, rect.getP00());
      break;
    case Waiting:
      w->rectwrite(waiting, rect.getP00());
      break;
    case Running:
      w->rectwrite(computing, rect.getP00());
      break;
    case Completed:
      w->rectwrite(done, rect.getP00());
      break;
    case Aborted:
      w->rectwrite(done_with_errors, rect.getP00());
      break;
      // case TaskUnknown:
    }
  }
};
 
class TaskTree : public TTreeView {
  TaskStatusPage *m_statusPage;
  TPopupMenu *m_popupMenu;
  TPopupMenu *m_globalPopupMenu;
 
public:
  TaskTree(TaskStatusPage *parent, string name = "taskTree")
      : TTreeView(parent, name), m_statusPage(parent) {
    m_popupMenu = new TPopupMenu(this);
 
    TPopupMenuItem *item = new TPopupMenuItem(m_popupMenu, "remove");
    TGuiCommand("remove").setAction(
        new TCommandAction<TaskTree>(this, onRemove));
    TGuiCommand("remove").add(item);
 
    item = new TPopupMenuItem(m_popupMenu, "restart");
    TGuiCommand("restart").setAction(
        new TCommandAction<TaskTree>(this, onRestart));
    TGuiCommand("restart").add(item);
 
    m_globalPopupMenu = new TPopupMenu(this);
 
    TPopupMenuItem *item1 =
        new TPopupMenuItem(m_globalPopupMenu, "restart all");
    TGuiCommand("restart all")
        .setAction(new TCommandAction<TaskTree>(this, onRestartAll));
    TGuiCommand("restart all").add(item1);
  }
 
  void rightButtonDown(const TMouseEvent &e) {
    leftButtonDown(e);
    TTreeViewItem *item    = getSelectedItem();
    TaskTreeItem *taskItem = dynamic_cast<TaskTreeItem *>(item);
    if (taskItem) {
      TPoint pos =
          getAbsolutePosition() + TPoint(e.m_pos.x, getSize().ly - e.m_pos.y);
      m_popupMenu->popup(pos);
    }
    TaskTreeItemRoot *taskItemRoot = dynamic_cast<TaskTreeItemRoot *>(item);
    if (taskItemRoot) {
      TPoint pos =
          getAbsolutePosition() + TPoint(e.m_pos.x, getSize().ly - e.m_pos.y);
      m_globalPopupMenu->popup(pos);
    }
  }
 
  void onSelect(TTreeViewItem *item) {
    TaskTreeItem *taskItem = dynamic_cast<TaskTreeItem *>(item);
    if (taskItem) m_statusPage->showTaskInfo(taskItem->getId());
  }
 
  void onExpand(TTreeViewItem *item) {
    string id       = "";
    TaskTreeItem *i = dynamic_cast<TaskTreeItem *>(item);
    if (i) id       = i->getId();
 
    item->clearItems();
    TFarmController *controller = Application::instance()->getController();
    vector<string> tasks;
    try {
      controller->getTasks(id, tasks);
 
      vector<string>::iterator it = tasks.begin();
      for (int j = 0; it != tasks.end(); ++it, ++j) {
        string taskId = *it;
        if (taskId != "") {
          TFarmTask task;
 
          string parentId, name;
          TaskState status;
          controller->queryTaskShortInfo(taskId, parentId, name, status);
 
          if (!item->getItem(name))
            if (parentId == "")
              item->addItem(new TaskTreeItem(0, taskId, name, status));
            else
              item->addItem(new SubtaskTreeItem(0, taskId, name, status));
        }
      }
 
      /*
int count = tasks.size();
for (int j = 0; j< count; ++j)
if(tasks[j] != "")
{
TFarmTask task;
controller->queryTaskInfo(tasks[j], task);
//TMainshell::errorMessage("dopo queryTaskInfo" + tasks[j]);
 
if(!item->getItem(task.m_name))
if(task.m_parentId == "")
item->addItem(new TaskTreeItem(0, task));
else
item->addItem(new SubtaskTreeItem(0, task));
}
*/
    } catch (TException &e) {
      TMessage::error(toString(e.getMessage()));
    }
  }
 
  void onCollapse(TTreeViewItem *item) {
    /*
string id = "";
TaskTreeItem *taskItem = dynamic_cast<TaskTreeItem*> (item);
if(taskItem)
*/
    item->clearItems();
  }
 
  void onRemove() {
    string id = "";
    TaskTreeItem *taskTreeItem =
        dynamic_cast<TaskTreeItem *>(getSelectedItem());
    if (taskTreeItem) id = taskTreeItem->getId();
 
    TFarmController *controller = Application::instance()->getController();
    try {
      controller->removeTask(id);
      update();
    } catch (TException &e) {
      TMessage::error(toString(e.getMessage()));
    }
  }
 
  void onRestart() {
    string id = "";
    TaskTreeItem *taskTreeItem =
        dynamic_cast<TaskTreeItem *>(getSelectedItem());
    if (taskTreeItem) id = taskTreeItem->getId();
 
    TFarmController *controller = Application::instance()->getController();
    try {
      controller->restartTask(id);
      update();
    } catch (TException &e) {
      TMessage::error(toString(e.getMessage()));
    }
  }
 
  void onRestartAll() {
    TFarmController *controller = Application::instance()->getController();
    try {
      vector<string> tasks;
      controller->getTasks("", tasks);
      int i = 0;
      for (; i < (int)tasks.size(); i++) controller->restartTask(tasks[i]);
      update();
    } catch (TException &e) {
      TMessage::error(toString(e.getMessage()));
    }
  }
 
  void update(TTreeViewItem *item) {
    if (!item->isOpen()) return;
 
    TFarmController *controller = Application::instance()->getController();
 
    string taskId;
    TaskTreeItem *task = dynamic_cast<TaskTreeItem *>(item);
    if (task) taskId   = task->getId();
 
    vector<TaskShortInfo> subTasks;
    try {
      controller->getTasks(taskId, subTasks);
    } catch (TException &e) {
      TMessage::error(toString(e.getMessage()));
      return;
    }
 
    vector<TTreeViewItem *> toBeDeleted;
    int count = item->getItemCount();
    for (int i = 0; i < count; ++i) {
      TaskTreeItem *subTask = dynamic_cast<TaskTreeItem *>(item->getItem(i));
      if (subTask) {
        vector<TaskShortInfo>::iterator it = subTasks.begin();
        for (; it != subTasks.end(); ++it) {
          string id = it->m_id;
          if (id == subTask->getId()) break;
        }
 
        if (it != subTasks.end()) {
          subTask->m_status = it->m_status;
          update(subTask);
        } else
          toBeDeleted.push_back(subTask);
      }
    }
 
    vector<TTreeViewItem *>::iterator it = toBeDeleted.begin();
    while (it != toBeDeleted.end()) {
      if (getSelectedItem() == *it) {
        TTreeViewItem *task = dynamic_cast<TTreeViewItem *>((*it)->getParent());
        if (task) select(task);
      }
      item->removeItem(*it++);
    }
 
#ifdef PRIMA
    TFarmController *controller = Application::instance()->getController();
    vector<TTreeViewItem *> toBeDeleted;
    int count = item->getItemCount();
    for (int i = 0; i < count; ++i) {
      TaskTreeItem *task = dynamic_cast<TaskTreeItem *>(item->getItem(i));
      if (task) {
        TFarmTask taskInfo;
        try {
          string parentId, name;
          TaskState status;
          controller->queryTaskShortInfo(task->getId(), parentId, name, status);
          if (status == TaskUnknown)
            toBeDeleted.push_back(task);
          else {
            task->m_status = status;
            update(task);
          }
        } catch (TException &e) {
          TMainshell::errorMessage(e.getMessage());
          return;
        }
      }
    }
 
    vector<TTreeViewItem *>::iterator it = toBeDeleted.begin();
    while (it != toBeDeleted.end()) {
      if (getSelectedItem() == *it) {
        TTreeViewItem *task = dynamic_cast<TTreeViewItem *>((*it)->getParent());
        if (task) select(task);
      }
      item->removeItem(*it++);
    }
#endif
  }
 
  void update() {
    TFarmController *controller = Application::instance()->getController();
 
    TTreeViewItem *item = getItem(0);
    if (!item->isOpen()) return;
 
    if (item) update(item);
 
    // aggiungo i nuovi
    vector<string> tasks;
    try {
      controller->getTasks("", tasks);
    } catch (TException &e) {
      TMessage::error(toString(e.getMessage()));
      return;
    }
 
    vector<string>::iterator it = tasks.begin();
    for (; it != tasks.end(); it++) {
      bool old  = false;
      int count = item->getItemCount();
      for (int i = 0; i < count; ++i) {
        TaskTreeItem *task = dynamic_cast<TaskTreeItem *>(item->getItem(i));
        if (task) old      = (*it == task->getId());
        if (old) break;
      }
 
      if (!old) {
        if (*it != "") {
          TFarmTask task;
          try {
            string parentId, name;
            TaskState status;
            controller->queryTaskShortInfo(*it, parentId, name, status);
            item->addItem(new TaskTreeItem(0, *it, name, status));
          } catch (TException &e) {
            TMessage::error(toString(e.getMessage()));
            return;
          }
        }
      }
    }
    updateVisibleItems();
    invalidate();
  }
};
};  // namespace
 
//==============================================================================
 
class TaskStatusPage::Data {
public:
  Data(TaskStatusPage *parent);
 
  void showTaskInfo(const TFarmTask &task);
  void configureNotify(const TDimension &size);
  void clearFields();
 
  TFarmTask m_currTask;
 
  TaskTree *m_tree;
  TTextField *m_taskId, *m_cmdLine, *m_server, *m_byUser, *m_onMachine,
      *m_priority, *m_submissionDate, *m_startDate, *m_completionDate,
      *m_taskStatus, *m_failedSteps, *m_successfullSteps, *m_stepCount;
 
  TLabel *m_taskIdLbl, *m_cmdLineLbl, *m_serverLbl, *m_byUserLbl,
      *m_onMachineLbl, *m_priorityLbl, *m_submissionDateLbl, *m_startDateLbl,
      *m_completionDateLbl, *m_taskStatusLbl, *m_failedStepsLbl,
      *m_successfullStepsLbl, *m_stepCountLbl, *m_dependenciesLbl;
 
  TTextList *m_dependencies;
 
  TScrollbar *m_scrollVBar, *m_scrollHBar;
};
 
//------------------------------------------------------------------------------
 
TaskStatusPage::Data::Data(TaskStatusPage *parent) {
  m_tree                = new TaskTree(parent, "taskTree");
  m_taskId              = new TTextField(parent, "taskId");
  m_cmdLine             = new TTextField(parent, "cmdLine");
  m_server              = new TTextField(parent, "server");
  m_byUser              = new TTextField(parent, "byUser");
  m_onMachine           = new TTextField(parent, "onMachine");
  m_priority            = new TTextField(parent, "priority");
  m_submissionDate      = new TTextField(parent, "submissionDate");
  m_startDate           = new TTextField(parent, "startDate");
  m_completionDate      = new TTextField(parent, "completionDate");
  m_taskStatus          = new TTextField(parent, "taskStatus");
  m_stepCount           = new TTextField(parent, "stepCount");
  m_failedSteps         = new TTextField(parent, "failedSteps");
  m_successfullSteps    = new TTextField(parent, "successfullSteps");
  m_dependencies        = new TTextList(parent);
  m_taskIdLbl           = new TLabel(parent, "task id");
  m_cmdLineLbl          = new TLabel(parent, "command line");
  m_serverLbl           = new TLabel(parent, "server");
  m_byUserLbl           = new TLabel(parent, "submitted by");
  m_onMachineLbl        = new TLabel(parent, "submitted on");
  m_priorityLbl         = new TLabel(parent, "priority");
  m_submissionDateLbl   = new TLabel(parent, "submission date");
  m_startDateLbl        = new TLabel(parent, "start date");
  m_completionDateLbl   = new TLabel(parent, "completion date");
  m_stepCountLbl        = new TLabel(parent, "step count");
  m_failedStepsLbl      = new TLabel(parent, "failed steps");
  m_successfullStepsLbl = new TLabel(parent, "successfull steps");
  m_dependenciesLbl     = new TLabel(parent, "dependencies");
  m_taskStatusLbl       = new TLabel(parent, "status");
  m_scrollVBar          = new TScrollbar(parent, "vscroll");
  m_scrollHBar          = new TScrollbar(parent, "hscroll");
  m_tree->setScrollbars(m_scrollHBar, m_scrollVBar);
}
 
//------------------------------------------------------------------------------
 
void TaskStatusPage::Data::showTaskInfo(const TFarmTask &task) {
  switch (task.m_status) {
  case Waiting:
    m_taskStatus->setText("Waiting");
    break;
  case Running:
    m_taskStatus->setText("Running");
    break;
  case Completed:
    m_taskStatus->setText("Completed");
    break;
  case Aborted:
    m_taskStatus->setText("Failed");
    break;
  case TaskUnknown:
    clearFields();
    return;
  }
  m_taskId->setText(task.m_id);
  m_cmdLine->setText(task.m_cmdline);
  m_server->setText(task.m_server);
  m_byUser->setText(task.m_user);
  m_onMachine->setText(task.m_hostName);
  m_priority->setText(toString(task.m_priority));
  m_submissionDate->setText(task.m_submissionDate);
  m_startDate->setText(task.m_startDate);
  m_completionDate->setText(task.m_completionDate);
  m_stepCount->setText(toString(task.m_stepCount));
  m_failedSteps->setText(toString(task.m_failedSteps));
  m_successfullSteps->setText(toString(task.m_successfullSteps));
  m_dependencies->clearAll();
  if (task.m_dependencies) {
    int count = task.m_dependencies->getTaskCount(), i = 0;
    TFarmController *controller = Application::instance()->getController();
    for (; i < count; ++i) {
      string id, parentId, name;
      TaskState status;
      id = task.m_dependencies->getTaskId(i);
      try {
        controller->queryTaskShortInfo(id, parentId, name, status);
      } catch (TException &e) {
        TMessage::error(toString(e.getMessage()));
      }
      string label = "<" + id + "> " + name;
      m_dependencies->addItem(new TTextListItem(id, label));
    }
  }
  m_dependencies->invalidate();
}
 
//------------------------------------------------------------------------------
 
void TaskStatusPage::Data::configureNotify(const TDimension &size) {
  const int dx       = 10;
  const int dy       = 5;
  const int h        = 20;
  const int lw       = 120;
  const int leftSize = tmin(250, size.lx / 3);
 
  const int w = size.lx - leftSize - lw - dx * 3;
  int left    = leftSize + dx;
  int y0      = size.ly - 30;
  int x0;
 
  // prima la parte a sx
  const int scbSize = 15;
  TRect rect        = TRect(0, 0, leftSize, size.ly);
  int x             = leftSize;
  m_tree->setGeometry(rect.x0, rect.y0 + scbSize, x - 1 - scbSize, rect.y1);
  m_scrollVBar->setGeometry(x - scbSize, rect.y0 + scbSize, x - 1, rect.y1);
  m_scrollHBar->setGeometry(rect.x0, rect.y0, x - 1 - scbSize,
                            rect.y0 + scbSize - 1);
 
  // ora la parte a dx
  x0 = left;
  m_taskIdLbl->setGeometry(x0, y0, x0 + lw, y0 + h);
  x0 += lw + dx;
  m_taskId->setGeometry(x0, y0, x0 + w, y0 + h);
 
  x0 = left;
  y0 -= h + dy;
  m_taskStatusLbl->setGeometry(x0, y0, x0 + lw, y0 + h);
  x0 += lw + dx;
  m_taskStatus->setGeometry(x0, y0, x0 + w, y0 + h);
 
  x0 = left;
  y0 -= h + dy;
  m_cmdLineLbl->setGeometry(x0, y0, x0 + lw, y0 + h);
  x0 += lw + dx;
  m_cmdLine->setGeometry(x0, y0, x0 + w, y0 + h);
 
  x0 = left;
  y0 -= h + dy;
  m_serverLbl->setGeometry(x0, y0, x0 + lw, y0 + h);
  x0 += lw + dx;
  m_server->setGeometry(x0, y0, x0 + w, y0 + h);
 
  x0 = left;
  y0 -= h + dy;
  m_byUserLbl->setGeometry(x0, y0, x0 + lw, y0 + h);
  x0 += lw + dx;
  m_byUser->setGeometry(x0, y0, x0 + w, y0 + h);
 
  x0 = left;
  y0 -= h + dy;
  m_onMachineLbl->setGeometry(x0, y0, x0 + lw, y0 + h);
  x0 += lw + dx;
  m_onMachine->setGeometry(x0, y0, x0 + w, y0 + h);
 
  x0 = left;
  y0 -= h + dy;
  m_priorityLbl->setGeometry(x0, y0, x0 + lw, y0 + h);
  x0 += lw + dx;
  m_priority->setGeometry(x0, y0, x0 + w, y0 + h);
 
  x0 = left;
  y0 -= h + dy;
  m_submissionDateLbl->setGeometry(x0, y0, x0 + lw, y0 + h);
  x0 += lw + dx;
  m_submissionDate->setGeometry(x0, y0, x0 + w, y0 + h);
 
  x0 = left;
  y0 -= h + dy;
  m_startDateLbl->setGeometry(x0, y0, x0 + lw, y0 + h);
  x0 += lw + dx;
  m_startDate->setGeometry(x0, y0, x0 + w, y0 + h);
 
  x0 = left;
  y0 -= h + dy;
  m_completionDateLbl->setGeometry(x0, y0, x0 + lw, y0 + h);
  x0 += lw + dx;
  m_completionDate->setGeometry(x0, y0, x0 + w, y0 + h);
 
  x0 = left;
  y0 -= h + dy;
  m_stepCountLbl->setGeometry(x0, y0, x0 + lw, y0 + h);
  x0 += lw + dx;
  m_stepCount->setGeometry(x0, y0, x0 + w, y0 + h);
 
  x0 = left;
  y0 -= h + dy;
  m_failedStepsLbl->setGeometry(x0, y0, x0 + lw, y0 + h);
  x0 += lw + dx;
  m_failedSteps->setGeometry(x0, y0, x0 + w, y0 + h);
 
  x0 = left;
  y0 -= h + dy;
  m_successfullStepsLbl->setGeometry(x0, y0, x0 + lw, y0 + h);
  x0 += lw + dx;
  m_successfullSteps->setGeometry(x0, y0, x0 + w, y0 + h);
 
  x0 = left;
  y0 -= h + dy;
  m_dependenciesLbl->setGeometry(x0, y0, x0 + lw, y0 + h);
  x0 += lw + dx;
  m_dependencies->setGeometry(x0, y0 - 3 * h, x0 + w, y0 + h);
}
 
//------------------------------------------------------------------------------
 
void TaskStatusPage::Data::clearFields() {
  m_taskStatus->setText("");
  m_taskId->setText("");
  m_cmdLine->setText("");
  m_server->setText("");
  m_byUser->setText("");
  m_onMachine->setText("");
  m_priority->setText("");
  m_submissionDate->setText("");
  m_startDate->setText("");
  m_completionDate->setText("");
  m_stepCount->setText("");
  m_failedSteps->setText("");
  m_successfullSteps->setText("");
  m_dependencies->clearAll();
}
 
//==============================================================================
 
TaskStatusPage::TaskStatusPage(TWidget *parent) : TabPage(parent, "Tasks") {
  m_data = new Data(this);
}
 
//------------------------------------------------------------------------------
 
TaskStatusPage::~TaskStatusPage() {}
 
//------------------------------------------------------------------------------
 
void TaskStatusPage::configureNotify(const TDimension &size) {
  m_data->configureNotify(size);
}
 
//------------------------------------------------------------------------------
 
void TaskStatusPage::rightButtonDown(const TMouseEvent &e) {}
 
//------------------------------------------------------------------------------
 
void TaskStatusPage::onActivate() {
  if (m_data->m_tree && m_data->m_tree->getItemCount() < 1) {
    TaskTreeItemRoot *root = new TaskTreeItemRoot();
    root->setIsLeaf(false);
    m_data->m_tree->clearItems();
    m_data->m_tree->addItem(root);
  }
  m_data->m_tree->update();
  invalidate();
}
 
//------------------------------------------------------------------------------
 
void TaskStatusPage::onDeactivate() {}
 
//------------------------------------------------------------------------------
 
void TaskStatusPage::showTaskInfo(const string &id) {
  TFarmController *controller = Application::instance()->getController();
  try {
    TFarmTask task;
    controller->queryTaskInfo(id, task);
 
    if (task != m_data->m_currTask) {
      m_data->m_currTask = task;
      m_data->showTaskInfo(task);
    }
  } catch (TException &e) {
    TMessage::error(toString(e.getMessage()));
  }
}
 
//------------------------------------------------------------------------------
 
void TaskStatusPage::update() {
  m_data->m_tree->update();
 
  string id = "";
  TaskTreeItem *item =
      dynamic_cast<TaskTreeItem *>(m_data->m_tree->getSelectedItem());
  if (item) id = item->getId();
 
  if (id != "")
    showTaskInfo(id);
  else
    m_data->clearFields();
  invalidate();
}
 
//------------------------------------------------------------------------------