// Copyright 2016 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/lib/fxl/strings/string_printf.h"

#include <assert.h>
#include <errno.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>

#include <memory>

namespace fxl {
namespace {

void StringVAppendfHelper(std::string* dest, const char* format, va_list ap) {
  // Size of the small stack buffer to use first. This should be kept in sync
  // with the numbers in StringPrintfTest.StringPrintf_Boundary.
  constexpr size_t kStackBufferSize = 1024u;

  // First, try with a small buffer on the stack.
  char stack_buf[kStackBufferSize];
  // Copy |ap| (which can only be used once), in case we need to retry.
  va_list ap_copy;
  va_copy(ap_copy, ap);
  int result = vsnprintf(stack_buf, kStackBufferSize, format, ap_copy);
  va_end(ap_copy);
  if (result < 0) {
    // As far as I can tell, we'd only get |EOVERFLOW| if the result is so large
    // that it can't be represented by an |int| (in which case retrying would be
    // futile), so Chromium's implementation is wrong.
    return;
  }
  // |result| should be the number of characters we need, not including the
  // terminating null. However, |vsnprintf()| always null-terminates!
  size_t output_size = static_cast<size_t>(result);
  // Check if the output fit into our stack buffer. This is "<" not "<=", since
  // |vsnprintf()| will null-terminate.
  if (output_size < kStackBufferSize) {
    // It fit.
    dest->append(stack_buf, static_cast<size_t>(result));
    return;
  }

  // Since we have the required output size, we can just heap allocate that.
  // (Add 1 because |vsnprintf()| will always null-terminate.)
  size_t heap_buf_size = output_size + 1u;
  std::unique_ptr<char[]> heap_buf(new char[heap_buf_size]);
  result = vsnprintf(heap_buf.get(), heap_buf_size, format, ap);
  if (result < 0 || static_cast<size_t>(result) > output_size) {
    assert(false);
    return;
  }
  assert(static_cast<size_t>(result) == output_size);
  dest->append(heap_buf.get(), static_cast<size_t>(result));
}

}  // namespace

std::string StringPrintf(const char* format, ...) {
  va_list ap;
  va_start(ap, format);
  std::string rv;
  StringVAppendf(&rv, format, ap);
  va_end(ap);
  return rv;
}

std::string StringVPrintf(const char* format, va_list ap) {
  std::string rv;
  StringVAppendf(&rv, format, ap);
  return rv;
}

void StringAppendf(std::string* dest, const char* format, ...) {
  va_list ap;
  va_start(ap, format);
  StringVAppendf(dest, format, ap);
  va_end(ap);
}

void StringVAppendf(std::string* dest, const char* format, va_list ap) {
  int old_errno = errno;
  StringVAppendfHelper(dest, format, ap);
  errno = old_errno;
}

}  // namespace fxl