ma_result ma_encoder_write_callback(ma_encoder* encoder, const void* buffer, size_t bytesToWrite, size_t* pBytesWritten) {
	if (encoder == nullptr) {
		return MA_INVALID_ARGS;
	}

	MemoryStream* stream = reinterpret_cast<MemoryStream*>(encoder->pUserData);
	if (buffer == nullptr || stream == nullptr)return MA_INVALID_ARGS;
	stream->write((const char*)buffer, bytesToWrite);
	return MA_SUCCESS;
}



ma_result ma_encoder_seek_callback(ma_encoder* pEncoder, ma_int64 offset, ma_seek_origin origin) {
	MemoryStream* stream = reinterpret_cast<MemoryStream*>(pEncoder->pUserData);
	seek_origin so;
	switch (origin) {
	case ma_seek_origin_start: {
		so = seek_origin_start;
		break;
	}
	case ma_seek_origin_current: {
		so = seek_origin_current;
		break;
	}
	case ma_seek_origin_end: {
		so = seek_origin_end;
		break;
	}
	default:return MA_ERROR;
	}
	stream->seek(so, offset);
	return MA_SUCCESS;
}

MemoryStream::MemoryStream(size_t initialSize)
	: buffer(initialSize), position(0), ref(1) {}
void MemoryStream::AddRef() {
	asAtomicInc(ref);
}
void MemoryStream::Release() {
	if (asAtomicDec(ref) < 1)
		delete this;
}
MemoryStream::~MemoryStream() {
	this->clear();
}
void MemoryStream::write(const char* data, size_t size) {
	ensureCapacity(position + size);
	std::copy(data, data + size, buffer.begin() + position);
	position += size;
}

void MemoryStream::write(const std::string& str) {
	write(str.data(), str.size());
}

void MemoryStream::read(char* data, size_t size) {
	if (position + size > buffer.size()) {
		return;
	}
	std::copy(buffer.begin() + position, buffer.begin() + position + size, data);
	position += size;
}

void MemoryStream::read(std::string& str, size_t size) {
	str.resize(size);
	read(&str[0], size);
}

void MemoryStream::seek(size_t pos) {
	if (pos > buffer.size()) {
		return;
	}
	position = pos;
}

void MemoryStream::seek(seek_origin origin, int offset) {
	switch (origin) {
	case seek_origin_start:
		if (offset < 0 || static_cast<size_t>(offset) > buffer.size()) {
			return;
		}
		position = static_cast<size_t>(offset);
		break;

	case seek_origin_current:
		if (position + offset > buffer.size() || position + offset < 0) {
			return;
		}
		position += offset;
		break;

	case seek_origin_end:
		if (offset > 0 || static_cast<size_t>(-offset) > buffer.size()) {
			return;
		}
		position = buffer.size() + static_cast<size_t>(offset);
		break;

	default:
		return;
	}
}

size_t MemoryStream::tell() const {
	return position;
}

size_t MemoryStream::size() const {
	return buffer.size();
}

void MemoryStream::clear() {
	buffer.clear();
	position = 0;
}

void MemoryStream::ensureCapacity(size_t requiredSize) {
	if (requiredSize > buffer.size()) {
		buffer.resize(requiredSize * 2); // Double the size for future writes
	}
};