/*
 * UserCommands.cpp
 *
 * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include "UserCommands.h"
#include "Application.h"
#include "CommandParser.h"
#include "ConsoleUtil.h"

#include <Common/RequestManager.h>
#include <Common/UserManager.h>

#include <iostream>


namespace Mad {
namespace Client {

Core::String UserCommands::getUserName(CommandParser *commandParser, unsigned long uid, bool withId) {
  std::ostringstream stream;

  try {
    stream << commandParser->application->getUserManager()->getUserInfo(uid)->getUsername();
  }
  catch(...) {
    stream << uid;
  }

  if(withId) {
    stream << " (";
    stream << uid;
    stream << ")";
  }

  return stream.str().c_str();
}

Core::String UserCommands::getGroupName(CommandParser *commandParser, unsigned long gid, bool withId) {
  std::ostringstream stream;

  try {
    stream << commandParser->application->getUserManager()->getGroupInfo(gid)->getName();
  }
  catch(...) {
    stream << gid;
  }

  if(withId) {
    stream << " (";
    stream << gid;
    stream << ")";
  }

  return stream.str().c_str();
}

void UserCommands::listUsersCommand(CommandParser *commandParser, const std::vector<Core::String> &/*args*/) {
  try {
    boost::shared_ptr<const std::map<unsigned long, Common::UserInfo> > users = commandParser->application->getUserManager()->getUserList();

    if(users->empty()) {
      std::cout << "The user list is empty." << std::endl;
    }
    else {
      std::cout << "Found " << users->size() << " user" << (users->size()==1 ? "" : "s") << ":" << std::endl;

      for(std::map<unsigned long, Common::UserInfo>::const_iterator user = users->begin(); user != users->end(); ++user) {
        std::cout << "  " << user->second.getUsername() << ":"
                  << getGroupName(commandParser, user->second.getGid(), false) <<  " ("
                  << user->second.getFullName() << ")" << std::endl;
      }
    }

    std::cout << std::endl;
  }
  catch(Core::Exception e) {
    std::cerr << "An error occurred during your request: " << e.what() << "." << std::endl;
  }
}

void UserCommands::userInfoCommand(CommandParser *commandParser, const std::vector<Core::String> &args) {
  if(args.size() == 1) {
    std::cerr << args[0] << ": No user id given." << std::endl;
    commandParser->printUsage("user_info");
    return;
  }
  if(args.size() > 2) {
    std::cerr << args[0] << ": Too many arguments." << std::endl;
    commandParser->printUsage("user_info");
    return;
  }

  try {
    char *endptr;
    unsigned long uid = std::strtoul(args[1].toString().c_str(), &endptr, 10);

    boost::shared_ptr<const Common::UserInfo> userInfo;

    if(args[1].isEmpty() || *endptr != '\0') {
      userInfo = commandParser->application->getUserManager()->getUserInfoByName(args[1]);
    }
    else
      userInfo = commandParser->application->getUserManager()->getUserInfo(uid);

    std::cout << "  User name: " << userInfo->getUsername() << " (" << userInfo->getUid() << ")" << std::endl;
    std::cout << "  Group: " << getGroupName(commandParser, userInfo->getGid(), true) << std::endl;
    std::cout << "  Full name: " << userInfo->getFullName() << std::endl << std::endl;

    boost::shared_ptr<const std::set<unsigned long> > groups = commandParser->application->getUserManager()->getUserGroupList(userInfo->getUid());

    if(!groups->empty()) {
      std::cout << "  The user is member of " << groups->size() << " group" << (groups->size()==1 ? "" : "s") << ":" << std::endl;
      for(std::set<unsigned long>::const_iterator group = groups->begin(); group != groups->end(); ++group)
        std::cout << "    " << getGroupName(commandParser, *group, true) << std::endl;

      std::cout << std::endl;
    }
  }
  catch(Core::Exception e) {
    std::cerr << "An error occurred during your request: " << e.what() << "." << std::endl;
  }
}

