// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.
//
// A Status encapsulates the result of an operation.  It may indicate success,
// or it may indicate an error with an associated error message.
//
// Multiple threads can invoke const methods on a Status without
// external synchronization, but if any of the threads may call a
// non-const method, all threads accessing the same Status must use
// external synchronization.

#ifndef KUDU_UTIL_STATUS_H_
#define KUDU_UTIL_STATUS_H_

// NOTE: using stdint.h instead of cstdint and errno.h instead of cerrno because
// this file is supposed to be processed by a compiler lacking C++11 support.
#include <errno.h>
#include <stdint.h>

#include <cstddef>
#include <string>

// This macro is not defined when status.h is consumed by third party applications.
#ifdef KUDU_HEADERS_USE_SHORT_STATUS_MACROS
#include <glog/logging.h>
#endif

#ifdef KUDU_HEADERS_NO_STUBS
#include "kudu/gutil/macros.h"
#include "kudu/gutil/port.h"
#else
#include "kudu/client/stubs.h"
#endif

#include "kudu/util/kudu_export.h"
#include "kudu/util/slice.h"

/// @brief Return the given status if it is not @c OK.
#define KUDU_RETURN_NOT_OK(s) do { \
    const ::kudu::Status& _s = (s);             \
    if (PREDICT_FALSE(!_s.ok())) return _s;     \
  } while (0)

/// @brief Return the given status if it is not OK, but first clone it and
///   prepend the given message.
#define KUDU_RETURN_NOT_OK_PREPEND(s, msg) do { \
    const ::kudu::Status& _s = (s);                              \
    if (PREDICT_FALSE(!_s.ok())) return _s.CloneAndPrepend(msg); \
  } while (0)

/// @brief Return @c to_return if @c to_call returns a bad status.
///   The substitution for 'to_return' may reference the variable
///   @c s for the bad status.
#define KUDU_RETURN_NOT_OK_RET(to_call, to_return) do { \
    const ::kudu::Status& s = (to_call);                \
    if (PREDICT_FALSE(!s.ok())) return (to_return);  \
  } while (0)

/// @brief Return the given status if it is not OK, evaluating `on_error` if so.
#define KUDU_RETURN_NOT_OK_EVAL(s, on_error) do { \
    const ::kudu::Status& _s = (s); \
    if (PREDICT_FALSE(!_s.ok())) { \
      (on_error); \
      return _s; \
    } \
  } while (0)

/// @brief Emit a warning if @c to_call returns a bad status.
#define KUDU_WARN_NOT_OK(to_call, warning_prefix) do { \
    const ::kudu::Status& _s = (to_call);              \
    if (PREDICT_FALSE(!_s.ok())) { \
      KUDU_LOG(WARNING) << (warning_prefix) << ": " << _s.ToString();  \
    } \
  } while (0)

/// @brief Log the given status and return immediately.
#define KUDU_LOG_AND_RETURN(level, status) do { \
    const ::kudu::Status& _s = (status);        \
    KUDU_LOG(level) << _s.ToString(); \
    return _s; \
  } while (0)

/// @brief If the given status is not OK, log it and 'msg' at 'level' and return the status.
#define KUDU_RETURN_NOT_OK_LOG(s, level, msg) do { \
    const ::kudu::Status& _s = (s);             \
    if (PREDICT_FALSE(!_s.ok())) { \
      KUDU_LOG(level) << "Status: " << _s.ToString() << " " << (msg); \
      return _s;     \
    } \
  } while (0)

/// @brief If @c to_call returns a bad status, CHECK immediately with
///   a logged message of @c msg followed by the status.
#define KUDU_CHECK_OK_PREPEND(to_call, msg) do { \
    const ::kudu::Status& _s = (to_call);                   \
    KUDU_CHECK(_s.ok()) << (msg) << ": " << _s.ToString();  \
  } while (0)

/// @brief If the status is bad, CHECK immediately, appending the status to the
///   logged message.
#define KUDU_CHECK_OK(s) KUDU_CHECK_OK_PREPEND(s, "Bad status")

