#include "serverstatuspage.h"

#include "tfarmcontroller.h"

#include "application.h"

#include "textlist.h"

#include "tw/mainshell.h"

#include "tw/textfield.h"

#include "tw/event.h"

#include "tw/message.h"

#include <vector></vector>

#include <set></set>

using namespace std;

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

class ServerList : public TTextList {

public:

  ServerList(TWidget *parent);

  void rightButtonDown(const TMouseEvent &e);

  void onDeactivate();

  void onActivate();

  TPopupMenuItem *m_activationItem;

  TPopupMenu *m_popupMenu;

};

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

ServerList::ServerList(TWidget *parent) : TTextList(parent, "servers") {

  m_popupMenu = new TPopupMenu(this);

  TPopupMenuItem *item = new TPopupMenuItem(m_popupMenu, "deactivate");

  TGuiCommand("deactivate")

      .setAction(new TCommandAction<serverlist>(this, onDeactivate));</serverlist>

  TGuiCommand("deactivate").add(item);

  item = new TPopupMenuItem(m_popupMenu, "activate");

  TGuiCommand("activate")

      .setAction(new TCommandAction<serverlist>(this, onActivate));</serverlist>

  TGuiCommand("activate").add(item);

}

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

void ServerList::rightButtonDown(const TMouseEvent &e) {

  leftButtonDown(e);

  TTextListItem *item = getSelectedItem(0);

  if (item) {

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

    ServerState state;

    try {

      state = controller->queryServerState2(item->getId());

    } catch (TException &e) {

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

      return;

    }

    if (state != Offline) {

      TGuiCommand("activate").disable();

      TGuiCommand("deactivate").enable();

    } else {

      TGuiCommand("activate").enable();

      TGuiCommand("deactivate").disable();

    }

    TPoint pos =

        getAbsolutePosition() + TPoint(e.m_pos.x, getSize().ly - e.m_pos.y);

    m_popupMenu->popup(pos);

  }

}

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

void ServerList::onDeactivate() {

  TTextListItem *item = getSelectedItem(0);

  if (item) {

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

    try {

      controller->deactivateServer(item->getId());

    } catch (TException &e) {

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

    }

  }

}

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

void ServerList::onActivate() {

  TTextListItem *item = getSelectedItem(0);

  if (item) {

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

    try {

      controller->activateServer(item->getId());

    } catch (TException &e) {

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

    }

  }

}

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

class ServerStatusPage::Data {

public:

  Data(ServerStatusPage *parent) {

    m_serverList = new ServerList(parent);

    m_serverList->setSelAction(

        new TTextListAction<data>(this, &Data::onServerSelection));</data>

    m_name       = new TTextField(parent, "name");

    m_ipAddress  = new TTextField(parent, "ipAddress");

    m_portNumber = new TTextField(parent, "portNumber");

    m_tasks      = new TTextField(parent, "tasks");

    m_state      = new TTextField(parent, "state");

    m_cpuCount   = new TTextField(parent, "cpuCount");

    m_totPhysMem = new TTextField(parent, "totalPhysMemory");

    m_nameLbl       = new TLabel(parent, "name");

    m_ipAddressLbl  = new TLabel(parent, "ipAddress");

    m_portNumberLbl = new TLabel(parent, "portNumber");

    m_tasksLbl      = new TLabel(parent, "tasks");

    m_stateLbl      = new TLabel(parent, "state");

    m_cpuCountLbl   = new TLabel(parent, "cpuCount");

    m_totPhysMemLbl = new TLabel(parent, "totalPhysMemory");

  }

  ~Data() {}

  void onServerSelection(int index) {

    TTextListItem *item = m_serverList->getSelectedItem(0);

    if (item) {

      showServerInfo(item->getId());

    }

  }

  void showServerInfo(const string &id) {

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

    ServerInfo info;

    try {

      controller->queryServerInfo(id, info);

    } catch (TException &e) {

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

    }

    switch (info.m_state) {

    case Ready:

      m_state->setText("Ready");

      break;

    case Busy:

      m_state->setText("Busy");

      break;

    case NotResponding:

      m_state->setText("Not Responding");

      break;

    case Down:

      m_state->setText("Down");

      break;

    case Offline:

      m_state->setText("Offline");

      break;

    case ServerUnknown:

      m_state->setText("");

      m_name->setText("");

      m_ipAddress->setText("");

      m_portNumber->setText("");

      m_tasks->setText("");

      m_cpuCount->setText("");

      m_totPhysMem->setText("");

      return;

    }

    m_name->setText(info.m_name);

    m_ipAddress->setText(info.m_ipAddress);

    m_portNumber->setText(info.m_portNumber);

    if (info.m_currentTaskId == "")

      m_tasks->setText("");

    else {

      TFarmTask task;

      try {

        controller->queryTaskInfo(info.m_currentTaskId, task);

        m_tasks->setText("<" + task.m_id + "> " + task.m_name);

      } catch (TException &e) {

        m_tasks->setText("");

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

      }

    }

    if (info.m_state != Down) {

      m_cpuCount->setText(toString(info.m_cpuCount));

      m_totPhysMem->setText(toString((long)info.m_totPhysMem));

    } else {

      m_cpuCount->setText("");

      m_totPhysMem->setText("");

    }

  }

