/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include <cstdarg>

#ifdef _WIN32
#  include <windows.h>
#else
#  include <unistd.h>
#endif
#include <cmath>
#include <cstring>
#include "mozilla/Assertions.h"
#include "FdPrintf.h"

/* Template class allowing a limited number of increments on a value */
template <typename T>
class CheckedIncrement {
 public:
  CheckedIncrement(T aValue, size_t aMaxIncrement)
      : mValue(aValue), mMaxIncrement(aMaxIncrement) {}

  T operator++(int) {
    if (!mMaxIncrement) {
      MOZ_CRASH("overflow detected");
    }
    mMaxIncrement--;
    return mValue++;
  }

  T& operator++() {
    (*this)++;
    return mValue;
  }

  void advance(T end) {
    // Only makes sense if T is a pointer type.
    size_t diff = end - mValue;
    if (diff > mMaxIncrement) {
      MOZ_CRASH("overflow detected");
    }
    mMaxIncrement -= diff;
    mValue = end;
  }

  void rewind(T pos) {
    size_t diff = mValue - pos;
    mMaxIncrement += diff;
    mValue = pos;
  }

  operator T() { return mValue; }
  T value() { return mValue; }

 private:
  T mValue;
  size_t mMaxIncrement;
};

template <typename T>
static unsigned NumDigits(T n) {
  if (n < 1) {
    // We want one digit, it will be 0.
    return 1;
  }

  double l = log10(static_cast<double>(n));
  double cl = ceil(l);
  return l == cl ? unsigned(cl) + 1 : unsigned(cl);
}

static void LeftPad(CheckedIncrement<char*>& b, size_t pad) {
  while (pad-- > 0) {
    *(b++) = ' ';
  }
}

// Write the digits into the buffer.
static void WriteDigits(CheckedIncrement<char*>& b, size_t i,
                        size_t num_digits) {
  size_t x = pow(10, double(num_digits - 1));
  do {
    *(b++) = "0123456789"[(i / x) % 10];
    x /= 10;
  } while (x > 0);
}

int VSNPrintf(char* aBuf, size_t aSize, const char* aFormat, va_list aArgs) {
  CheckedIncrement<char*> b(aBuf, aSize);
  CheckedIncrement<const char*> f(aFormat, strlen(aFormat) + 1);
  while (true) {
    switch (*f) {
      case '\0':
        return b - aBuf;

      case '%': {
        // The start of the format specifier is used if this specifier is
        // invalid.
        const char* start = f;

        // Read the field width
        f++;
        char* end = nullptr;
        size_t width = strtoul(f, &end, 10);
        // If strtol can't find a number that's okay, that means 0 in our
        // case, but we must advance f).
        f.advance(end);

        switch (*f) {
          case 'z': {
            if (*(++f) == 'u') {
              size_t i = va_arg(aArgs, size_t);

              size_t num_digits = NumDigits(i);
              LeftPad(b, width > num_digits ? width - num_digits : 0);
              WriteDigits(b, i, num_digits);
            } else {
              // If the format specifier is unknown then write out '%' and
              // rewind to the beginning of the specifier causing it to be
              // printed normally.
              *(b++) = '%';
              f.rewind(start);
            }
            break;
          }

          case 'p': {
            intptr_t ptr = va_arg(aArgs, intptr_t);
            *(b++) = '0';
            *(b++) = 'x';
            int x = sizeof(intptr_t) * 8;
            bool wrote_msb = false;
            do {
              x -= 4;
              size_t hex_digit = ptr >> x & 0xf;
              if (hex_digit || wrote_msb) {
                *(b++) = "0123456789abcdef"[hex_digit];
                wrote_msb = true;
              }
            } while (x > 0);
            if (!wrote_msb) {
              *(b++) = '0';
            }
            break;
          }

          case 's': {
            const char* str = va_arg(aArgs, const char*);
            size_t len = strlen(str);

            LeftPad(b, width > len ? width - len : 0);

            while (*str) {
              *(b++) = *(str++);
            }

            break;
          }

          case '%':
            // Print a single raw '%'.
            *(b++) = '%';
            break;

          default:
            // If the format specifier is unknown then write out '%' and
            // rewind to the beginning of the specifier causing it to be
            // printed normally.
            *(b++) = '%';
            f.rewind(start);
            break;
        }
        break;
      }
      default:
        *(b++) = *f;
        break;
    }
    f++;
  }
}

int SNPrintf(char* aBuf, size_t aSize, const char* aFormat, ...) {
  va_list args;
  va_start(args, aFormat);
  int ret = VSNPrintf(aBuf, aSize, aFormat, args);
  va_end(args);
  return ret;
}

void VFdPrintf(platform_handle_t aFd, const char* aFormat, va_list aArgs) {
  char buf[256];
  int len = VSNPrintf(buf, 256, aFormat, aArgs);
  FdPuts(aFd, buf, len);
}

void FdPrintf(platform_handle_t aFd, const char* aFormat, ...) {
  va_list args;
  va_start(args, aFormat);
  VFdPrintf(aFd, aFormat, args);
  va_end(args);
}

void FdPuts(platform_handle_t aFd, const char* aBuf, size_t aSize) {
  if (aFd == 0) {
    return;
  }

#ifdef _WIN32
  // See comment in FdPrintf.h as to why WriteFile is used.
  DWORD written;
  WriteFile(aFd, aBuf, aSize, &written, nullptr);
#else
  [[maybe_unused]] ssize_t _ = write(aFd, aBuf, aSize);
#endif
}