/// @brief If @c to_call returns a bad status, DCHECK immediately with
///   a logged message of @c msg followed by the status.
#define KUDU_DCHECK_OK_PREPEND(to_call, msg) do { \
    const ::kudu::Status& _s = (to_call);                   \
    KUDU_DCHECK(_s.ok()) << (msg) << ": " << _s.ToString();  \
  } while (0)

/// @brief If the status is bad, DCHECK immediately, appending the status to the
///   logged 'Bad status' message.
#define KUDU_DCHECK_OK(s) KUDU_DCHECK_OK_PREPEND(s, "Bad status")

/// @brief A macro to use at the main() function level if it's necessary to
///   return a non-zero status from the main() based on the non-OK status 's'
///   and extra message 'msg' prepended. The desired return code is passed as
///   'ret_code' parameter.
#define KUDU_RETURN_MAIN_NOT_OK(to_call, msg, ret_code) do { \
    DCHECK_NE(0, (ret_code)) << "non-OK return code should not be 0"; \
    const ::kudu::Status& _s = (to_call); \
    if (!_s.ok()) { \
      const ::kudu::Status& _ss = _s.CloneAndPrepend((msg)); \
      LOG(ERROR) << _ss.ToString(); \
      return (ret_code); \
    } \
  } while (0)

/// @file status.h
///
/// This header is used in both the Kudu build as well as in builds of
/// applications that use the Kudu C++ client. In the latter we need to be
/// careful to "namespace" our macros, to avoid colliding or overriding with
/// similarly named macros belonging to the application.
///
/// KUDU_HEADERS_USE_SHORT_STATUS_MACROS handles this behavioral change. When
/// defined, we're building Kudu and:
/// @li Non-namespaced macros are allowed and mapped to the namespaced versions
///   defined above.
/// @li Namespaced versions of glog macros are mapped to the real glog macros
///   (otherwise the macros are defined in the C++ client stubs).
#ifdef KUDU_HEADERS_USE_SHORT_STATUS_MACROS
#define RETURN_NOT_OK         KUDU_RETURN_NOT_OK
#define RETURN_NOT_OK_PREPEND KUDU_RETURN_NOT_OK_PREPEND
#define RETURN_NOT_OK_RET     KUDU_RETURN_NOT_OK_RET
#define RETURN_NOT_OK_EVAL    KUDU_RETURN_NOT_OK_EVAL
#define WARN_NOT_OK           KUDU_WARN_NOT_OK
#define LOG_AND_RETURN        KUDU_LOG_AND_RETURN
#define RETURN_NOT_OK_LOG     KUDU_RETURN_NOT_OK_LOG
#define CHECK_OK_PREPEND      KUDU_CHECK_OK_PREPEND
#define CHECK_OK              KUDU_CHECK_OK
#define DCHECK_OK_PREPEND     KUDU_DCHECK_OK_PREPEND
#define DCHECK_OK             KUDU_DCHECK_OK
#define RETURN_MAIN_NOT_OK    KUDU_RETURN_MAIN_NOT_OK

// These are standard glog macros.
#define KUDU_LOG              LOG
#define KUDU_CHECK            CHECK
#define KUDU_DCHECK           DCHECK
#endif

namespace kudu {

/// @brief A representation of an operation's outcome.
class KUDU_EXPORT Status {
 public:
  /// Create an object representing success status.
  Status() : state_(NULL) { }

  ~Status() { delete[] state_; }

  /// Copy the specified status.
  ///
  /// @param [in] s
  ///   The status object to copy from.
  Status(const Status& s);

  /// Assign the specified status.
  ///
  /// @param [in] s
  ///   The status object to assign from.
  /// @return The reference to the modified object.
  Status& operator=(const Status& s);

#if __cplusplus >= 201103L
  /// Move the specified status (C++11).
  ///
  /// @param [in] s
  ///   rvalue reference to a Status object.
  Status(Status&& s) noexcept;

