/*
 * CommandManager.cpp
 *
 * Copyright (C) 2008 Matthias Schiffer <matthias@gamezock.de>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include "CommandManager.h"
#include <Common/HostInfo.h>
#include <Common/Logger.h>
#include <Net/Packets/FSInfoPacket.h>
#include <Net/Packets/HostListPacket.h>
#include <Net/Packets/HostStatusPacket.h>
#include <Net/Packets/UserListPacket.h>

#include <cmath>
#include <iostream>
#include <vector>


namespace Mad {
namespace Client {

CommandManager CommandManager::commandManager;


void CommandManager::printFSInfo(const Net::Packets::FSInfoPacket &packet) {
  const std::string units[] = {
      "kB", "MB", "GB", "TB", ""
  };

  const std::vector<Common::SystemBackend::FSInfo>& fsList = packet.getFSInfo();

  for(std::vector<Common::SystemBackend::FSInfo>::const_iterator fs = fsList.begin(); fs != fsList.end(); ++fs) {
    unsigned usedUnit = 0, totalUnit = 0;

    float used = fs->used;
    float total = fs->total;
    float available = fs->available;

    while(used >= 1024 && !units[usedUnit+1].empty()) {
      ++usedUnit;
      used /= 1024;
      available /= 1024;
    }

    while(total >= 1024 && !units[totalUnit+1].empty()) {
      ++totalUnit;
      total /= 1024;
    }

    std::string nameString = fs->mountedOn + " (" + fs->fsName + ")";

    if(nameString.length() < 32) {
      nameString.resize(32, ' ');
    }
    else {
      nameString += '\n';
      nameString.resize(nameString.length() + 32, ' ');
    }

    std::printf("\t%s%.*f%s", nameString.c_str(), (used < 10) ? 2 : 1, used, (usedUnit == totalUnit) ? "" : (" " + units[usedUnit]).c_str());
    std::printf("/%.*f %s (%.1f%%)\n", (total < 10) ? 2 : 1, total, units[totalUnit].c_str(), std::min(100*used/(used+available), 100.0f));
  }

  std::printf("\n");
}

void CommandManager::printHostStatus(const Net::Packets::HostStatusPacket &packet) {
  if(packet.getUptime()) {
    unsigned long days = packet.getUptime()/86400;
    unsigned long hours = (packet.getUptime()%86400)/3600;
    unsigned long minutes = (packet.getUptime()%3600)/60;

    std::printf("\tUptime:\t\t");

    if(days) std::printf("%lu days ", days);

    std::printf("%lu:%02lu", hours, minutes);

    std::printf(" (load average: %.2f %.2f %.2f, %lu processes)", packet.getLoadAverage1(), packet.getLoadAverage5(), packet.getLoadAverage15(), (unsigned long)packet.getProcessNumber());

    std::printf("\n\n");
  }

  if(packet.getTotalMem() && packet.getFreeMem()) {
    const std::string units[] = {
        "kB", "MB", "GB", "TB", ""
    };

    unsigned unit = 0;
    float totalMem = packet.getTotalMem(), usedMem = packet.getTotalMem()-packet.getFreeMem();

    while(totalMem >= 1024 && !units[unit+1].empty()) {
      ++unit;
      totalMem /= 1024;
      usedMem /= 1024;
    }

    std::printf("\tMemory usage:\t%.*f/%.*f %s", (usedMem < 10) ? 2 : 1, usedMem, (totalMem < 10) ? 2 : 1, totalMem, units[unit].c_str());
    std::printf(" (%.1f%%)\n", usedMem*100.0f/totalMem);

    if(packet.getTotalSwap() && packet.getFreeSwap()) {
      unit = 0;
      totalMem = packet.getTotalSwap(); usedMem = packet.getTotalSwap()-packet.getFreeSwap();

      while(totalMem >= 1024 && !units[unit+1].empty()) {
        ++unit;
        totalMem /= 1024;
        usedMem /= 1024;
      }

      std::printf("\tSwap usage:\t%.*f/%.*f %s", (usedMem < 10) ? 2 : 1, usedMem, (totalMem < 10) ? 2 : 1, totalMem, units[unit].c_str());
      std::printf(" (%.1f%%)\n", usedMem*100.0f/totalMem);
    }

    std::printf("\n");
  }
}


void CommandManager::daemonCommandRequestFinished(const Common::Request<> &request) {
  try {
    request.getResult();
  }
  catch(Common::Exception &exception) {
    Common::Logger::logf(Common::Logger::ERROR, "An error occurred during your request: %s.", exception.strerror().c_str());
  }

  requestFinished();
}

void CommandManager::daemonFSInfoRequestFinished(const Common::Request<Net::Packets::FSInfoPacket> &request) {
  try {
    const Net::Packets::FSInfoPacket &packet = request.getResult();
    std::cout << "Host file system usage:" << std::endl;
    printFSInfo(packet);
  }
  catch(Common::Exception &exception) {
    Common::Logger::logf(Common::Logger::ERROR, "An error occurred during your request: %s.", exception.strerror().c_str());
  }

  requestFinished();
}

void CommandManager::daemonStatusRequestFinished(const Common::Request<Net::Packets::HostStatusPacket> &request) {
  try {
    const Net::Packets::HostStatusPacket &packet = request.getResult();
    std::cout << "Host status:" << std::endl;
    printHostStatus(packet);
  }
  catch(Common::Exception &exception) {
    Common::Logger::logf(Common::Logger::ERROR, "An error occurred during your request: %s.", exception.strerror().c_str());
  }

  requestFinished();
}

void CommandManager::disconnectRequestFinished(const Common::Request<> &request) {
  try {
    request.getResult();
    disconnect = true;
  }
  catch(Common::Exception &exception) {
    Common::Logger::logf(Common::Logger::ERROR, "An error occurred during your request: %s.", exception.strerror().c_str());
  }

  requestFinished();
}

void CommandManager::fsInfoRequestFinished(const Common::Request<Net::Packets::FSInfoPacket> &request) {
  try {
    const Net::Packets::FSInfoPacket &packet = request.getResult();
    std::cout << "Server file system usage:" << std::endl;
    printFSInfo(packet);
  }
  catch(Common::Exception &exception) {
    Common::Logger::logf(Common::Logger::ERROR, "An error occurred during your request: %s.", exception.strerror().c_str());
  }

  requestFinished();
}

void CommandManager::statusRequestFinished(const Common::Request<Net::Packets::HostStatusPacket> &request) {
  try {
    const Net::Packets::HostStatusPacket &packet = request.getResult();
    std::cout << "Server status:" << std::endl;
    printHostStatus(packet);
  }
  catch(Common::Exception &exception) {
    Common::Logger::logf(Common::Logger::ERROR, "An error occurred during your request: %s.", exception.strerror().c_str());
  }

  requestFinished();
}

void CommandManager::userListRequestFinished(const Common::Request<Net::Packets::UserListPacket> &request) {
  try {
      const Net::Packets::UserListPacket &packet = request.getResult();

      const std::vector<Common::UserInfo> &users = packet.getUserInfo();

      if(users.empty()) {
        std::cout << "User list is empty." << std::endl;
      }
      else {
        std::cout << "Found " << packet.getUserInfo().size() << " users:" << std::endl;

        for(std::vector<Common::UserInfo>::const_iterator user = users.begin(); user != users.end(); ++user)
          std::cout << "  " << user->getUid() << ", " << user->getGid() << ", " << user->getUsername() << ", " << user->getFullName() << std::endl;
      }

      std::cout << std::endl;
    }
    catch(Common::Exception &exception) {
      Common::Logger::logf(Common::Logger::ERROR, "An error occurred during your request: %s.", exception.strerror().c_str());
    }

    requestFinished();
}

}
}