void UserCommands::listGroupsCommand(CommandParser *commandParser, const std::vector<Core::String> &/*args*/) {
  try {
    boost::shared_ptr<const std::map<unsigned long, Common::GroupInfo> > groups = commandParser->application->getUserManager()->getGroupList();

    if(groups->empty()) {
      std::cout << "The group list is empty." << std::endl;
    }
    else {
      std::cout << "Found " << groups->size() << " group" << (groups->size()==1 ? "" : "s") << ":" << std::endl;

      for(std::map<unsigned long, Common::GroupInfo>::const_iterator group = groups->begin(); group != groups->end(); ++group) {
        std::cout << "  " << group->second.getName() << " (" << group->second.getGid() << ")" << std::endl;
      }
    }

    std::cout << std::endl;
  }
  catch(Core::Exception e) {
    std::cerr << "An error occurred during your request: " << e.what() << "." << std::endl;
  }
}

void UserCommands::groupInfoCommand(CommandParser *commandParser, const std::vector<Core::String> &args) {
  if(args.size() == 1) {
    std::cerr << args[0] << ": No group id given." << std::endl;
    commandParser->printUsage("group_info");
    return;
  }
  if(args.size() > 2) {
    std::cerr << args[0] << ": Too many arguments." << std::endl;
    commandParser->printUsage("group_info");
    return;
  }

  try {
    char *endptr;
    unsigned long gid = std::strtoul(args[1].toString().c_str(), &endptr, 10);

    boost::shared_ptr<const Common::GroupInfo> groupInfo;

    if(args[1].isEmpty() || *endptr != '\0') {
      groupInfo = commandParser->application->getUserManager()->getGroupInfoByName(args[1]);
    }
    else
      groupInfo = commandParser->application->getUserManager()->getGroupInfo(gid);

    std::cout << "  Group name: " << groupInfo->getName() << " (" << groupInfo->getGid() << ")" << std::endl << std::endl;

    boost::shared_ptr<const std::set<unsigned long> > users = commandParser->application->getUserManager()->getGroupUserList(groupInfo->getGid());

    if(!users->empty()) {
      std::cout << "  The group has " << users->size() << " member" << (users->size()==1 ? "" : "s") << ":" << std::endl;


      for(std::set<unsigned long>::const_iterator user = users->begin(); user != users->end(); ++user)
        std::cout << "    " << getUserName(commandParser, *user, true) << std::endl;

      std::cout << std::endl;
    }
  }
  catch(Core::Exception e) {
    std::cerr << "An error occurred during your request: " << e.what() << "." << std::endl;
  }
}

void UserCommands::addUserCommand(CommandParser *commandParser, const std::vector<Core::String> &args) {
  if(args.size() < 5) {
    std::cerr << args[0] << ": Too few arguments." << std::endl;
    commandParser->printUsage("add_user");
    return;
  }
  if(args.size() > 5) {
    std::cerr << args[0] << ": Too many arguments." << std::endl;
    commandParser->printUsage("add_user");
    return;
  }

  char *endptr;
  unsigned long uid = std::strtoul(args[1].toString().c_str(), &endptr, 10);
  if(args[1].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse user id." << std::endl;
    commandParser->printUsage("add_user");
    return;
  }

  unsigned long gid = std::strtoul(args[2].toString().c_str(), &endptr, 10);
  if(args[2].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse group id." << std::endl;
    commandParser->printUsage("add_user");
    return;
  }

  try {
    Common::UserInfo user(uid, args[3]);
    user.setGid(gid);
    user.setFullName(args[4]);

    commandParser->application->getUserManager()->addUser(user);

    std::cout << "User added." << std::endl;
  }
  catch(Core::Exception e) {
    std::cerr << "An error occurred during your request: " << e.what() << "." << std::endl;
  }
}

