/*
 * Copyright 2015 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "cobalt/storage/virtual_file.h"

#include <algorithm>

#include "base/logging.h"

namespace cobalt {
namespace storage {
namespace {

// We must use forward declarations to be able to specify the
// WARN_UNUSED_RESULT attribute.

// Read size bytes from buffer into dest. Return # of bytes read.
int ReadBuffer(uint8* dest, const uint8* buffer, int size) WARN_UNUSED_RESULT;

// Write size bytes from source into buffer. Return # of bytes written.
int WriteBuffer(uint8* buffer, const uint8* source, int size,
                bool dry_run) WARN_UNUSED_RESULT;

int ReadBuffer(uint8* dest, const uint8* buffer, int size) {
  memcpy(dest, buffer, static_cast<size_t>(size));
  return size;
}

int WriteBuffer(uint8* buffer, const uint8* source, int size, bool dry_run) {
  if (!dry_run) {
    memcpy(buffer, source, static_cast<size_t>(size));
  }
  return size;
}

}  // namespace

VirtualFile::VirtualFile(const std::string& name) : size_(0), name_(name) {}
VirtualFile::~VirtualFile() {}

int VirtualFile::Read(void* dest, int bytes, int offset) const {
  DCHECK_GE(offset, 0);
  if (offset > size_) {
    return 0;
  }
  int bytes_to_read = std::min(size_ - offset, bytes);
  if (bytes_to_read == 0) {
    return 0;
  }
  memcpy(dest, &buffer_[static_cast<size_t>(offset)],
         static_cast<size_t>(bytes_to_read));
  return bytes_to_read;
}

int VirtualFile::Write(const void* source, int bytes, int offset) {
  DCHECK_GE(offset, 0);
  DCHECK_GE(bytes, 0);
  if (static_cast<int>(buffer_.size()) < offset + bytes) {
    buffer_.resize(static_cast<size_t>(offset + bytes));
  }

  memcpy(&buffer_[static_cast<size_t>(offset)], source,
         static_cast<size_t>(bytes));
  size_ = std::max(size_, offset + bytes);
  return bytes;
}

int VirtualFile::Truncate(int size) {
  size_ = std::min(size_, size);
  return size_;
}

int VirtualFile::Serialize(uint8* dest, bool dry_run) {
  uint8* cur_buffer = dest;

  // Write filename length
  uint64 name_length = name_.length();
  DCHECK_LT(name_length, kMaxVfsPathname);
  cur_buffer +=
      WriteBuffer(cur_buffer, reinterpret_cast<const uint8*>(&name_length),
                  sizeof(name_length), dry_run);

  // Write the filename
  cur_buffer +=
      WriteBuffer(cur_buffer, reinterpret_cast<const uint8*>(name_.c_str()),
                  static_cast<int>(name_length), dry_run);

  // NOTE: Ensure the file size is 64-bit for compatibility
  // with any existing serialized files.
  uint64 file_size = static_cast<uint64>(size_);
  // Write the file contents size
  cur_buffer +=
      WriteBuffer(cur_buffer, reinterpret_cast<const uint8*>(&file_size),
                  sizeof(file_size), dry_run);

  // Write the file contents
  cur_buffer += WriteBuffer(cur_buffer, &buffer_[0], size_, dry_run);

  // Return the number of bytes written
  return static_cast<int>(std::distance(dest, cur_buffer));
}

int VirtualFile::Deserialize(const uint8* source) {
  // Read in filename length
  const uint8* cur_buffer = source;
  uint64 name_length;
  cur_buffer += ReadBuffer(reinterpret_cast<uint8*>(&name_length), cur_buffer,
                           sizeof(name_length));

  if (name_length >= kMaxVfsPathname) {
    DLOG(ERROR) << "Filename was longer than the maximum allowed.";
    return -1;
  }
  // Read in filename
  char name[kMaxVfsPathname];
  cur_buffer += ReadBuffer(reinterpret_cast<uint8*>(name), cur_buffer,
                           static_cast<int>(name_length));
  name_.assign(name, name_length);

  // Read in file contents size.
  uint64 file_size;
  cur_buffer += ReadBuffer(reinterpret_cast<uint8*>(&file_size), cur_buffer,
                           sizeof(file_size));
  size_ = static_cast<int>(file_size);

  // Read in the file contents
  buffer_.resize(static_cast<size_t>(size_));
  cur_buffer += ReadBuffer(&buffer_[0], cur_buffer, size_);

  // Return the number of bytes read
  return static_cast<int>(std::distance(source, cur_buffer));
}

}  // namespace storage
}  // namespace cobalt