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

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