  /// Assign the specified status using move semantics (C++11).
  ///
  /// @param [in] s
  ///   rvalue reference to a Status object.
  /// @return The reference to the modified object.
  Status& operator=(Status&& s) noexcept;

  /// If this status is OK, calls 'op' and returns the result, otherwise returns
  /// this status.
  ///
  /// This method can be used to chain together multiple Status-returning
  /// operations, short circuiting after the first one to fail.
  ///
  /// Example:
  ///
  /// @code
  /// unique_ptr<SequentialFile> file;
  /// Status s = Env::Default()
  ///               ->NewSequentialFile("/tmp/example.txt", &file)
  ///               .AndThen([&] {
  ///                 return file->Write(0, "some data")
  ///                             .CloneAndPrepend("failed to write to example file");
  ///               });
  /// @endcode
  ///
  /// @param [in] op
  ///   Status-returning closure or function to run.
  /// @return 'this', if this is not OK, or the result of running op.
  template<typename F>
  Status AndThen(F op) {
    if (ok()) {
      return op();
    }
    return *this;
  }
#endif

  /// @return A success status.
  static Status OK() { return Status(); }

  /// @name Methods to build status objects for various types of errors.
  ///@{

  /// @param [in] msg
  ///   The informational message on the error.
  /// @param [in] msg2
  ///   Additional information on the error (optional).
  /// @param [in] posix_code
  ///   POSIX error code, if applicable (optional).
  /// @return The error status of an appropriate type.
  static Status NotFound(const Slice& msg, const Slice& msg2 = Slice(),
                         int16_t posix_code = -1) {
    return Status(kNotFound, msg, msg2, posix_code);
  }
  static Status Corruption(const Slice& msg, const Slice& msg2 = Slice(),
                         int16_t posix_code = -1) {
    return Status(kCorruption, msg, msg2, posix_code);
  }
  static Status NotSupported(const Slice& msg, const Slice& msg2 = Slice(),
                         int16_t posix_code = -1) {
    return Status(kNotSupported, msg, msg2, posix_code);
  }
  static Status InvalidArgument(const Slice& msg, const Slice& msg2 = Slice(),
                         int16_t posix_code = -1) {
    return Status(kInvalidArgument, msg, msg2, posix_code);
  }
  static Status IOError(const Slice& msg, const Slice& msg2 = Slice(),
                         int16_t posix_code = -1) {
    return Status(kIOError, msg, msg2, posix_code);
  }
  static Status AlreadyPresent(const Slice& msg, const Slice& msg2 = Slice(),
                         int16_t posix_code = -1) {
    return Status(kAlreadyPresent, msg, msg2, posix_code);
  }
  static Status RuntimeError(const Slice& msg, const Slice& msg2 = Slice(),
                         int16_t posix_code = -1) {
    return Status(kRuntimeError, msg, msg2, posix_code);
  }
  static Status NetworkError(const Slice& msg, const Slice& msg2 = Slice(),
                         int16_t posix_code = -1) {
    return Status(kNetworkError, msg, msg2, posix_code);
  }
  static Status IllegalState(const Slice& msg, const Slice& msg2 = Slice(),
                         int16_t posix_code = -1) {
    return Status(kIllegalState, msg, msg2, posix_code);
  }
  static Status NotAuthorized(const Slice& msg, const Slice& msg2 = Slice(),
                         int16_t posix_code = -1) {
    return Status(kNotAuthorized, msg, msg2, posix_code);
  }
  static Status Aborted(const Slice& msg, const Slice& msg2 = Slice(),
                         int16_t posix_code = -1) {
    return Status(kAborted, msg, msg2, posix_code);
  }
  static Status RemoteError(const Slice& msg, const Slice& msg2 = Slice(),
                         int16_t posix_code = -1) {
    return Status(kRemoteError, msg, msg2, posix_code);
  }
  static Status ServiceUnavailable(const Slice& msg, const Slice& msg2 = Slice(),
                         int16_t posix_code = -1) {
    return Status(kServiceUnavailable, msg, msg2, posix_code);
  }
  static Status TimedOut(const Slice& msg, const Slice& msg2 = Slice(),
                         int16_t posix_code = -1) {
    return Status(kTimedOut, msg, msg2, posix_code);
  }
  static Status Uninitialized(const Slice& msg, const Slice& msg2 = Slice(),
                              int16_t posix_code = -1) {
    return Status(kUninitialized, msg, msg2, posix_code);
  }
  static Status ConfigurationError(const Slice& msg, const Slice& msg2 = Slice(),
                                   int16_t posix_code = -1) {
    return Status(kConfigurationError, msg, msg2, posix_code);
  }
  static Status Incomplete(const Slice& msg, const Slice& msg2 = Slice(),
                           int64_t posix_code = -1) {
    return Status(kIncomplete, msg, msg2, posix_code);
  }
  static Status EndOfFile(const Slice& msg, const Slice& msg2 = Slice(),
                          int64_t posix_code = -1) {
    return Status(kEndOfFile, msg, msg2, posix_code);
  }
  static Status Immutable(const Slice& msg, const Slice& msg2 = Slice(),
                          int64_t posix_code = -1) {
    return Status(kImmutable, msg, msg2, posix_code);
  }
  ///@}

