/*
 * UserBackendMysql.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 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 "UserBackendMysql.h"
#include <Core/ConfigEntry.h>
#include <Core/ConfigManager.h>
#include <Core/ThreadManager.h>

#include <sstream>

#include <boost/bind.hpp>
#include <boost/regex.hpp>
#include <boost/thread/locks.hpp>

#include <mysql/mysqld_error.h>

namespace Mad {
namespace Modules {
namespace UserBackendMysql {

const std::string UserBackendMysql::name("UserBackendMysql");

bool UserBackendMysql::handleConfigEntry(const Core::ConfigEntry &entry, bool /*handled*/) {
  if(!entry[0].getKey().matches("UserManager"))
    return false;

  if(entry[1].empty())
    return true;

  if(!entry[1].getKey().matches("Mysql"))
    return false;

  if(entry[2].getKey().matches("Host")) {
    if(entry[3].empty())
      host = entry[2][0];
  }
  else if(entry[2].getKey().matches("Username")) {
    if(entry[3].empty())
      username = entry[2][0];
  }
  else if(entry[2].getKey().matches("Password")) {
    if(entry[3].empty())
      passwd = entry[2][0];
  }
  else if(entry[2].getKey().matches("Database")) {
    if(entry[3].empty())
      db = entry[2][0];
  }
  else if(entry[2].getKey().matches("Port")) {
    if(entry[3].empty()) {
      char *endptr;
      long val;

      val = strtol(entry[2][0].c_str(), &endptr, 10);

      if(endptr != 0 || val < 0 || val > 65535)
        application->log(Core::LoggerBase::WARNING, "UserBackendMysql: Invalid port");
      else
        port = val;
    }
  }
  else if(entry[2].getKey().matches("UnixSocket")) {
    if(entry[3].empty())
      unixSocket = entry[2][0];
  }
  else if(entry[2].getKey().matches("Queries")) {
    if(entry[3].getKey().matches("ListUsers")) {
      if(entry[4].empty())
        queryListUsers = entry[3][0];
    }
    else if(entry[3].getKey().matches("ListGroups")) {
      if(entry[4].empty())
        queryListGroups = entry[3][0];
    }
    else if(entry[3].getKey().matches("ListUserGroups")) {
      if(entry[4].empty())
        queryListUserGroups = entry[3][0];
    }
    else if(entry[3].getKey().matches("ListGroupUsers")) {
      if(entry[4].empty())
        queryListGroupUsers = entry[3][0];
    }
    else if(entry[3].getKey().matches("UserById")) {
      if(entry[4].empty())
        queryUserById = entry[3][0];
    }
    else if(entry[3].getKey().matches("UserByName")) {
      if(entry[4].empty())
        queryUserByName = entry[3][0];
    }
    else if(entry[3].getKey().matches("GroupById")) {
      if(entry[4].empty())
        queryGroupById = entry[3][0];
    }
    else if(entry[3].getKey().matches("GroupByName")) {
      if(entry[4].empty())
        queryGroupByName = entry[3][0];
    }
    else if(entry[3].getKey().matches("UserGroupTable")) {
      if(entry[4].empty())
        queryUserGroupTable = entry[3][0];
    }
    else if(entry[3].getKey().matches("AddUser")) {
      if(entry[4].empty())
        queryAddUser = entry[3][0];
    }
    else if(entry[3].getKey().matches("UpdateUser")) {
      if(entry[4].empty())
        queryUpdateUser = entry[3][0];
    }
    else if(entry[3].getKey().matches("DeleteUser")) {
      if(entry[4].empty())
        queryDeleteUser = entry[3][0];
    }
    else if(entry[3].getKey().matches("AddGroup")) {
      if(entry[4].empty())
        queryAddGroup = entry[3][0];
    }
    else if(entry[3].getKey().matches("UpdateGroup")) {
      if(entry[4].empty())
        queryUpdateGroup = entry[3][0];
    }
    else if(entry[3].getKey().matches("DeleteGroup")) {
      if(entry[4].empty())
        queryDeleteGroup = entry[3][0];
    }
    else if(entry[3].getKey().matches("AddUserToGroup")) {
      if(entry[4].empty())
        queryAddUserToGroup = entry[3][0];
    }
    else if(entry[3].getKey().matches("DeleteUserFromGroup")) {
      if(entry[4].empty())
        queryDeleteUserFromGroup = entry[3][0];
    }
    else if(!entry[3].empty())
      return false;
  }
  else if(!entry[2].empty())
    return false;

  return true;
}