void UserCommands::updateUserCommand(CommandParser *commandParser, const std::vector<Core::String> &args) {
  if(args.size() < 6) {
    std::cerr << args[0] << ": Too few arguments." << std::endl;
    commandParser->printUsage("update_user");
    return;
  }
  if(args.size() > 6) {
    std::cerr << args[0] << ": Too many arguments." << std::endl;
    commandParser->printUsage("update_user");
    return;
  }

  char *endptr;
  unsigned long origUid = std::strtoul(args[1].toString().c_str(), &endptr, 10);
  if(args[1].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse the old user id." << std::endl;
    commandParser->printUsage("update_user");
    return;
  }

  unsigned long uid = std::strtoul(args[2].toString().c_str(), &endptr, 10);
  if(args[2].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse the new user id." << std::endl;
    commandParser->printUsage("update_user");
    return;
  }

  unsigned long gid = std::strtoul(args[3].toString().c_str(), &endptr, 10);
  if(args[3].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse group id." << std::endl;
    commandParser->printUsage("update_user");
    return;
  }

  try {
    Common::UserInfo user(uid, args[4]);
    user.setGid(gid);
    user.setFullName(args[5]);

    commandParser->application->getUserManager()->updateUser(origUid, user);

    std::cout << "User updated." << std::endl;
  }
  catch(Core::Exception e) {
    std::cerr << "An error occurred during your request: " << e.what() << "." << std::endl;
  }
}

void UserCommands::deleteUserCommand(CommandParser *commandParser, const std::vector<Core::String> &args) {
  if(args.size() < 2) {
    std::cerr << args[0] << ": No user id given." << std::endl;
    commandParser->printUsage("delete_user");
    return;
  }
  if(args.size() > 2) {
    std::cerr << args[0] << ": Too many arguments." << std::endl;
    commandParser->printUsage("delete_user");
    return;
  }

  char *endptr;
  unsigned long uid = std::strtoul(args[1].toString().c_str(), &endptr, 10);
  if(args[1].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse user id." << std::endl;
    commandParser->printUsage("delete_user");
    return;
  }

  try {
    commandParser->application->getUserManager()->deleteUser(uid);

    std::cout << "User deleted." << std::endl;
  }
  catch(Core::Exception e) {
    std::cerr << "An error occurred during your request: " << e.what() << "." << std::endl;
  }
}

void UserCommands::addGroupCommand(CommandParser *commandParser, const std::vector<Core::String> &args) {
  if(args.size() < 3) {
    std::cerr << args[0] << ": Too few arguments." << std::endl;
    commandParser->printUsage("add_group");
    return;
  }
  if(args.size() > 3) {
    std::cerr << args[0] << ": Too many arguments." << std::endl;
    commandParser->printUsage("add_group");
    return;
  }

  char *endptr;
  unsigned long gid = std::strtoul(args[1].toString().c_str(), &endptr, 10);
  if(args[2].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse group id." << std::endl;
    commandParser->printUsage("add_group");
    return;
  }

  try {
    commandParser->application->getUserManager()->addGroup(Common::GroupInfo(gid, args[2]));

    std::cout << "Group added." << std::endl;
  }
  catch(Core::Exception e) {
    std::cerr << "An error occurred during your request: " << e.what() << "." << std::endl;
  }
}

void UserCommands::updateGroupCommand(CommandParser *commandParser, const std::vector<Core::String> &args) {
  if(args.size() < 4) {
    std::cerr << args[0] << ": Too few arguments." << std::endl;
    commandParser->printUsage("update_group");
    return;
  }
  if(args.size() > 4) {
    std::cerr << args[0] << ": Too many arguments." << std::endl;
    commandParser->printUsage("update_group");
    return;
  }

  char *endptr;
  unsigned long origGid = std::strtoul(args[1].toString().c_str(), &endptr, 10);
  if(args[1].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse the old group id." << std::endl;
    commandParser->printUsage("update_group");
    return;
  }

  unsigned long gid = std::strtoul(args[2].toString().c_str(), &endptr, 10);
  if(args[2].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse the new group id." << std::endl;
    commandParser->printUsage("update_group");
    return;
  }

  try {
    commandParser->application->getUserManager()->updateGroup(origGid, Common::GroupInfo(gid, args[3]));

    std::cout << "Group updated." << std::endl;
  }
  catch(Core::Exception e) {
    std::cerr << "An error occurred during your request: " << e.what() << "." << std::endl;
  }
}

