// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "webkit/fileapi/file_system_usage_cache.h"

#include "base/file_path.h"
#include "base/file_util.h"
#include "base/pickle.h"

namespace fileapi {

const char FileSystemUsageCache::kUsageFileName[] = ".usage";
const char FileSystemUsageCache::kUsageFileHeader[] = "FSU4";
const int FileSystemUsageCache::kUsageFileHeaderSize = 4;

/* Pickle::{Read,Write}Bool treat bool as int */
const int FileSystemUsageCache::kUsageFileSize =
    sizeof(Pickle::Header) +
    FileSystemUsageCache::kUsageFileHeaderSize +
    sizeof(int) + sizeof(int32) + sizeof(int64);

// static
int64 FileSystemUsageCache::GetUsage(const FilePath& usage_file_path) {
  bool is_valid = true;
  uint32 dirty = 0;
  int64 fs_usage;
  fs_usage = Read(usage_file_path, &is_valid, &dirty);

  if (fs_usage < 0)
    return -1;

  return fs_usage;
}

// static
int32 FileSystemUsageCache::GetDirty(const FilePath& usage_file_path) {
  bool is_valid = true;
  uint32 dirty = 0;
  int64 fs_usage;
  fs_usage = Read(usage_file_path, &is_valid, &dirty);

  if (fs_usage < 0)
    return -1;

  return static_cast<int32>(dirty);
}

// static
bool FileSystemUsageCache::IncrementDirty(const FilePath& usage_file_path) {
  bool is_valid = true;
  uint32 dirty = 0;
  int64 fs_usage;
  fs_usage = Read(usage_file_path, &is_valid, &dirty);

  if (fs_usage < 0)
    return false;

  return Write(usage_file_path, is_valid, dirty + 1, fs_usage) >= 0;
}

// static
bool FileSystemUsageCache::DecrementDirty(const FilePath& usage_file_path) {
  bool is_valid = true;
  uint32 dirty = 0;
  int64 fs_usage;
  fs_usage = Read(usage_file_path, &is_valid, &dirty);

  if (fs_usage < 0 || dirty <= 0)
    return false;

  return Write(usage_file_path, is_valid, dirty - 1, fs_usage) >= 0;
}

// static
bool FileSystemUsageCache::Invalidate(const FilePath& usage_file_path) {
  bool is_valid = true;
  uint32 dirty = 0;
  int64 fs_usage;
  fs_usage = Read(usage_file_path, &is_valid, &dirty);

  return fs_usage >= 0 && Write(usage_file_path, false, dirty, fs_usage);
}

bool FileSystemUsageCache::IsValid(const FilePath& usage_file_path) {
  bool is_valid = true;
  uint32 dirty = 0;
  Read(usage_file_path, &is_valid, &dirty);
  return is_valid;
}

// static
int FileSystemUsageCache::AtomicUpdateUsageByDelta(
    const FilePath& usage_file_path, int64 delta) {
  bool is_valid = true;
  uint32 dirty = 0;
  int64 fs_usage;
  // TODO(dmikurube): Make sure that usage_file_path is available.
  fs_usage = Read(usage_file_path, &is_valid, &dirty);

  if (fs_usage < 0)
    return -1;

  return Write(usage_file_path, is_valid, dirty, fs_usage + delta);
}

// static
int FileSystemUsageCache::UpdateUsage(const FilePath& usage_file_path,
                                      int64 fs_usage) {
  return Write(usage_file_path, true, 0, fs_usage);
}

// static
bool FileSystemUsageCache::Exists(const FilePath& usage_file_path) {
  return file_util::PathExists(usage_file_path);
}

// static
bool FileSystemUsageCache::Delete(const FilePath& usage_file_path) {
  return file_util::Delete(usage_file_path, true);
}

// static
int64 FileSystemUsageCache::Read(const FilePath& usage_file_path,
                                 bool* is_valid,
                                 uint32* dirty) {
  char buffer[kUsageFileSize];
  const char *header;
  DCHECK(!usage_file_path.empty());
  if (kUsageFileSize !=
      file_util::ReadFile(usage_file_path, buffer, kUsageFileSize))
    return -1;
  Pickle read_pickle(buffer, kUsageFileSize);
  void* iter = NULL;
  int64 fs_usage;

  if (!read_pickle.ReadBytes(&iter, &header, kUsageFileHeaderSize) ||
      !read_pickle.ReadBool(&iter, is_valid) ||
      !read_pickle.ReadUInt32(&iter, dirty) ||
      !read_pickle.ReadInt64(&iter, &fs_usage))
    return -1;

  if (header[0] != kUsageFileHeader[0] ||
      header[1] != kUsageFileHeader[1] ||
      header[2] != kUsageFileHeader[2] ||
      header[3] != kUsageFileHeader[3])
    return -1;

  return fs_usage;
}

// static
int FileSystemUsageCache::Write(const FilePath& usage_file_path,
                                bool is_valid,
                                uint32 dirty,
                                int64 fs_usage) {
  Pickle write_pickle;
  write_pickle.WriteBytes(kUsageFileHeader, kUsageFileHeaderSize);
  write_pickle.WriteBool(is_valid);
  write_pickle.WriteUInt32(dirty);
  write_pickle.WriteInt64(fs_usage);

  DCHECK(!usage_file_path.empty());
  FilePath temporary_usage_file_path;
  file_util::CreateTemporaryFileInDir(usage_file_path.DirName(),
                                      &temporary_usage_file_path);
  int bytes_written = file_util::WriteFile(temporary_usage_file_path,
                                           (const char *)write_pickle.data(),
                                           write_pickle.size());
  if (bytes_written != kUsageFileSize)
    return -1;

  if (file_util::ReplaceFile(temporary_usage_file_path, usage_file_path))
    return bytes_written;
  else
    return -1;
}

}  // namespace fileapi