  void addServer(const ServerIdentity &sid) {

    m_serverList->addItem(new TTextListItem(sid.m_id, sid.m_name));

  }

  void 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

    m_serverList->setGeometry(0, 0, leftSize /*100*/, size.ly - 1);

    // ora la parte a dx

    x0 = left;

    m_nameLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

    x0 += lw + dx;

    m_name->setGeometry(x0, y0, x0 + w, y0 + h);

    x0 = left;

    y0 -= h + dy;

    m_ipAddressLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

    x0 += lw + dx;

    m_ipAddress->setGeometry(x0, y0, x0 + w, y0 + h);

    x0 = left;

    y0 -= h + dy;

    m_portNumberLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

    x0 += lw + dx;

    m_portNumber->setGeometry(x0, y0, x0 + w, y0 + h);

    x0 = left;

    y0 -= h + dy;

    m_tasksLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

    x0 += lw + dx;

    m_tasks->setGeometry(x0, y0, x0 + w, y0 + h);

    x0 = left;

    y0 -= h + dy;

    m_stateLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

    x0 += lw + dx;

    m_state->setGeometry(x0, y0, x0 + w, y0 + h);

    x0 = left;

    y0 -= h + dy;

    m_cpuCountLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

    x0 += lw + dx;

    m_cpuCount->setGeometry(x0, y0, x0 + w, y0 + h);

    x0 = left;

    y0 -= h + dy;

    m_totPhysMemLbl->setGeometry(x0, y0, x0 + lw, y0 + h);

    x0 += lw + dx;

    m_totPhysMem->setGeometry(x0, y0, x0 + w, y0 + h);

  }

  TTextList *m_serverList;

  TTextField *m_name, *m_ipAddress, *m_portNumber, *m_tasks, *m_state,

      *m_cpuCount, *m_totPhysMem;

  TLabel *m_nameLbl, *m_ipAddressLbl, *m_portNumberLbl, *m_tasksLbl,

      *m_stateLbl, *m_cpuCountLbl, *m_totPhysMemLbl;

};

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

void ServerStatusPage::onActivate() {

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

  try {

    vector<serveridentity> servers;</serveridentity>

    controller->getServers(servers);

    vector<serveridentity>::iterator it = servers.begin();</serveridentity>

    for (; it != servers.end(); ++it) m_data->addServer(*it);

  } catch (TException &e) {

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

  }

}

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

void ServerStatusPage::onDeactivate() {}

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

ServerStatusPage::ServerStatusPage(TWidget *parent)

    : TabPage(parent, "Servers") {

  m_data = new Data(this);

}

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

ServerStatusPage::~ServerStatusPage() {}

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

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

  m_data->configureNotify(size);

}

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

void ServerStatusPage::update() {

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

  vector<serveridentity> servers;</serveridentity>

  try {

    controller->getServers(servers);

  } catch (TException &e) {

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

    return;

  }

  vector<serveridentity>::iterator it = servers.begin();</serveridentity>

  vector<serveridentity> newServers;</serveridentity>

  std::set<int> oldServers;</int>

  TTextList *sl = m_data->m_serverList;

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

    int index;

    if ((index = sl->itemToIndex(it->m_id)) == -1)

      newServers.push_back(*it);

    else

      oldServers.insert(index);

  }

  int i = 0, count = sl->getItemCount();

  for (; i < count; ++i)

    if (oldServers.find(i) == oldServers.end()) {

      string itemId = sl->getItem(i)->getId();

      /*

if(sl->isSelected(itemId))

sl->select((i+1)%sl->getItemCount(), true);

*/

      sl->removeItem(itemId);

    }

  it = newServers.begin();

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

    sl->addItem(new TTextListItem(it->m_id, it->m_name));

  TTextListItem *item = m_data->m_serverList->getSelectedItem(0);

  if (item) m_data->showServerInfo(item->getId());

  invalidate();

}