// Copyright 2017 The PDFium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com

#include "core/fxcrt/fx_system.h"

#include <math.h>

#include <limits>

#include "build/build_config.h"
#include "core/fxcrt/compiler_specific.h"
#include "core/fxcrt/fx_extension.h"

namespace {

#if !BUILDFLAG(IS_WIN)
uint32_t g_last_error = 0;
#endif

template <typename IntType, typename CharType>
IntType FXSYS_StrToInt(const CharType* str) {
  if (!str) {
    return 0;
  }

  // Process the sign.
  bool neg = *str == '-';
  if (neg || *str == '+') {
    // SAFETY: `str` points at the start of the string, which is a character or
    // a terminating NUL. `*str` is non-NUL from the condition above, so `str`
    // is pointing inside the string. Afterward, `str` may be pointing at the
    // terminating NUL.
    UNSAFE_BUFFERS(str++);
  }

  IntType num = 0;
  while (*str && FXSYS_IsDecimalDigit(*str)) {
    IntType val = FXSYS_DecimalCharToInt(*str);
    if (num > (std::numeric_limits<IntType>::max() - val) / 10) {
      if (neg && std::numeric_limits<IntType>::is_signed) {
        // Return MIN when the represented number is signed type and is smaller
        // than the min value.
        return std::numeric_limits<IntType>::min();
      }
      // Return MAX when the represented number is signed type and is larger
      // than the max value, or the number is unsigned type and out of range.
      return std::numeric_limits<IntType>::max();
    }
    num = num * 10 + val;

    // SAFETY: The loop terminates if `str` is ever pointing at the terminating
    // NUL. `str` is only moved by one character at a time, so inside the loop
    // `str` always points inside the string.
    UNSAFE_BUFFERS(str++);
  }
  // When it is a negative value, -num should be returned. Since num may be of
  // unsigned type, use ~num + 1 to avoid the warning of applying unary minus
  // operator to unsigned type.
  return neg ? ~num + 1 : num;
}

template <typename T, typename UT, typename STR_T>
STR_T FXSYS_IntToStr(T value, STR_T str, int radix) {
  if (radix < 2 || radix > 16) {
    str[0] = 0;
    return str;
  }
  if (value == 0) {
    str[0] = '0';
    UNSAFE_TODO(str[1]) = 0;
    return str;
  }
  int i = 0;
  UT uvalue;
  if (value < 0) {
    UNSAFE_TODO(str[i++]) = '-';
    // Standard trick to avoid undefined behaviour when negating INT_MIN.
    uvalue = static_cast<UT>(-(value + 1)) + 1;
  } else {
    uvalue = value;
  }
  int digits = 1;
  T order = uvalue / radix;
  while (order > 0) {
    digits++;
    order = order / radix;
  }
  for (int d = digits - 1; d > -1; d--) {
    UNSAFE_TODO(str[d + i] = "0123456789abcdef"[uvalue % radix]);
    uvalue /= radix;
  }
  UNSAFE_TODO(str[digits + i]) = 0;
  return str;
}

}  // namespace

int FXSYS_roundf(float f) {
  if (std::isnan(f)) {
    return 0;
  }
  if (f < static_cast<float>(std::numeric_limits<int>::min())) {
    return std::numeric_limits<int>::min();
  }
  if (f >= static_cast<float>(std::numeric_limits<int>::max())) {
    return std::numeric_limits<int>::max();
  }
  return static_cast<int>(round(f));
}

int FXSYS_round(double d) {
  if (std::isnan(d)) {
    return 0;
  }
  if (d < static_cast<double>(std::numeric_limits<int>::min())) {
    return std::numeric_limits<int>::min();
  }
  if (d >= static_cast<double>(std::numeric_limits<int>::max())) {
    return std::numeric_limits<int>::max();
  }
  return static_cast<int>(round(d));
}

int32_t FXSYS_atoi(const char* str) {
  return FXSYS_StrToInt<int32_t, char>(str);
}
uint32_t FXSYS_atoui(const char* str) {
  return FXSYS_StrToInt<uint32_t>(str);
}
int32_t FXSYS_wtoi(const wchar_t* str) {
  return FXSYS_StrToInt<int32_t, wchar_t>(str);
}
int64_t FXSYS_atoi64(const char* str) {
  return FXSYS_StrToInt<int64_t, char>(str);
}
const char* FXSYS_i64toa(int64_t value, char* str, int radix) {
  return FXSYS_IntToStr<int64_t, uint64_t, char*>(value, str, radix);
}