void UserBackendMysql::configFinished() {
  if(db.empty()) {
    application->log(Core::LoggerBase::ERROR, "UserBackendMysql: No database name given");
    return;
  }

  boost::lock_guard<boost::mutex> lock(mutex);
  mysql = mysql_init(0);
  mysql_real_connect(mysql, host.c_str(), username.c_str(), passwd.c_str(), db.c_str(), port, unixSocket.empty() ? 0 : unixSocket.c_str(), 0);
}


UserBackendMysql::Result UserBackendMysql::query(const std::string &query, const ArgumentMap &args) throw(Core::Exception) {
  if(!mysql || mysql_ping(mysql))
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  if(args.empty()) {
    mysql_real_query(mysql, query.c_str(), query.length());
  }
  else {
    std::string queryStr = query;

    for(ArgumentMap::const_iterator arg = args.begin(); arg != args.end(); ++arg) {
      std::string argStr;

      try {
        argStr = boost::get<std::string>(arg->second);
      }
      catch(...) {
        std::ostringstream stream;
        stream << arg->second;
        argStr = stream.str();
      }

      boost::scoped_array<char> escaped(new char[argStr.length()*2+1]);
      mysql_real_escape_string(mysql, escaped.get(), argStr.c_str(), argStr.length());

      queryStr = boost::regex_replace(queryStr, boost::regex("\\{" + arg->first + "\\}"), "\"" + std::string(escaped.get()) + "\"", boost::match_default);
    }

    mysql_real_query(mysql, queryStr.c_str(), queryStr.length());
  }

  return Result(mysql);
}


boost::shared_ptr<const std::map<unsigned long, Common::UserInfo> > UserBackendMysql::getUserList(boost::posix_time::ptime *timestamp) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::unique_lock<boost::mutex> lock(mutex);

  if(timestamp) {
    if(timestamp->is_not_a_date_time() || *timestamp < lastUpdate)
      *timestamp = lastUpdate;
    else
      return boost::shared_ptr<const std::map<unsigned long, Common::UserInfo> >();
  }

  Result result = query(queryListUsers);

  lock.unlock();

  if(!result || result.getErrno() || result.getFieldNumber() < 4)
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  boost::shared_ptr<std::map<unsigned long, Common::UserInfo> > users(new std::map<unsigned long, Common::UserInfo>());

  while(MYSQL_ROW row = result.getNextRow()) {
    Common::UserInfo user(strtoul(row[0], 0, 10), row[2]);

    user.setGid(strtoul(row[1], 0, 10));
    user.setFullName(row[3]);

    users->insert(std::make_pair(user.getUid(), user));
  }

  return users;
}

boost::shared_ptr<const Common::UserInfo> UserBackendMysql::getUserInfo(unsigned long uid, boost::posix_time::ptime *timestamp) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::unique_lock<boost::mutex> lock(mutex);

  if(timestamp) {
    if(timestamp->is_not_a_date_time() || *timestamp < lastUpdate)
      *timestamp = lastUpdate;
    else
      return boost::shared_ptr<const Common::UserInfo>();
  }

  ArgumentMap args;
  args.insert(std::make_pair("UID", uid));

  Result result = query(queryUserById, args);

  lock.unlock();

  if(!result || result.getErrno() || result.getFieldNumber() < 4)
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  MYSQL_ROW row = result.getNextRow();

  if(row) {
    boost::shared_ptr<Common::UserInfo> user(new Common::UserInfo(strtoul(row[0], 0, 10), row[2]));

    user->setGid(strtoul(row[1], 0, 10));
    user->setFullName(row[3]);

    return user;
  }

  throw Core::Exception(Core::Exception::NOT_FOUND);
}

