#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>
#include <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));
  TGuiCommand("deactivate").add(item);

  item = new TPopupMenuItem(m_popupMenu, "activate");
  TGuiCommand("activate")
      .setAction(new TCommandAction<ServerList>(this, onActivate));
  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));
    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;
    controller->getServers(servers);
    vector<ServerIdentity>::iterator it = servers.begin();
    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;
  try {
    controller->getServers(servers);
  } catch (TException &e) {
    TMessage::error(toString(e.getMessage()));
    return;
  }

  vector<ServerIdentity>::iterator it = servers.begin();
  vector<ServerIdentity> newServers;
  std::set<int> oldServers;
  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();
}