  /// @return @c true iff the status indicates success.
  bool ok() const { return (state_ == NULL); }

  /// @return @c true iff the status indicates a NotFound error.
  bool IsNotFound() const { return code() == kNotFound; }

  /// @return @c true iff the status indicates a Corruption error.
  bool IsCorruption() const { return code() == kCorruption; }

  /// @return @c true iff the status indicates a NotSupported error.
  bool IsNotSupported() const { return code() == kNotSupported; }

  /// @return @c true iff the status indicates an IOError.
  bool IsIOError() const { return code() == kIOError; }

  /// @return @c true iff the status indicates an InvalidArgument error.
  bool IsInvalidArgument() const { return code() == kInvalidArgument; }

  /// @return @c true iff the status indicates an AlreadyPresent error.
  bool IsAlreadyPresent() const { return code() == kAlreadyPresent; }

  /// @return @c true iff the status indicates a RuntimeError.
  bool IsRuntimeError() const { return code() == kRuntimeError; }

  /// @return @c true iff the status indicates a NetworkError.
  bool IsNetworkError() const { return code() == kNetworkError; }

  /// @return @c true iff the status indicates an IllegalState error.
  bool IsIllegalState() const { return code() == kIllegalState; }

  /// @return @c true iff the status indicates a NotAuthorized error.
  bool IsNotAuthorized() const { return code() == kNotAuthorized; }

  /// @return @c true iff the status indicates an Aborted error.
  bool IsAborted() const { return code() == kAborted; }

  /// @return @c true iff the status indicates a RemoteError.
  bool IsRemoteError() const { return code() == kRemoteError; }

  /// @return @c true iff the status indicates ServiceUnavailable.
  bool IsServiceUnavailable() const { return code() == kServiceUnavailable; }

  /// @return @c true iff the status indicates TimedOut.
  bool IsTimedOut() const { return code() == kTimedOut; }

  /// @return @c true iff the status indicates Uninitialized.
  bool IsUninitialized() const { return code() == kUninitialized; }

  /// @return @c true iff the status indicates ConfigurationError.
  bool IsConfigurationError() const { return code() == kConfigurationError; }

  /// @return @c true iff the status indicates Incomplete.
  bool IsIncomplete() const { return code() == kIncomplete; }

  /// @return @c true iff the status indicates end of file.
  bool IsEndOfFile() const { return code() == kEndOfFile; }

  /// @return @c true iff the status indicates immutable.
  bool IsImmutable() const { return code() == kImmutable; }

  /// @return @c true iff the status indicates a disk failure.
  bool IsDiskFailure() const {
    switch (posix_code()) {
      case EIO:
      case ENODEV:
      case ENXIO:
      case EROFS:
        return true;
    }
    return false;
  }

  /// @return A string representation of this status suitable for printing.
  ///   Returns the string "OK" for success.
  std::string ToString() const;