boost::shared_ptr<const Common::UserInfo> UserBackendMysql::getUserInfoByName(const std::string &name, boost::posix_time::ptime *timestamp) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::unique_lock<boost::mutex> lock(mutex);

  if(timestamp) {
    if(timestamp->is_not_a_date_time() || *timestamp < lastUpdate)
      *timestamp = lastUpdate;
    else
      return boost::shared_ptr<const Common::UserInfo>();
  }

  ArgumentMap args;
  args.insert(std::make_pair("USER", name));

  Result result = query(queryUserByName, args);

  lock.unlock();

  if(!result || result.getErrno() || result.getFieldNumber() < 4)
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  MYSQL_ROW row = result.getNextRow();

  if(row) {
    boost::shared_ptr<Common::UserInfo> user(new Common::UserInfo(strtoul(row[0], 0, 10), row[2]));

    user->setGid(strtoul(row[1], 0, 10));
    user->setFullName(row[3]);

    return user;
  }

  throw Core::Exception(Core::Exception::NOT_FOUND);
}

boost::shared_ptr<const std::set<unsigned long> > UserBackendMysql::getUserGroupList(unsigned long uid, boost::posix_time::ptime *timestamp) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::unique_lock<boost::mutex> lock(mutex);

  if(timestamp) {
    if(timestamp->is_not_a_date_time() || *timestamp < lastUpdate)
      *timestamp = lastUpdate;
    else
      return boost::shared_ptr<const std::set<unsigned long> >();
  }

  ArgumentMap args;
  args.insert(std::make_pair("UID", uid));

  Result result = query(queryListUserGroups, args);

  lock.unlock();

  if(!result || result.getErrno() || result.getFieldNumber() < 1)
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  boost::shared_ptr<std::set<unsigned long> > groups(new std::set<unsigned long>);

  while(MYSQL_ROW row = result.getNextRow())
    groups->insert(strtoul(row[0], 0, 10));

  return groups;
}


boost::shared_ptr<const std::map<unsigned long, Common::GroupInfo> > UserBackendMysql::getGroupList(boost::posix_time::ptime *timestamp) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::unique_lock<boost::mutex> lock(mutex);

  if(timestamp) {
    if(timestamp->is_not_a_date_time() || *timestamp < lastUpdate)
      *timestamp = lastUpdate;
    else
      return boost::shared_ptr<const std::map<unsigned long, Common::GroupInfo> >();
  }

  Result result = query(queryListGroups);

  lock.unlock();

  if(!result || result.getErrno() || result.getFieldNumber() < 2)
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  boost::shared_ptr<std::map<unsigned long, Common::GroupInfo> > groups(new std::map<unsigned long, Common::GroupInfo>());

  while(MYSQL_ROW row = result.getNextRow()) {
    Common::GroupInfo group(strtoul(row[0], 0, 10), row[1]);

    groups->insert(std::make_pair(group.getGid(), group));
  }

  return groups;
}

boost::shared_ptr<const Common::GroupInfo> UserBackendMysql::getGroupInfo(unsigned long gid, boost::posix_time::ptime *timestamp) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::unique_lock<boost::mutex> lock(mutex);

  if(timestamp) {
    if(timestamp->is_not_a_date_time() || *timestamp < lastUpdate)
      *timestamp = lastUpdate;
    else
      return boost::shared_ptr<const Common::GroupInfo>();
  }

  ArgumentMap args;
  args.insert(std::make_pair("GID", gid));

  Result result = query(queryGroupById, args);

  lock.unlock();

  if(!result || result.getErrno() || result.getFieldNumber() < 2)
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  MYSQL_ROW row = result.getNextRow();

  if(row)
    return boost::shared_ptr<Common::GroupInfo>(new Common::GroupInfo(strtoul(row[0], 0, 10), row[1]));

  throw Core::Exception(Core::Exception::NOT_FOUND);
}

