/*
 * UserListManager.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 "UserListManager.h"
#include "UserList.h"
#include "Util.h"
#include "RequestHandlers/UserListRequestHandlerGroup.h"
#include "RequestHandlers/UserListUploadRequestHandler.h"

#include <Server/Application.h>
#include <Common/RequestManager.h>
#include <Common/StorageManager.h>
#include <Common/UserManager.h>
#include <Core/ConfigManager.h>

namespace Mad {
namespace Modules {
namespace UserListManager {

UserListManager::UserListManager(Server::Application *application0) : application(application0), requestHandlerGroup(new RequestHandlers::UserListRequestHandlerGroup(application, this)) {
  application->getConfigManager()->registerConfigurable(this);
}

UserListManager::~UserListManager() {
  application->getRequestManager()->unregisterPacketType("UploadUserList");
  application->getRequestManager()->unregisterRequestHandlerGroup(requestHandlerGroup);
  application->getConfigManager()->unregisterConfigurable(this);
}


void UserListManager::configFinished() {
  userLists = application->getStorageManager()->list("UserList");

  application->getRequestManager()->registerRequestHandlerGroup(requestHandlerGroup);
  application->getRequestManager()->registerPacketType<RequestHandlers::UserListUploadRequestHandler>("UploadUserList", this);
}


const std::set<std::string>& UserListManager::getUserLists() const {
  return userLists;
}


bool UserListManager::existsUserList(const std::string &name) {
  return application->getStorageManager()->exists("UserList", name);
}

boost::shared_ptr<UserList> UserListManager::loadUserList(const std::string &name) {
  boost::shared_ptr<Common::XmlData> data = application->getStorageManager()->load("UserList", name);

  if(!data)
    return boost::shared_ptr<UserList>();

  return Util::deserializeUserList(data.get());
}

void UserListManager::storeUserList(const std::string &name, const UserList *list) {
  Common::XmlData data;

  Util::serializeUserList(list, &data);
  application->getStorageManager()->store("UserList", name, &data);
}

void UserListManager::removeUserList(const std::string &name) {
  application->getStorageManager()->remove("UserList", name);
}

boost::shared_ptr<UserList> UserListManager::getCurrentUserList() {
  boost::shared_ptr<UserList> list(new UserList);

  boost::shared_ptr<const std::map<unsigned long, Common::UserInfo> > userList = application->getUserManager()->getUserList();
  boost::shared_ptr<const std::map<unsigned long, Common::GroupInfo> > groupList = application->getUserManager()->getGroupList();

  for(std::map<unsigned long, Common::UserInfo>::const_iterator user = userList->begin(); user != userList->end(); ++user) {
    std::map<unsigned long, Common::GroupInfo>::const_iterator group = groupList->find(user->second.getGid());
    std::string groupname;

    if(group != groupList->end()) {
      groupname = group->second.getName();
    }
    else {
      std::ostringstream stream;
      stream << user->second.getGid();
      groupname = stream.str();
    }

    UserListEntry entry(user->second.getUsername(), groupname);
    entry.setDetail("Full name", user->second.getFullName());

    list->push_back(entry);
  }

  return list;
}

}
}
}