////////////////////////////////////////////////////////////////////////////////
// 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 UTIL_STATUS_H_
#define UTIL_STATUS_H_

#include <string>

#include "util/error_space.h"

namespace widevine {
namespace util {
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,

  // 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 GenericErrorSpace : public ErrorSpaceImpl<GenericErrorSpace> {
 public:
  static std::string SpaceName();
  static std::string CodeToString(int code);
};

class Status {
 public:
  Status() : status_code_(error::OK) {}
  ~Status() {}
  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 ErrorSpace* e, error::StatusCode c,
         const std::string& error_message) {
    SetError(e, c, error_message);
  }
  Status(const ErrorSpace* e, int error, const std::string& error_message) {
    SetError(e, error, error_message);
  }
  void SetError(const ErrorSpace* e, int c, const std::string& error_message) {
    error_space_ = e;
    status_code_ = c;
    error_message_ = error_message;
  }

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

 private:
  const ErrorSpace* error_space_ = GenericErrorSpace::Get();
  int status_code_;
  std::string error_message_;
};  // class Status

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

// Here error_message_ is ignored during comparison.
inline bool operator==(const Status& s1, const Status& s2) {
  return s1.error_space() == s2.error_space() &&
         s1.error_code() == s2.error_code();
}
inline bool operator!=(const Status& s1, const Status& s2) {
  return s1.error_space() != s2.error_space() ||
         s1.error_code() != s2.error_code();
}

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

#define CHECK_OK(expression) CHECK_EQ(util::error::OK, expression.error_code())


}  // namespace util
}  // namespace widevine

#endif  // UTIL_STATUS_H_