#pragma once

#include <std/fwd/string.hpp>

#include <cstddef>
#include <vector>

namespace std {

  class string {

    std::vector<char> characters;

  public:
    static const size_t npos = (size_t)-1;

    constexpr string() : characters({'\0'}) {}

    constexpr string(const string &other)
    : characters(other.characters) {}

    constexpr string(string &&other) noexcept
    : characters(std::move(other.characters)) {}

    constexpr string(const char *s) {
      size_t count = 0;
      while (s[count] != '\0')
        ++count;
      characters.resize(count + 1);
      for (size_t i = 0; i <= count; ++i)
        characters[i] = s[i];
    }

    constexpr ~string() {}

    constexpr string &operator =(const string &str) {
      characters = str.characters;
      return *this;
    }

    constexpr string &operator =(string &&str) noexcept {
      characters = std::move(str.characters);
      return *this;
    }

    constexpr size_t size() const noexcept {
      return characters.size() - 1;
    }

    constexpr void resize(size_t count) {
      if (count < characters.size() - 1) {
        characters.resize(count + 1);
        characters[count] = '\0';
      }
      else if (count > characters.size() - 1)
        characters.resize(count + 1);
    }

    constexpr void clear() noexcept {
      resize(0);
    }

    constexpr const char *data() const noexcept {
      return characters.data();
    }

    constexpr char *data() noexcept {
      return characters.data();
    }

    constexpr char &operator[](size_t pos) {
      return characters[pos];
    }

    constexpr const char &operator[](size_t pos) const {
      return characters[pos];
    }

    constexpr string &erase(size_t index = 0, size_t count = npos) {
      count = std::min(count, size() - index);
      for (size_t i = index; i + count < size(); ++i)
        characters[i] = characters[i + count];
      resize(size() - count);
      return *this;
    }

  };

}
