#pragma once

#include <XCEngine/Core/Containers/String.h>
#include <XCEngine/RHI/RHIEnums.h>
#include <XCEngine/RHI/RHIPipelineState.h>
#include <XCEngine/Resources/Shader/Shader.h>

#include <string>

namespace XCEngine {
namespace Rendering {
namespace Detail {

inline Resources::ShaderBackend ToShaderBackend(RHI::RHIType backendType) {
    switch (backendType) {
    case RHI::RHIType::D3D12:
        return Resources::ShaderBackend::D3D12;
    case RHI::RHIType::Vulkan:
        return Resources::ShaderBackend::Vulkan;
    case RHI::RHIType::OpenGL:
    default:
        return Resources::ShaderBackend::OpenGL;
    }
}

inline RHI::ShaderLanguage ToRHIShaderLanguage(Resources::ShaderLanguage language) {
    switch (language) {
    case Resources::ShaderLanguage::HLSL:
        return RHI::ShaderLanguage::HLSL;
    case Resources::ShaderLanguage::SPIRV:
        return RHI::ShaderLanguage::SPIRV;
    case Resources::ShaderLanguage::GLSL:
    default:
        return RHI::ShaderLanguage::GLSL;
    }
}

inline std::wstring ToWideAscii(const Containers::String& value) {
    std::wstring wide;
    wide.reserve(value.Length());
    for (size_t index = 0; index < value.Length(); ++index) {
        wide.push_back(static_cast<wchar_t>(value[index]));
    }
    return wide;
}

inline void ApplyShaderStageVariant(
    const Resources::ShaderStageVariant& variant,
    RHI::ShaderCompileDesc& compileDesc) {
    compileDesc.source.assign(
        variant.sourceCode.CStr(),
        variant.sourceCode.CStr() + variant.sourceCode.Length());
    compileDesc.sourceLanguage = ToRHIShaderLanguage(variant.language);
    compileDesc.entryPoint = ToWideAscii(variant.entryPoint);
    compileDesc.profile = ToWideAscii(variant.profile);
}

inline Containers::String BuildShaderKeywordSignature(
    const Resources::ShaderKeywordSet& keywordSet) {
    Resources::ShaderKeywordSet normalizedKeywords = keywordSet;
    Resources::NormalizeShaderKeywordSetInPlace(normalizedKeywords);

    Containers::String signature;
    for (size_t keywordIndex = 0; keywordIndex < normalizedKeywords.enabledKeywords.Size(); ++keywordIndex) {
        if (keywordIndex > 0) {
            signature += ";";
        }

        signature += normalizedKeywords.enabledKeywords[keywordIndex];
    }

    return signature;
}

inline bool ShaderPassHasGraphicsVariants(
    const Resources::Shader& shader,
    const Containers::String& passName,
    Resources::ShaderBackend backend,
    const Resources::ShaderKeywordSet& enabledKeywords = Resources::ShaderKeywordSet()) {
    return shader.FindVariant(
               passName,
               Resources::ShaderType::Vertex,
               backend,
               enabledKeywords) != nullptr &&
           shader.FindVariant(
               passName,
               Resources::ShaderType::Fragment,
               backend,
               enabledKeywords) != nullptr;
}

} // namespace Detail
} // namespace Rendering
} // namespace XCEngine