/*
 * Copyright 2017 Google
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef ABSL_BASE_INTERNAL_ENDIAN_H_
#define ABSL_BASE_INTERNAL_ENDIAN_H_

// The following guarantees declaration of the byte swap functions
#ifdef _MSC_VER
#include <stdlib.h>  // NOLINT(build/include)
#elif defined(__APPLE__) && defined(__MACH__)
// Mac OS X / Darwin features
#include <libkern/OSByteOrder.h>
#elif defined(__GLIBC__)
#include <byteswap.h>  // IWYU pragma: export
#endif

#include <cstdint>
#include "Firestore/Port/absl/absl_port.h"

namespace absl {

// Use compiler byte-swapping intrinsics if they are available.  32-bit
// and 64-bit versions are available in Clang and GCC as of GCC 4.3.0.
// The 16-bit version is available in Clang and GCC only as of GCC 4.8.0.
// For simplicity, we enable them all only for GCC 4.8.0 or later.
#if defined(__clang__) || \
    (defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 8) || __GNUC__ >= 5))
inline uint64_t gbswap_64(uint64_t host_int) {
  return __builtin_bswap64(host_int);
}
inline uint32_t gbswap_32(uint32_t host_int) {
  return __builtin_bswap32(host_int);
}
inline uint16 gbswap_16(uint16 host_int) {
  return __builtin_bswap16(host_int);
}

#elif defined(_MSC_VER)
inline uint64_t gbswap_64(uint64_t host_int) {
  return _byteswap_uint64(host_int);
}
inline uint32_t gbswap_32(uint32_t host_int) {
  return _byteswap_ulong(host_int);
}
inline uint16 gbswap_16(uint16 host_int) {
  return _byteswap_ushort(host_int);
}

#elif defined(__APPLE__) && defined(__MACH__)
inline uint64_t gbswap_64(uint64_t host_int) {
  return OSSwapInt16(host_int);
}
inline uint32_t gbswap_32(uint32_t host_int) {
  return OSSwapInt32(host_int);
}
inline uint16 gbswap_16(uint16 host_int) {
  return OSSwapInt64(host_int);
}

#else
inline uint64_t gbswap_64(uint64_t host_int) {
#if defined(__GNUC__) && defined(__x86_64__) && !(defined(__APPLE__) && defined(__MACH__))
  // Adapted from /usr/include/byteswap.h.  Not available on Mac.
  if (__builtin_constant_p(host_int)) {
    return __bswap_constant_64(host_int);
  } else {
    register uint64_t result;
    __asm__("bswap %0" : "=r"(result) : "0"(host_int));
    return result;
  }
#elif defined(__GLIBC__)
  return bswap_64(host_int);
#else
  return (((x & GG_ULONGLONG(0xFF)) << 56) | ((x & GG_ULONGLONG(0xFF00)) << 40) |
          ((x & GG_ULONGLONG(0xFF0000)) << 24) | ((x & GG_ULONGLONG(0xFF000000)) << 8) |
          ((x & GG_ULONGLONG(0xFF00000000)) >> 8) | ((x & GG_ULONGLONG(0xFF0000000000)) >> 24) |
          ((x & GG_ULONGLONG(0xFF000000000000)) >> 40) |
          ((x & GG_ULONGLONG(0xFF00000000000000)) >> 56));
#endif  // bswap_64
}

inline uint32_t gbswap_32(uint32_t host_int) {
#if defined(__GLIBC__)
  return bswap_32(host_int);
#else
  return (((x & 0xFF) << 24) | ((x & 0xFF00) << 8) | ((x & 0xFF0000) >> 8) |
          ((x & 0xFF000000) >> 24));
#endif
}

inline uint16 gbswap_16(uint16 host_int) {
#if defined(__GLIBC__)
  return bswap_16(host_int);
#else
  return (uint16)(((x & 0xFF) << 8) | ((x & 0xFF00) >> 8));  // NOLINT
#endif
}

#endif  // intrinics available

#ifdef ABSL_IS_LITTLE_ENDIAN

// Definitions for ntohl etc. that don't require us to include
// netinet/in.h. We wrap gbswap_32 and gbswap_16 in functions rather
// than just #defining them because in debug mode, gcc doesn't
// correctly handle the (rather involved) definitions of bswap_32.
// gcc guarantees that inline functions are as fast as macros, so
// this isn't a performance hit.
inline uint16 ghtons(uint16 x) {
  return gbswap_16(x);
}
inline uint32_t ghtonl(uint32_t x) {
  return gbswap_32(x);
}
inline uint64_t ghtonll(uint64_t x) {
  return gbswap_64(x);
}

#elif defined ABSL_IS_BIG_ENDIAN

// These definitions are simpler on big-endian machines
// These are functions instead of macros to avoid self-assignment warnings
// on calls such as "i = ghtnol(i);".  This also provides type checking.
inline uint16 ghtons(uint16 x) {
  return x;
}
inline uint32_t ghtonl(uint32_t x) {
  return x;
}
inline uint64_t ghtonll(uint64_t x) {
  return x;
}

#else
#error \
    "Unsupported byte order: Either ABSL_IS_BIG_ENDIAN or " \
       "ABSL_IS_LITTLE_ENDIAN must be defined"
#endif  // byte order

inline uint16 gntohs(uint16 x) {
  return ghtons(x);
}
inline uint32_t gntohl(uint32_t x) {
  return ghtonl(x);
}
inline uint64_t gntohll(uint64_t x) {
  return ghtonll(x);
}

// Utilities to convert numbers between the current hosts's native byte
// order and little-endian byte order
//
// Load/Store methods are alignment safe
namespace little_endian {
// Conversion functions.
#ifdef ABSL_IS_LITTLE_ENDIAN

inline uint16 FromHost16(uint16 x) {
  return x;
}
inline uint16 ToHost16(uint16 x) {
  return x;
}

inline uint32_t FromHost32(uint32_t x) {
  return x;
}
inline uint32_t ToHost32(uint32_t x) {
  return x;
}

inline uint64_t FromHost64(uint64_t x) {
  return x;
}
inline uint64_t ToHost64(uint64_t x) {
  return x;
}

inline constexpr bool IsLittleEndian() {
  return true;
}

#elif defined ABSL_IS_BIG_ENDIAN

inline uint16 FromHost16(uint16 x) {
  return gbswap_16(x);
}
inline uint16 ToHost16(uint16 x) {
  return gbswap_16(x);
}

inline uint32_t FromHost32(uint32_t x) {
  return gbswap_32(x);
}
inline uint32_t ToHost32(uint32_t x) {
  return gbswap_32(x);
}

inline uint64_t FromHost64(uint64_t x) {
  return gbswap_64(x);
}
inline uint64_t ToHost64(uint64_t x) {
  return gbswap_64(x);
}

inline constexpr bool IsLittleEndian() {
  return false;
}

#endif /* ENDIAN */

