MinecraftConsoles/Minecraft.Server/Common/AccessStorageUtils.h

#pragma once

#include "FileUtils.h"
#include "StringUtils.h"
#include "..\..\Minecraft.World\GameUUID.h"

#include "..\vendor\nlohmann\json.hpp"

#include <stdio.h>

namespace ServerRuntime
{
	namespace AccessStorageUtils
	{
		inline bool IsRegularFile(const std::string &path)
		{
			const std::wstring widePath = StringUtils::Utf8ToWide(path);
			if (widePath.empty())
			{
				return false;
			}

			const DWORD attributes = GetFileAttributesW(widePath.c_str());
			return (attributes != INVALID_FILE_ATTRIBUTES) && ((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0);
		}

		inline bool EnsureJsonListFileExists(const std::string &path)
		{
			return IsRegularFile(path) || FileUtils::WriteTextFileAtomic(path, "[]\n");
		}

		inline bool TryGetStringField(const nlohmann::ordered_json &object, const char *key, std::string *outValue)
		{
			if (key == nullptr || outValue == nullptr || !object.is_object())
			{
				return false;
			}

			const auto it = object.find(key);
			if (it == object.end() || !it->is_string())
			{
				return false;
			}

			*outValue = it->get<std::string>();
			return true;
		}

		inline std::string NormalizeXuid(const std::string &xuid)
		{
			const std::string trimmed = StringUtils::TrimAscii(xuid);
			if (trimmed.empty())
			{
				return "";
			}

			// Try parsing as a dashed 128-bit UUID (standard format)
			GameUUID parsed = GameUUID::fromDashed(trimmed);
			if (parsed.isValid())
			{
				return parsed.toDashed();
			}

			// Try parsing as an undashed 128-bit UUID
			parsed = GameUUID::fromUndashed(trimmed);
			if (parsed.isValid())
			{
				return parsed.toDashed();
			}

			// Fallback: lowercase whatever was passed (e.g. player names in legacy files)
			return StringUtils::ToLowerAscii(trimmed);
		}

		inline std::string BuildPathFromBaseDirectory(const std::string &baseDirectory, const char *fileName)
		{
			if (fileName == nullptr || fileName[0] == 0)
			{
				return "";
			}

			const std::wstring wideFileName = StringUtils::Utf8ToWide(fileName);
			if (wideFileName.empty())
			{
				return "";
			}

			if (baseDirectory.empty() || baseDirectory == ".")
			{
				return StringUtils::WideToUtf8(wideFileName);
			}

			const std::wstring wideBaseDirectory = StringUtils::Utf8ToWide(baseDirectory);
			if (wideBaseDirectory.empty())
			{
				return StringUtils::WideToUtf8(wideFileName);
			}

			const wchar_t last = wideBaseDirectory[wideBaseDirectory.size() - 1];
			if (last == L'\\' || last == L'/')
			{
				return StringUtils::WideToUtf8(wideBaseDirectory + wideFileName);
			}

			return StringUtils::WideToUtf8(wideBaseDirectory + L"\\" + wideFileName);
		}
	}
}