void UserCommands::deleteGroupCommand(CommandParser *commandParser, const std::vector<Core::String> &args) {
  if(args.size() < 2) {
    std::cerr << args[0] << ": No group id given." << std::endl;
    commandParser->printUsage("delete_group");
    return;
  }
  if(args.size() > 2) {
    std::cerr << args[0] << ": Too many arguments." << std::endl;
    commandParser->printUsage("delete_group");
    return;
  }

  char *endptr;
  unsigned long gid = std::strtoul(args[1].toString().c_str(), &endptr, 10);
  if(args[1].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse group id." << std::endl;
    commandParser->printUsage("delete_group");
    return;
  }

  try {
    commandParser->application->getUserManager()->deleteGroup(gid);

    std::cout << "Group deleted." << std::endl;
  }
  catch(Core::Exception e) {
    std::cerr << "An error occurred during your request: " << e.what() << "." << std::endl;
  }
}

void UserCommands::addUserToGroupCommand(CommandParser *commandParser, const std::vector<Core::String> &args) {
  if(args.size() < 3) {
    std::cerr << args[0] << ": Too few arguments." << std::endl;
    commandParser->printUsage("add_user_to_group");
    return;
  }
  if(args.size() > 3) {
    std::cerr << args[0] << ": Too many arguments." << std::endl;
    commandParser->printUsage("add_user_to_group");
    return;
  }

  char *endptr;
  unsigned long uid = std::strtoul(args[1].toString().c_str(), &endptr, 10);
  if(args[1].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse user id." << std::endl;
    commandParser->printUsage("add_user_to_group");
    return;
  }

  unsigned long gid = std::strtoul(args[2].toString().c_str(), &endptr, 10);
  if(args[2].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse group id." << std::endl;
    commandParser->printUsage("add_user_to_group");
    return;
  }

  try {
    commandParser->application->getUserManager()->addUserToGroup(uid, gid);

    std::cout << "Added." << std::endl;
  }
  catch(Core::Exception e) {
    std::cerr << "An error occurred during your request: " << e.what() << "." << std::endl;
  }
}

void UserCommands::deleteUserFromGroupCommand(CommandParser *commandParser, const std::vector<Core::String> &args) {
  if(args.size() < 3) {
    std::cerr << args[0] << ": Too few arguments." << std::endl;
    commandParser->printUsage("delete_user_from_group");
    return;
  }
  if(args.size() > 3) {
    std::cerr << args[0] << ": Too many arguments." << std::endl;
    commandParser->printUsage("delete_user_from_group");
    return;
  }

  char *endptr;
  unsigned long uid = std::strtoul(args[1].toString().c_str(), &endptr, 10);
  if(args[1].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse user id." << std::endl;
    commandParser->printUsage("delete_user_from_group");
    return;
  }

  unsigned long gid = std::strtoul(args[2].toString().c_str(), &endptr, 10);
  if(args[2].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse group id." << std::endl;
    commandParser->printUsage("delete_user_from_group");
    return;
  }

  try {
    commandParser->application->getUserManager()->deleteUserFromGroup(uid, gid);

    std::cout << "Removed." << std::endl;
  }
  catch(Core::Exception e) {
    std::cerr << "An error occurred during your request: " << e.what() << "." << std::endl;
  }
}

void UserCommands::setPasswordCommand(CommandParser *commandParser, const std::vector<Core::String> &args) {
  if(args.size() < 2) {
    std::cerr << args[0] << ": Too few arguments." << std::endl;
    commandParser->printUsage("set_password");
    return;
  }
  if(args.size() > 2) {
    std::cerr << args[0] << ": Too many arguments." << std::endl;
    commandParser->printUsage("set_password");
    return;
  }

  char *endptr;
  unsigned long uid = std::strtoul(args[1].toString().c_str(), &endptr, 10);
  if(args[1].isEmpty() || *endptr != '\0') {
    std::cerr << args[0] << ": Unable to parse user id." << std::endl;
    commandParser->printUsage("set_password");
    return;
  }

  Core::String password = ConsoleUtil::readPassword("Password: ");
  Core::String password2 = ConsoleUtil::readPassword("Verify password: ");

  if(password != password2) {
    std::cerr << "Passwords do not match." << std::endl;
    return;
  }

  try {
    commandParser->application->getUserManager()->setPassword(uid, password);

    std::cout << "Password set." << std::endl;
  }
  catch(Core::Exception e) {
    std::cerr << "An error occurred during your request: " << e.what() << "." << std::endl;
  }
}

}
}