// © 2025 and later: Unicode, Inc. and others.
// License & terms of use: https://www.unicode.org/copyright.html

#ifndef FIXEDSTRING_H
#define FIXEDSTRING_H

#include <string_view>
#include <utility>

#include "unicode/uobject.h"
#include "unicode/utypes.h"
#include "cmemory.h"

U_NAMESPACE_BEGIN

class UnicodeString;

/**
 * ICU-internal fixed-length char* string class.
 * This is a complement to CharString to store fixed-length strings efficiently
 * (not allocating any unnecessary storage for future additions to the string).
 *
 * A terminating NUL is always stored, but the length of the string isn't.
 * An empty string is stored as nullptr, allocating no storage at all.
 *
 * This class wants to be convenient but is also deliberately minimalist.
 * Please do not add methods if they only add minor convenience.
 */
class FixedString : public UMemory {
public:
    FixedString() = default;
    ~FixedString() { operator delete[](ptr); }

    FixedString(const FixedString& other) : FixedString(other.data()) {}

    FixedString(std::string_view init) {
        size_t size = init.size();
        if (size > 0 && reserve(size + 1)) {
            uprv_memcpy(ptr, init.data(), size);
            ptr[size] = '\0';
        }
    }

    FixedString& operator=(const FixedString& other) {
        *this = other.data();
        return *this;
    }

    FixedString& operator=(std::string_view init) {
        if (init.empty()) {
            operator delete[](ptr);
            ptr = nullptr;
        } else {
            size_t size = init.size();
            if (reserve(size + 1)) {
                uprv_memcpy(ptr, init.data(), size);
                ptr[size] = '\0';
            }
        }
        return *this;
    }

    FixedString(FixedString&& other) noexcept : ptr(std::exchange(other.ptr, nullptr)) {}

    FixedString& operator=(FixedString&& other) noexcept {
        operator delete[](ptr);
        ptr = other.ptr;
        other.ptr = nullptr;
        return *this;
    }

    void clear() {
        operator delete[](ptr);
        ptr = nullptr;
    }

    const char* data() const {
        return isEmpty() ? "" : ptr;
    }

    char* getAlias() {
        return ptr;
    }

    bool isEmpty() const {
        return ptr == nullptr;
    }

    /** Allocate storage for a new string, without initializing it. */
    bool reserve(size_t size) {
        operator delete[](ptr);
        ptr = static_cast<char*>(operator new[](size));
        return ptr != nullptr;
    }

private:
    char* ptr = nullptr;
};

U_COMMON_API void copyInvariantChars(const UnicodeString& src, FixedString& dst, UErrorCode& status);

U_NAMESPACE_END

#endif