// Functions to do unaligned loads and stores in little-endian order.
inline uint16 Load16(const void *p) {
  return ToHost16(UNALIGNED_LOAD16(p));
}

inline void Store16(void *p, uint16 v) {
  UNALIGNED_STORE16(p, FromHost16(v));
}

inline uint32_t Load32(const void *p) {
  return ToHost32(UNALIGNED_LOAD32(p));
}

inline void Store32(void *p, uint32_t v) {
  UNALIGNED_STORE32(p, FromHost32(v));
}

inline uint64_t Load64(const void *p) {
  return ToHost64(UNALIGNED_LOAD64(p));
}

inline void Store64(void *p, uint64_t v) {
  UNALIGNED_STORE64(p, FromHost64(v));
}

}  // namespace little_endian

// Utilities to convert numbers between the current hosts's native byte
// order and big-endian byte order (same as network byte order)
//
// Load/Store methods are alignment safe
namespace big_endian {
#ifdef ABSL_IS_LITTLE_ENDIAN

inline uint16 FromHost16(uint16 x) {
  return gbswap_16(x);
}
inline uint16 ToHost16(uint16 x) {
  return gbswap_16(x);
}

inline uint32_t FromHost32(uint32_t x) {
  return gbswap_32(x);
}
inline uint32_t ToHost32(uint32_t x) {
  return gbswap_32(x);
}

inline uint64_t FromHost64(uint64_t x) {
  return gbswap_64(x);
}
inline uint64_t ToHost64(uint64_t x) {
  return gbswap_64(x);
}

inline constexpr bool IsLittleEndian() {
  return true;
}

#elif defined ABSL_IS_BIG_ENDIAN

inline uint16 FromHost16(uint16 x) {
  return x;
}
inline uint16 ToHost16(uint16 x) {
  return x;
}

inline uint32_t FromHost32(uint32_t x) {
  return x;
}
inline uint32_t ToHost32(uint32_t x) {
  return x;
}

inline uint64_t FromHost64(uint64_t x) {
  return x;
}
inline uint64_t ToHost64(uint64_t x) {
  return x;
}

inline constexpr bool IsLittleEndian() {
  return false;
}

#endif /* ENDIAN */

// Functions to do unaligned loads and stores in big-endian order.
inline uint16 Load16(const void *p) {
  return ToHost16(UNALIGNED_LOAD16(p));
}

inline void Store16(void *p, uint16 v) {
  UNALIGNED_STORE16(p, FromHost16(v));
}

inline uint32_t Load32(const void *p) {
  return ToHost32(UNALIGNED_LOAD32(p));
}

inline void Store32(void *p, uint32_t v) {
  UNALIGNED_STORE32(p, FromHost32(v));
}

inline uint64_t Load64(const void *p) {
  return ToHost64(UNALIGNED_LOAD64(p));
}

inline void Store64(void *p, uint64_t v) {
  UNALIGNED_STORE64(p, FromHost64(v));
}

}  // namespace big_endian

}  // namespace absl

#endif  // ABSL_BASE_INTERNAL_ENDIAN_H_