boost::shared_ptr<const Common::GroupInfo> UserBackendMysql::getGroupInfoByName(const std::string &name, boost::posix_time::ptime *timestamp) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::unique_lock<boost::mutex> lock(mutex);

  if(timestamp) {
    if(timestamp->is_not_a_date_time() || *timestamp < lastUpdate)
      *timestamp = lastUpdate;
    else
      return boost::shared_ptr<const Common::GroupInfo>();
  }

  ArgumentMap args;
  args.insert(std::make_pair("GROUP", name));

  Result result = query(queryGroupByName, args);

  lock.unlock();

  if(!result || result.getErrno() || result.getFieldNumber() < 2)
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  MYSQL_ROW row = result.getNextRow();

  if(row)
    return boost::shared_ptr<Common::GroupInfo>(new Common::GroupInfo(strtoul(row[0], 0, 10), row[1]));

  throw Core::Exception(Core::Exception::NOT_FOUND);
}

boost::shared_ptr<const std::set<unsigned long> > UserBackendMysql::getGroupUserList(unsigned long gid, boost::posix_time::ptime *timestamp) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::unique_lock<boost::mutex> lock(mutex);

  if(timestamp) {
    if(timestamp->is_not_a_date_time() || *timestamp < lastUpdate)
      *timestamp = lastUpdate;
    else
      return boost::shared_ptr<const std::set<unsigned long> >();
  }

  ArgumentMap args;
  args.insert(std::make_pair("GID", gid));

  Result result = query(queryListGroupUsers, args);

  lock.unlock();

  if(!result || result.getErrno() || result.getFieldNumber() < 1)
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  boost::shared_ptr<std::set<unsigned long> > users(new std::set<unsigned long>);

  while(MYSQL_ROW row = result.getNextRow())
    users->insert(strtoul(row[0], 0, 10));

  return users;
}

boost::shared_ptr<const std::multimap<unsigned long, unsigned long> > UserBackendMysql::getFullUserGroupList(boost::posix_time::ptime *timestamp) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::unique_lock<boost::mutex> lock(mutex);

  if(timestamp) {
    if(timestamp->is_not_a_date_time() || *timestamp < lastUpdate)
      *timestamp = lastUpdate;
    else
      return boost::shared_ptr<const std::multimap<unsigned long, unsigned long> >();
  }

  Result result = query(queryUserGroupTable);

  lock.unlock();

  if(!result || result.getErrno() || result.getFieldNumber() < 2)
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  boost::shared_ptr<std::multimap<unsigned long, unsigned long> > usergroups(new std::multimap<unsigned long, unsigned long>);

  while(MYSQL_ROW row = result.getNextRow())
    usergroups->insert(std::make_pair(strtoul(row[0], 0, 10), strtoul(row[1], 0, 10)));

  return usergroups;
}

void UserBackendMysql::addUser(const Common::UserInfo &userInfo) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::lock_guard<boost::mutex> lock(mutex);

  ArgumentMap args;
  args.insert(std::make_pair("UID", userInfo.getUid()));
  args.insert(std::make_pair("GID", userInfo.getGid()));
  args.insert(std::make_pair("USER", userInfo.getUsername()));
  args.insert(std::make_pair("FULL_NAME", userInfo.getFullName()));

  Result result = query(queryAddUser, args);

  if(result.getErrno()) {
    if(result.getErrno() == ER_DUP_ENTRY)
      throw Core::Exception(Core::Exception::DUPLICATE_ENTRY);
    else
      throw Core::Exception(Core::Exception::NOT_AVAILABLE);
  }

  lastUpdate = boost::posix_time::microsec_clock::universal_time();
}

