// Copyright 2013 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 "chrome/browser/sync_file_system/sync_status_code.h"

#include "base/logging.h"
#include "third_party/leveldatabase/src/include/leveldb/db.h"

namespace sync_file_system {

const char* SyncStatusCodeToString(SyncStatusCode status) {
  switch (status) {
    case SYNC_STATUS_OK:
      return "OK.";
    case SYNC_STATUS_UNKNOWN:
      return "Unknown sync status.";
    case SYNC_STATUS_FAILED:
      return "Failed.";

    // PlatformFile related errors.
    // TODO(nhiroki): add stringize function for File::Error into base/.
    case SYNC_FILE_ERROR_FAILED:
      return "File operation failed.";
    case SYNC_FILE_ERROR_IN_USE:
      return "File currently in use.";
    case SYNC_FILE_ERROR_EXISTS:
      return "File already exists.";
    case SYNC_FILE_ERROR_NOT_FOUND:
      return "File not found.";
    case SYNC_FILE_ERROR_ACCESS_DENIED:
      return "File access denied.";
    case SYNC_FILE_ERROR_TOO_MANY_OPENED:
      return "Too many files open.";
    case SYNC_FILE_ERROR_NO_MEMORY:
      return "Out of memory.";
    case SYNC_FILE_ERROR_NO_SPACE:
      return "No space left on disk.";
    case SYNC_FILE_ERROR_NOT_A_DIRECTORY:
      return "Not a directory.";
    case SYNC_FILE_ERROR_INVALID_OPERATION:
      return "Invalid file operation.";
    case SYNC_FILE_ERROR_SECURITY:
      return "Security error.";
    case SYNC_FILE_ERROR_ABORT:
      return "File operation aborted.";
    case SYNC_FILE_ERROR_NOT_A_FILE:
      return "Not a file.";
    case SYNC_FILE_ERROR_NOT_EMPTY:
      return "File not empty.";
    case SYNC_FILE_ERROR_INVALID_URL:
      return "Invalid URL.";
    case SYNC_FILE_ERROR_IO:
      return "OS or hardware error.";

    // Database related errors.
    case SYNC_DATABASE_ERROR_NOT_FOUND:
      return "Database not found.";
    case SYNC_DATABASE_ERROR_CORRUPTION:
      return "Database was corrupted.";
    case SYNC_DATABASE_ERROR_IO_ERROR:
      return "Database I/O error.";
    case SYNC_DATABASE_ERROR_FAILED:
      return "Database operation failed.";

    // Sync specific status code.
    case SYNC_STATUS_FILE_BUSY:
      return "Sync: file is busy.";
    case SYNC_STATUS_HAS_CONFLICT:
      return "Sync: file has conflict.";
    case SYNC_STATUS_NO_CONFLICT:
      return "Sync: file has no conflict.";
    case SYNC_STATUS_ABORT:
      return "Sync: operation aborted.";
    case SYNC_STATUS_NO_CHANGE_TO_SYNC:
      return "Sync: no change to synchronize.";
    case SYNC_STATUS_SERVICE_TEMPORARILY_UNAVAILABLE:
      return "Sync: service is temporarily unavailable.";
    case SYNC_STATUS_NETWORK_ERROR:
      return "Sync: network error.";
    case SYNC_STATUS_AUTHENTICATION_FAILED:
      return "Sync: authentication failed.";
    case SYNC_STATUS_UNKNOWN_ORIGIN:
      return "Sync: unknown origin.";
    case SYNC_STATUS_NOT_MODIFIED:
      return "Sync: file not modified.";
    case SYNC_STATUS_SYNC_DISABLED:
      return "Sync: sync is disabled.";
    case SYNC_STATUS_ACCESS_FORBIDDEN:
      return "Sync: service access forbidden.";
    case SYNC_STATUS_RETRY:
      return "Sync: retry the operation.";
  }
  NOTREACHED();
  return "Unknown error.";
}

SyncStatusCode LevelDBStatusToSyncStatusCode(const leveldb::Status& status) {
  if (status.ok())
    return SYNC_STATUS_OK;
  else if (status.IsNotFound())
    return SYNC_DATABASE_ERROR_NOT_FOUND;
  else if (status.IsCorruption())
    return SYNC_DATABASE_ERROR_CORRUPTION;
  else if (status.IsIOError())
    return SYNC_DATABASE_ERROR_IO_ERROR;
  else
    return SYNC_DATABASE_ERROR_FAILED;
}

SyncStatusCode FileErrorToSyncStatusCode(
    base::File::Error file_error) {
  switch (file_error) {
    case base::File::FILE_OK:
      return SYNC_STATUS_OK;
    case base::File::FILE_ERROR_FAILED:
      return SYNC_FILE_ERROR_FAILED;
    case base::File::FILE_ERROR_IN_USE:
      return SYNC_FILE_ERROR_IN_USE;
    case base::File::FILE_ERROR_EXISTS:
      return SYNC_FILE_ERROR_EXISTS;
    case base::File::FILE_ERROR_NOT_FOUND:
      return SYNC_FILE_ERROR_NOT_FOUND;
    case base::File::FILE_ERROR_ACCESS_DENIED:
      return SYNC_FILE_ERROR_ACCESS_DENIED;
    case base::File::FILE_ERROR_TOO_MANY_OPENED:
      return SYNC_FILE_ERROR_TOO_MANY_OPENED;
    case base::File::FILE_ERROR_NO_MEMORY:
      return SYNC_FILE_ERROR_NO_MEMORY;
    case base::File::FILE_ERROR_NO_SPACE:
      return SYNC_FILE_ERROR_NO_SPACE;
    case base::File::FILE_ERROR_NOT_A_DIRECTORY:
      return SYNC_FILE_ERROR_NOT_A_DIRECTORY;
    case base::File::FILE_ERROR_INVALID_OPERATION:
      return SYNC_FILE_ERROR_INVALID_OPERATION;
    case base::File::FILE_ERROR_SECURITY:
      return SYNC_FILE_ERROR_SECURITY;
    case base::File::FILE_ERROR_ABORT:
      return SYNC_FILE_ERROR_ABORT;
    case base::File::FILE_ERROR_NOT_A_FILE:
      return SYNC_FILE_ERROR_NOT_A_FILE;
    case base::File::FILE_ERROR_NOT_EMPTY:
      return SYNC_FILE_ERROR_NOT_EMPTY;
    case base::File::FILE_ERROR_INVALID_URL:
      return SYNC_FILE_ERROR_INVALID_URL;
    case base::File::FILE_ERROR_IO:
      return SYNC_FILE_ERROR_IO;
    case base::File::FILE_ERROR_MAX:
      NOTREACHED();
      return SYNC_FILE_ERROR_FAILED;
  }
  // Return the value as is, so the value converted by
  // SyncStatusCodeToFileError could be restored.
  return static_cast<SyncStatusCode>(file_error);
}

base::File::Error SyncStatusCodeToFileError(
    SyncStatusCode status) {
  switch (status) {
    case SYNC_STATUS_OK:
      return base::File::FILE_OK;
    case SYNC_FILE_ERROR_FAILED:
      return base::File::FILE_ERROR_FAILED;
    case SYNC_FILE_ERROR_IN_USE:
      return base::File::FILE_ERROR_IN_USE;
    case SYNC_FILE_ERROR_EXISTS:
      return base::File::FILE_ERROR_EXISTS;
    case SYNC_FILE_ERROR_NOT_FOUND:
      return base::File::FILE_ERROR_NOT_FOUND;
    case SYNC_FILE_ERROR_ACCESS_DENIED:
      return base::File::FILE_ERROR_ACCESS_DENIED;
    case SYNC_FILE_ERROR_TOO_MANY_OPENED:
      return base::File::FILE_ERROR_TOO_MANY_OPENED;
    case SYNC_FILE_ERROR_NO_MEMORY:
      return base::File::FILE_ERROR_NO_MEMORY;
    case SYNC_FILE_ERROR_NO_SPACE:
      return base::File::FILE_ERROR_NO_SPACE;
    case SYNC_FILE_ERROR_NOT_A_DIRECTORY:
      return base::File::FILE_ERROR_NOT_A_DIRECTORY;
    case SYNC_FILE_ERROR_INVALID_OPERATION:
      return base::File::FILE_ERROR_INVALID_OPERATION;
    case SYNC_FILE_ERROR_SECURITY:
      return base::File::FILE_ERROR_SECURITY;
    case SYNC_FILE_ERROR_ABORT:
      return base::File::FILE_ERROR_ABORT;
    case SYNC_FILE_ERROR_NOT_A_FILE:
      return base::File::FILE_ERROR_NOT_A_FILE;
    case SYNC_FILE_ERROR_NOT_EMPTY:
      return base::File::FILE_ERROR_NOT_EMPTY;
    case SYNC_FILE_ERROR_INVALID_URL:
      return base::File::FILE_ERROR_INVALID_URL;
    case SYNC_FILE_ERROR_IO:
      return base::File::FILE_ERROR_IO;
    default:
      // Return the value as is, so that caller may be able to
      // restore the information.
      return static_cast<base::File::Error>(status);
  }
}

}  // namespace sync_file_system