Path.h

#pragma once
#include <array>
#include <string>
#include <filesystem>
#include <ostream>
#include <string_view>
 
#include "Engine/Files/AssetPath.h"
#include "Engine/Files/GeneratedAssetManifest.h"
 
#ifndef GAME_FOLDER_NAME
#error "GAME_FOLDER_NAME must be defined by CMake"
#endif
 
namespace Engine::Core {

    template <size_t N>
    class ConstexprPath
    {
    public:
        constexpr ConstexprPath() = default;

        constexpr explicit ConstexprPath(const char (&literal)[N])
        {
            for (size_t i = 0; i < N; ++i) {
                path_[i] = literal[i];
            }
            length_ = N - 1;
        }

        [[nodiscard]] constexpr std::string_view view() const { return {path_.data(), length_}; }

        [[nodiscard]] std::filesystem::path fsPath() const
        {
            return std::filesystem::path(view());
        }

        [[nodiscard]] std::string string() const
        {
            return std::string(view());
        }

        [[nodiscard]] constexpr const char* c_str() const
        {
            return path_.data();
        }

        operator std::filesystem::path() const { return fsPath(); }

        template <size_t M>
        [[nodiscard]] constexpr auto operator/(const char (&other)[M]) const
        {
            constexpr size_t leftChars = N - 1;
            constexpr size_t rightChars = M - 1;
            constexpr size_t resultChars = leftChars + 1 + rightChars;
 
            ConstexprPath<resultChars + 1> result;
            size_t out = 0;
            for (size_t i = 0; i < length_; ++i) {
                result.path_[out++] = path_[i];
            }
            if (length_ > 0 && result.path_[out - 1] != '/') {
                result.path_[out++] = '/';
            }
            for (size_t i = 0; i < rightChars; ++i) {
                result.path_[out++] = other[i];
            }
            result.path_[out] = '\0';
            result.length_ = out;
            return result;
        }

        std::filesystem::path operator/(const std::filesystem::path & other ) const
        {
            return fsPath() / other;
        }

        std::filesystem::path operator/(std::string_view other) const
        {
            return fsPath() / other;
        }
 
    private:
        template <size_t>
        friend class ConstexprPath;
 
        std::array<char, N> path_{};
        size_t length_ = 0;
    };

    template <size_t N>
    ConstexprPath(const char (&)[N]) -> ConstexprPath<N>;

    template <size_t N>
    std::ostream& operator<<(std::ostream& stream, const ConstexprPath<N>& path)
    {
        return stream << path.view();
    }

    template <size_t N>
    [[nodiscard]] consteval bool assetExists(const ConstexprPath<N>& path)
    {
        return Assets::GeneratedAssetManifest::contains(path.view());
    }

    class Path {
    public:
        static std::string getEngineRoot();

        static constexpr std::string getProjectRoot();

        static constexpr auto engineGeometry()
        {
            return ConstexprPath( "assets/Engine/geometry/" );
        }

        static constexpr auto gameGeometry()
        {
            return ConstexprPath( "assets/" GAME_FOLDER_NAME "/Data/geometry/" );
        }

        static constexpr auto gameAudio()
        {
            return ConstexprPath( "assets/" GAME_FOLDER_NAME "/Data/sounds/" );
        }

        static constexpr auto gameTextures()
        {
            return ConstexprPath( "assets/" GAME_FOLDER_NAME "/Data/textures/" );
        }

        static constexpr auto engineShaders() {
            return ConstexprPath( "assets/Engine/shaders/" );
        }

        static constexpr auto engineTextures() {
            return ConstexprPath( "assets/Engine/textures/" );
        }

        static constexpr auto engineFonts()
        {
            return ConstexprPath( "assets/Engine/fonts/" );
        }

        static constexpr auto engineSounds()
        {
            return ConstexprPath( "assets/Engine/sounds/" );
        }

        static bool doesFileExist(const std::filesystem::path &path);
        static bool doesGltfFileExist(const std::filesystem::path &path);
        static bool doesExrFileExist(const std::filesystem::path &path);

        static bool doesFileOfTypeExist(const std::filesystem::path &path, const std::string& extension);
    };
 
}  // namespace Engine::Core

#define CREATE_ASSET_PATH( assetPath )                                                                       \
    []                                                                                                       \
    {                                                                                                        \
        constexpr auto verifiedAssetPath = ( assetPath );                                                    \
        static_assert(                                                                                       \
            ::Engine::Core::assetExists( verifiedAssetPath ),                                                \
            "Asset path is not present in GeneratedAssetManifest"                                            \
        );                                                                                                   \
        return verifiedAssetPath;                                                                            \
    }()

#define CREATE_MESH_ASSET_PATH( assetPath, objectName )                                                      \
    []                                                                                                       \
    {                                                                                                        \
        constexpr auto path = CREATE_ASSET_PATH( assetPath );                                                \
        Asset::MeshPath    meshAsset( path.fsPath(), objectName );                                               \
        return meshAsset;                                                                                    \
    }()