#if BUILDFLAG(IS_WIN)

size_t FXSYS_wcsftime(wchar_t* strDest,
                      size_t maxsize,
                      const wchar_t* format,
                      const struct tm* timeptr) {
  // Avoid tripping an invalid parameter handler and crashing process.
  // Note: leap seconds may cause tm_sec == 60.
  if (timeptr->tm_year < -1900 || timeptr->tm_year > 8099 ||
      timeptr->tm_mon < 0 || timeptr->tm_mon > 11 || timeptr->tm_mday < 1 ||
      timeptr->tm_mday > 31 || timeptr->tm_hour < 0 || timeptr->tm_hour > 23 ||
      timeptr->tm_min < 0 || timeptr->tm_min > 59 || timeptr->tm_sec < 0 ||
      timeptr->tm_sec > 60 || timeptr->tm_wday < 0 || timeptr->tm_wday > 6 ||
      timeptr->tm_yday < 0 || timeptr->tm_yday > 365) {
    strDest[0] = L'\0';
    return 0;
  }
  return wcsftime(strDest, maxsize, format, timeptr);
}

int FXSYS_stricmp(const char* str1, const char* str2) {
  return _stricmp(str1, str2);
}

int FXSYS_wcsicmp(const wchar_t* str1, const wchar_t* str2) {
  return _wcsicmp(str1, str2);
}

#else   // BUILDFLAG(IS_WIN)

char* FXSYS_strlwr(char* str) {
  if (!str) {
    return nullptr;
  }
  char* s = str;
  while (*str) {
    *str = tolower(*str);
    UNSAFE_BUFFERS(str++);  // SAFETY: NUL check in while condition.
  }
  return s;
}

char* FXSYS_strupr(char* str) {
  if (!str) {
    return nullptr;
  }
  char* s = str;
  while (*str) {
    *str = toupper(*str);
    UNSAFE_BUFFERS(str++);  // SAFETY: NUL check in while condition.
  }
  return s;
}

wchar_t* FXSYS_wcslwr(wchar_t* str) {
  if (!str) {
    return nullptr;
  }
  wchar_t* s = str;
  while (*str) {
    *str = FXSYS_towlower(*str);
    UNSAFE_BUFFERS(str++);  // SAFETY: NUL check in while condition.
  }
  return s;
}

wchar_t* FXSYS_wcsupr(wchar_t* str) {
  if (!str) {
    return nullptr;
  }
  wchar_t* s = str;
  while (*str) {
    *str = FXSYS_towupper(*str);
    UNSAFE_BUFFERS(str++);  // SAFETY: NUL check in while condition.
  }
  return s;
}

int FXSYS_stricmp(const char* str1, const char* str2) {
  int f;
  int l;
  do {
    f = toupper(*str1);
    l = toupper(*str2);
    // SAFETY: The loop breaks when `*str1` is NUL, so `str1` is always inside
    // its string.
    UNSAFE_BUFFERS(++str1);
    // SAFETY: The loop breaks when `*str1` is non-NUL but `*str2` is NUL (as
    // checked by `f != l`), so `str2` is always inside its string.
    UNSAFE_BUFFERS(++str2);
  } while (f && f == l);
  return f - l;
}

int FXSYS_wcsicmp(const wchar_t* str1, const wchar_t* str2) {
  wchar_t f;
  wchar_t l;
  do {
    f = FXSYS_towupper(*str1);
    l = FXSYS_towupper(*str2);
    // SAFETY: The loop breaks when `*str1` is NUL, so `str1` is always inside
    // its string.
    UNSAFE_BUFFERS(++str1);
    // SAFETY: The loop breaks when `*str1` is non-NUL but `*str2` is NUL (as
    // checked by `f != l`), so `str2` is always inside its string.
    UNSAFE_BUFFERS(++str2);
  } while (f && f == l);
  return f - l;
}

char* FXSYS_itoa(int value, char* str, int radix) {
  return FXSYS_IntToStr<int32_t, uint32_t, char*>(value, str, radix);
}

void FXSYS_SetLastError(uint32_t err) {
  g_last_error = err;
}

uint32_t FXSYS_GetLastError() {
  return g_last_error;
}
#endif  // BUILDFLAG(IS_WIN)

float FXSYS_sqrt2(float a, float b) {
  return sqrtf(a * a + b * b);
}
