/*
 * 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 {

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

  storageRoot = application->getConfigManager()->get("Storage.Root").toLocale();

  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 Core::String &type, const Core::String &name) {
  boost::filesystem::path path(storageRoot);

  path /= type.toLocale();
  path /= Core::String(name + ".xml").toLocale();

  return path;
}

std::set<Core::String> StorageBackendFile::listTypes() throw (Core::Exception) {
  boost::shared_lock<boost::shared_mutex> lock(mutex);

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

  std::set<Core::String> ret;

  try {
    for(boost::filesystem::directory_iterator it(storageRoot); it != boost::filesystem::directory_iterator(); ++it) {
      boost::filesystem::path path = *it;

      if(boost::filesystem::is_directory(path))
        ret.insert(path.filename().c_str());
    }
  }
  catch(...) {} // Don't throw if we can't iterate over the dirs

  return ret;
}

std::set<Core::String> StorageBackendFile::list(const Core::String &type) throw (Core::Exception) {
  boost::shared_lock<boost::shared_mutex> lock(mutex);

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

  std::set<Core::String> ret;

  boost::filesystem::path path(storageRoot);
  path /= type.toLocale();

  try {
    for(boost::filesystem::directory_iterator it(path); it != boost::filesystem::directory_iterator(); ++it) {
      boost::filesystem::path filePath = *it;

      if(boost::filesystem::is_regular_file(filePath) && filePath.extension() == ".xml")
        ret.insert(filePath.replace_extension().filename().c_str());
    }
  }
  catch(...) {} // Don't throw if we can't iterate over the dirs

  return ret;
}


bool StorageBackendFile::exists(const Core::String &type, const Core::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::filesystem::is_regular_file(path);
}

void StorageBackendFile::store(const Core::String &type, const Core::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 Core::String &type, const Core::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);
  if(!boost::filesystem::is_regular_file(path))
    throw Core::Exception(Core::Exception::NOT_FOUND);

  return boost::shared_ptr<Common::XmlData>(new Common::XmlData(path.file_string()));
}

void StorageBackendFile::copy(const Core::String &type, const Core::String &name, const Core::String &newName) 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::path newPath = getFileName(type, newName);
  boost::filesystem::copy_file(path, newPath);
}

void StorageBackendFile::rename(const Core::String &type, const Core::String &name, const Core::String &newName) 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::path newPath = getFileName(type, newName);
  boost::filesystem::rename(path, newPath);
}

void StorageBackendFile::remove(const Core::String &type, const Core::String &name) 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::remove(path);
}

}
}
}