/*****************************************************************************
 * Author:   Valient Gough <vgough@pobox.com>
 *
 *****************************************************************************
 * Copyright (c) 2004-2013, Valient Gough
 *
 * 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 "base/ConfigReader.h"

#include <glog/logging.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstring>

#include "base/types.h"

using std::make_pair;
using std::map;
using std::string;

namespace encfs {

ConfigReader::ConfigReader() {}

ConfigReader::~ConfigReader() {}

// read the entire file into a ConfigVar instance and then use that to decode
// into mapped variables.
bool ConfigReader::load(const char *fileName) {
  struct stat stbuf;
  memset(&stbuf, 0, sizeof(struct stat));
  if (lstat(fileName, &stbuf) != 0) return false;

  int size = stbuf.st_size;

  int fd = open(fileName, O_RDONLY);
  if (fd < 0) return false;

  char *buf = new char[size];

  int res = ::read(fd, buf, size);
  close(fd);

  if (res != size) {
    LOG(WARNING) << "Partial read of config file, expecting " << size
                 << " bytes, got " << res;
    delete[] buf;
    return false;
  }

  ConfigVar in;
  in.write((byte *)buf, size);
  delete[] buf;

  return loadFromVar(in);
}

bool ConfigReader::loadFromVar(ConfigVar &in) {
  in.resetOffset();

  // parse.
  int numEntries = in.readInt();

  for (int i = 0; i < numEntries; ++i) {
    string key, value;
    in >> key >> value;

    if (key.length() == 0) {
      LOG(ERROR) << "Invalid key encoding in buffer";
      return false;
    }
    ConfigVar newVar(value);
    vars.insert(make_pair(key, newVar));
  }

  return true;
}

bool ConfigReader::save(const char *fileName) const {
  // write everything to a ConfigVar, then output to disk
  ConfigVar out = toVar();

  int fd = ::open(fileName, O_RDWR | O_CREAT, 0640);
  if (fd >= 0) {
    int retVal = ::write(fd, out.buffer(), out.size());
    close(fd);
    if (retVal != out.size()) {
      LOG(ERROR) << "Error writing to config file " << fileName;
      return false;
    }
  } else {
    LOG(ERROR) << "Unable to open or create file " << fileName;
    return false;
  }

  return true;
}

ConfigVar ConfigReader::toVar() const {
  // write everything to a ConfigVar, then output to disk
  ConfigVar out;
  out.writeInt(vars.size());
  map<string, ConfigVar>::const_iterator it;
  for (it = vars.begin(); it != vars.end(); ++it) {
    out.writeInt(it->first.size());
    out.write((byte *)it->first.data(), it->first.size());
    out.writeInt(it->second.size());
    out.write((byte *)it->second.buffer(), it->second.size());
  }

  return out;
}

ConfigVar ConfigReader::operator[](const std::string &varName) const {
  // read only
  map<string, ConfigVar>::const_iterator it = vars.find(varName);
  if (it == vars.end())
    return ConfigVar();
  else
    return it->second;
}

ConfigVar &ConfigReader::operator[](const std::string &varName) {
  return vars[varName];
}

}  // namespace encfs