void UserBackendMysql::updateUser(unsigned long uid, const Common::UserInfo &userInfo) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::lock_guard<boost::mutex> lock(mutex);

  ArgumentMap args;
  args.insert(std::make_pair("ORIG_UID", uid));
  args.insert(std::make_pair("UID", userInfo.getUid()));
  args.insert(std::make_pair("GID", userInfo.getGid()));
  args.insert(std::make_pair("USER", userInfo.getUsername()));
  args.insert(std::make_pair("FULL_NAME", userInfo.getFullName()));

  Result result = query(queryUpdateUser, args);

  if(result.getErrno()) {
    if(result.getErrno() == ER_DUP_ENTRY)
      throw Core::Exception(Core::Exception::DUPLICATE_ENTRY);
    else
      throw Core::Exception(Core::Exception::NOT_AVAILABLE);
  }

  lastUpdate = boost::posix_time::microsec_clock::universal_time();
}

void UserBackendMysql::deleteUser(unsigned long uid) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::lock_guard<boost::mutex> lock(mutex);

  ArgumentMap args;
  args.insert(std::make_pair("UID", uid));

  Result result = query(queryDeleteUser, args);

  if(result.getErrno())
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  lastUpdate = boost::posix_time::microsec_clock::universal_time();
}

void UserBackendMysql::addGroup(const Common::GroupInfo &groupInfo) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::lock_guard<boost::mutex> lock(mutex);

  ArgumentMap args;
  args.insert(std::make_pair("GID", groupInfo.getGid()));
  args.insert(std::make_pair("GROUP", groupInfo.getName()));

  Result result = query(queryAddGroup, args);

  if(result.getErrno()) {
    if(result.getErrno() == ER_DUP_ENTRY)
      throw Core::Exception(Core::Exception::DUPLICATE_ENTRY);
    else
      throw Core::Exception(Core::Exception::NOT_AVAILABLE);
  }

  lastUpdate = boost::posix_time::microsec_clock::universal_time();
}

void UserBackendMysql::updateGroup(unsigned long gid, const Common::GroupInfo &groupInfo) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::lock_guard<boost::mutex> lock(mutex);

  ArgumentMap args;
  args.insert(std::make_pair("ORIG_GID", gid));
  args.insert(std::make_pair("GID", groupInfo.getGid()));
  args.insert(std::make_pair("GROUP", groupInfo.getName()));

  Result result = query(queryUpdateGroup, args);

  if(result.getErrno()) {
    if(result.getErrno() == ER_DUP_ENTRY)
      throw Core::Exception(Core::Exception::DUPLICATE_ENTRY);
    else
      throw Core::Exception(Core::Exception::NOT_AVAILABLE);
  }

  lastUpdate = boost::posix_time::microsec_clock::universal_time();
}

void UserBackendMysql::deleteGroup(unsigned long gid) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::lock_guard<boost::mutex> lock(mutex);

  ArgumentMap args;
  args.insert(std::make_pair("GID", gid));

  Result result = query(queryDeleteGroup, args);

  if(result.getErrno())
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  lastUpdate = boost::posix_time::microsec_clock::universal_time();
}

void UserBackendMysql::addUserToGroup(unsigned long uid, unsigned long gid) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::lock_guard<boost::mutex> lock(mutex);

  ArgumentMap args;
  args.insert(std::make_pair("UID", uid));
  args.insert(std::make_pair("GID", gid));

  Result result = query(queryAddUserToGroup, args);

  if(result.getErrno()) {
    if(result.getErrno() == ER_DUP_ENTRY)
      return;
    else
      throw Core::Exception(Core::Exception::NOT_AVAILABLE);
  }

  lastUpdate = boost::posix_time::microsec_clock::universal_time();
}

void UserBackendMysql::deleteUserFromGroup(unsigned long uid, unsigned long gid) throw(Core::Exception) {
  application->getThreadManager()->detach();

  boost::lock_guard<boost::mutex> lock(mutex);

  ArgumentMap args;
  args.insert(std::make_pair("UID", uid));
  args.insert(std::make_pair("GID", gid));

  Result result = query(queryDeleteUserFromGroup, args);

  if(result.getErrno())
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  lastUpdate = boost::posix_time::microsec_clock::universal_time();
}

}
}
}