/*
 * StorageBackendFile.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 "StorageBackendFile.h"

#include <Core/ConfigEntry.h>

#include <boost/filesystem.hpp>
#include <boost/thread/locks.hpp>

namespace Mad {
namespace Modules {
namespace StorageBackendFile {

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

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

  if(entry[1].getKey().matches("Root")) {
    if(!entry[2].empty())
      return false;

    storageRoot = entry[1][0];
  }
  else if(!entry[1].empty()) {
    return false;
  }

  return true;
}

void StorageBackendFile::configFinished() {
  boost::lock_guard<boost::shared_mutex> lock(mutex);

  if(!boost::filesystem::exists(storageRoot)) {
    boost::filesystem::create_directories(storageRoot);
  }

  if(!boost::filesystem::is_directory(storageRoot)) {
    application->logf("StorageBackendFile: Can't create directory: '%s'.", storageRoot.string().c_str());
    return;
  }

  configured = true;
}

boost::filesystem::path StorageBackendFile::getFileName(const std::string &type, const std::string &name) {
  boost::filesystem::path path(storageRoot);

  path /= type;
  path /= (name + ".xml");

  return path;
}

void StorageBackendFile::store(const std::string &type, const std::string &name, const Common::XmlData *data) throw (Core::Exception) {
  boost::lock_guard<boost::shared_mutex> lock(mutex);

  if(!configured)
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  boost::filesystem::path path = getFileName(type, name);
  boost::filesystem::create_directories(path.parent_path().directory_string());

  data->toFile(path.file_string());
}

boost::shared_ptr<Common::XmlData> StorageBackendFile::load(const std::string &type, const std::string &name) throw (Core::Exception) {
  boost::shared_lock<boost::shared_mutex> lock(mutex);

  if(!configured)
    throw Core::Exception(Core::Exception::NOT_AVAILABLE);

  boost::filesystem::path path = getFileName(type, name);
  return boost::shared_ptr<Common::XmlData>(new Common::XmlData(path.file_string()));
}

}
}
}