// Copyright 2019 The Pigweed Authors

//

// 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

//

//     https://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.

#include "pw_string/string_builder.h"

#include <cstdio>

#include "pw_string/format.h"

#include "pw_string/util.h"

namespace pw {

void StringBuilder::clear() {

  *size_ = 0;

  NullTerminate();

  status_ = StatusCode(OkStatus());

  last_status_ = StatusCode(OkStatus());

}

StringBuilder& StringBuilder::append(size_t count, char ch) {

  char* const append_destination = buffer_.data() + size();

  std::fill_n(append_destination, ResizeAndTerminate(count), ch);

  return *this;

}

StringBuilder& StringBuilder::append(const char* str, size_t count) {

  char* const append_destination = buffer_.data() + size();

  std::copy_n(str, ResizeAndTerminate(count), append_destination);

  return *this;

}

StringBuilder& StringBuilder::append(const char* str) {

  // Use buffer_.size() - size() as the maximum length so that strings too long

  // to fit in the buffer will request one character too many, which sets the

  // status to RESOURCE_EXHAUSTED.

  return append(string::ClampedCString(str, buffer_.size() - size()));

}

StringBuilder& StringBuilder::append(std::string_view str) {

  return append(str.data(), str.size());

}

StringBuilder& StringBuilder::append(std::string_view str,

                                     size_t pos,

                                     size_t count) {

  if (pos > str.size()) {

    SetErrorStatus(Status::OutOfRange());

    return *this;

  }

  return append(str.data() + pos, std::min(str.size() - pos, count));

}

size_t StringBuilder::ResizeAndTerminate(size_t chars_to_append) {

  const size_t copied = std::min(chars_to_append, max_size() - size());

  // NOTE: `+=` is not used in order to avoid implicit integer conversion which

  // results in an error on some compilers.

  *size_ = static_cast<InlineString<>::size_type>(copied + *size_);

  NullTerminate();

  if (buffer_.empty() || chars_to_append != copied) {

    SetErrorStatus(Status::ResourceExhausted());

  } else {

    last_status_ = StatusCode(OkStatus());

  }

  return copied;

}

void StringBuilder::resize(size_t new_size) {

  if (new_size <= size()) {

    *size_ = static_cast<InlineString<>::size_type>(new_size);

    NullTerminate();

    last_status_ = StatusCode(OkStatus());

  } else {

    SetErrorStatus(Status::OutOfRange());

  }

}

StringBuilder& StringBuilder::Format(const char* format, ...) {

  va_list args;

  va_start(args, format);

  FormatVaList(format, args);

  va_end(args);

  return *this;

}

StringBuilder& StringBuilder::FormatVaList(const char* format, va_list args) {

  HandleStatusWithSize(

      string::FormatVaList(buffer_.subspan(size()), format, args));

  return *this;

}

void StringBuilder::WriteBytes(span<const std::byte> data) {

  if (size() + data.size() * 2 > max_size()) {

    SetErrorStatus(Status::ResourceExhausted());

  } else {

    for (std::byte val : data) {

      *this << val;

    }

  }

}

void StringBuilder::CopySizeAndStatus(const StringBuilder& other) {

  *size_ = static_cast<InlineString<>::size_type>(other.size());

  status_ = other.status_;

  last_status_ = other.last_status_;

}

void StringBuilder::HandleStatusWithSize(StatusWithSize written) {

  const Status status = written.status();

  last_status_ = StatusCode(status);

  if (!status.ok()) {

    status_ = StatusCode(status);

  }

  // NOTE: `+=` is not used in order to avoid implicit integer conversion which

  // results in an error on some compilers.

  *size_ = static_cast<InlineString<>::size_type>(written.size() + *size_);

}

void StringBuilder::SetErrorStatus(Status status) {

  last_status_ = StatusCode(status);

  status_ = StatusCode(status);

}

}  // namespace pw