////////////////////////////////////////////////////////////////////////////////
// Copyright 2017 Google LLC.
//
// This software is licensed under the terms defined in the Widevine Master
// License Agreement. For a copy of this agreement, please contact
// widevine-licensing@google.com.
////////////////////////////////////////////////////////////////////////////////

#ifndef COMMON_STATUS_H_
#define COMMON_STATUS_H_

#include <iosfwd>
#include <string>

#include "util/error_space.h"

namespace widevine {
namespace error {

enum StatusCode {
  // Success.
  OK = 0,

  // Client specified an invalid argument.
  INVALID_ARGUMENT = 3,

  // Some requested entity (e.g., file or directory) was not found.
  NOT_FOUND = 5,

  // Some entity that we attempted to create (e.g., file or directory)
  // already exists.
  ALREADY_EXISTS = 6,

  // The caller does not have permission to execute the specified
  // operation.  PERMISSION_DENIED must not be used for rejections
  // caused by exhausting some resource (use RESOURCE_EXHAUSTED
  // instead for those errors).
  PERMISSION_DENIED = 7,

  // The operation was rejected because the system is not in a state
  // required for the operation's execution.  For example, the directory
  // to be deleted is non-empty, an rmdir operation is applied to
  // a non-directory, etc.
  FAILED_PRECONDITION = 9,

  // Operation is not implemented or not supported/enabled in this service.
  UNIMPLEMENTED = 12,

  // Internal errors.  Means some invariants expected by underlying
  // system has been broken.  If you see one of these errors,
  // something is very broken.
  INTERNAL = 13,

  // Operation is not implemented or not supported/enabled in this service.
  UNAVAILABLE = 14,

  // Number of generic (non license related) errors.
  NUM_ERRORS,
};

}  // namespace error

class Status {
 public:

  Status() = default;

  ~Status() = default;

  explicit Status(error::StatusCode c) : status_code_(c) {}

  Status(error::StatusCode c, const std::string& error_message)
      : status_code_(c), error_message_(error_message) {}

  Status(const util::ErrorSpace* e, error::StatusCode c,
         const std::string& error_message)
      : error_space_(e), status_code_(c), error_message_(error_message) {}

  Status(const util::ErrorSpace* e, int error,
         const std::string& error_message)
      : error_space_(e), status_code_(error), error_message_(error_message) {}

  bool ok() const { return status_code_ == error::OK; }
  const util::ErrorSpace* error_space() const { return error_space_; }
  static const util::ErrorSpace* canonical_space();
  std::string ToString() const;
  std::string error_message() const { return error_message_; }
  int error_code() const { return status_code_; }

 private:
  const util::ErrorSpace* error_space_ = canonical_space();
  int status_code_ = error::OK;
  std::string error_message_;
};

inline Status OkStatus() { return Status(); }

inline bool operator==(const Status& s1, const Status& s2) {
  return s1.error_space() == s2.error_space() &&
         s1.error_code() == s2.error_code() &&
         s1.error_message() == s2.error_message();
}
inline bool operator!=(const Status& s1, const Status& s2) {
  return !(s1 == s2);
}


// Prints a human-readable representation of 'x' to 'os'.
std::ostream& operator<<(std::ostream& os, const Status& x);

#define CHECK_OK(expression) CHECK(expression.ok()) << expression.ToString()


}  // namespace widevine

#endif  // COMMON_STATUS_H_