#ifndef TEMPORARYSTRING_HH
#define TEMPORARYSTRING_HH

#include "StringStorage.hh"
#include "zstring_view.hh"

#include <array>
#include <concepts>
#include <iostream>
#include <string_view>


/** TemporaryString
 *
 * This a type meant to store temporary strings. Typically it stores the string
 * in the object itself. Except when the string is too large, then it falls
 * back to heap-allocation. So it's more or less like a std::string but with a
 * relatively large (127 character) "small-string-buffer". (Typical std::string
 * implementations only have a buffer for 15 or 23 characters).
 *
 * Because of this internal buffer, TemporaryString objects are quite large.
 * The intention is that they are only used as local variable (so stored on the
 * stack). Not as member variables.
 *
 * The API of this type is still very minimal. It can be extended when needed.
 */
class TemporaryString {
public:
	static constexpr size_t BUFSIZE = 127;

	explicit TemporaryString()
		: n(0)
	{
		ptr = buffer.data();
		buffer[0] = '\0';
	}

	explicit TemporaryString(const char* s)
		: n(std::char_traits<char>::length(s)), ptr(s) {}
	explicit TemporaryString(zstring_view s)
		: n(s.size()), ptr(s.data()) {}

	explicit TemporaryString(size_t n_, std::invocable<char*> auto fillOp)
		: n(n_)
	{
		char* p = [&] {
			if (n <= BUFSIZE) {
				return buffer.data();
			} else {
				owner = allocate_string_storage(n + 1);
				return owner.get();
			}
		}();
		ptr = p;
		fillOp(p);
		p[n] = '\0';
	}
	TemporaryString(const TemporaryString&) = delete;
	TemporaryString(TemporaryString&&) = delete;
	TemporaryString& operator=(const TemporaryString&) = delete;
	TemporaryString& operator=(TemporaryString&&) = delete;
	~TemporaryString() = default;

	[[nodiscard]] auto size()  const { return n; }
	[[nodiscard]] auto empty() const { return n == 0; }

	[[nodiscard]] const char* data()  const { return ptr; }
	[[nodiscard]] const char* c_str() const { return ptr; }

	[[nodiscard]] std::string_view view()     const { return {ptr, n}; }
	[[nodiscard]] operator std::string_view() const { return {ptr, n}; }
	[[nodiscard]] operator     zstring_view() const { return {ptr, n}; }

	[[nodiscard]] bool starts_with(std::string_view s) const { return view().starts_with(s); }
	[[nodiscard]] bool starts_with(char c)             const { return view().starts_with(c); }
	[[nodiscard]] bool starts_with(const char* s)      const { return view().starts_with(s); }
	[[nodiscard]] bool ends_with(std::string_view s) const { return view().ends_with(s); }
	[[nodiscard]] bool ends_with(char c)             const { return view().ends_with(c); }
	[[nodiscard]] bool ends_with(const char* s)      const { return view().ends_with(s); }

	[[nodiscard]] friend bool operator==(const TemporaryString& x, const TemporaryString& y) {
		return std::string_view(x) == std::string_view(y);
	}
	[[nodiscard]] friend bool operator==(const TemporaryString& x, const zstring_view& y) {
		return std::string_view(x) == std::string_view(y);
	}
	[[nodiscard]] friend bool operator==(const TemporaryString& x, const std::string& y) {
		return std::string_view(x) == std::string_view(y);
	}
	[[nodiscard]] friend bool operator==(const TemporaryString& x, const std::string_view& y) {
		return std::string_view(x) == y;
	}
	[[nodiscard]] friend bool operator==(const TemporaryString& x, const char* y) {
		return std::string_view(x) == std::string_view(y);
	}

	friend std::ostream& operator<<(std::ostream& os, const TemporaryString& str)
	{
		os << std::string_view(str);
		return os;
	}

private:
	size_t n;
	const char* ptr;
	StringStorage owner;
	std::array<char, BUFSIZE + 1> buffer;
};

#endif