  /// @return A string representation of the status code, without the message
  ///   text or POSIX code information.
  std::string CodeAsString() const;

  /// This is similar to ToString, except that it does not include
  /// the stringified error code or POSIX code.
  ///
  /// @note The returned Slice is only valid as long as this Status object
  ///   remains live and unchanged.
  ///
  /// @return The message portion of the Status. For @c OK statuses,
  ///   this returns an empty string.
  Slice message() const;

  /// @return The POSIX code associated with this Status object,
  ///   or @c -1 if there is none.
  int16_t posix_code() const;

  /// Clone this status and add the specified prefix to the message.
  ///
  /// If this status is OK, then an OK status will be returned.
  ///
  /// @param [in] msg
  ///   The message to prepend.
  /// @return A new Status object with the same state plus an additional
  ///   leading message.
  Status CloneAndPrepend(const Slice& msg) const;

  /// Clone this status and add the specified suffix to the message.
  ///
  /// If this status is OK, then an OK status will be returned.
  ///
  /// @param [in] msg
  ///   The message to append.
  /// @return A new Status object with the same state plus an additional
  ///   trailing message.
  Status CloneAndAppend(const Slice& msg) const;

  /// @return The memory usage of this object without the object itself.
  ///   Should be used when embedded inside another object.
  size_t memory_footprint_excluding_this() const;

  /// @return The memory usage of this object including the object itself.
  ///   Should be used when allocated on the heap.
  size_t memory_footprint_including_this() const;

 private:
  // OK status has a NULL state_.  Otherwise, state_ is a new[] array
  // of the following form:
  //    state_[0..3] == length of message
  //    state_[4]    == code
  //    state_[5..6] == posix_code
  //    state_[7..]  == message
  const char* state_;

  enum Code {
    kOk = 0,
    kNotFound = 1,
    kCorruption = 2,
    kNotSupported = 3,
    kInvalidArgument = 4,
    kIOError = 5,
    kAlreadyPresent = 6,
    kRuntimeError = 7,
    kNetworkError = 8,
    kIllegalState = 9,
    kNotAuthorized = 10,
    kAborted = 11,
    kRemoteError = 12,
    kServiceUnavailable = 13,
    kTimedOut = 14,
    kUninitialized = 15,
    kConfigurationError = 16,
    kIncomplete = 17,
    kEndOfFile = 18,
    // kCancelled stems from AppStatusPB, although it seems nobody use it now, we still reserve it.
    // kCancelled = 19,
    kImmutable = 20,
    // NOTE: Remember to duplicate these constants into wire_protocol.proto and
    // and to add StatusTo/FromPB ser/deser cases in wire_protocol.cc !
    // Also remember to make the same changes to the java client in Status.java.
    //
    // TODO: Move error codes into an error_code.proto or something similar.
  };
  COMPILE_ASSERT(sizeof(Code) == 4, code_enum_size_is_part_of_abi);

  Code code() const {
    return (state_ == NULL) ? kOk : static_cast<Code>(state_[4]);
  }

  Status(Code code, const Slice& msg, const Slice& msg2, int16_t posix_code);
  static const char* CopyState(const char* s);
};

inline Status::Status(const Status& s) {
  state_ = (s.state_ == NULL) ? NULL : CopyState(s.state_);
}

inline Status& Status::operator=(const Status& s) {
  // The following condition catches both aliasing (when this == &s),
  // and the common case where both s and *this are OK.
  if (state_ != s.state_) {
    delete[] state_;
    state_ = (s.state_ == NULL) ? NULL : CopyState(s.state_);
  }
  return *this;
}

#if __cplusplus >= 201103L
inline Status::Status(Status&& s) noexcept : state_(s.state_) {
  s.state_ = nullptr;
}

inline Status& Status::operator=(Status&& s) noexcept {
  if (state_ != s.state_) {
    delete[] state_;
    state_ = s.state_;
    s.state_ = nullptr;
  }
  return *this;
}
#endif

}  // namespace kudu

#endif  // KUDU_UTIL_STATUS_H_