#ifndef SLANG_DOWNSTREAM_COMPILER_UTIL_H
#define SLANG_DOWNSTREAM_COMPILER_UTIL_H

#include "slang-downstream-compiler-set.h"
#include "slang-downstream-compiler.h"

namespace Slang
{

typedef SlangResult (*DownstreamCompilerLocatorFunc)(
    const String& path,
    ISlangSharedLibraryLoader* loader,
    DownstreamCompilerSet* set);

struct DownstreamCompilerInfo
{
    typedef DownstreamCompilerInfo This;
    typedef uint32_t SourceLanguageFlags;
    struct SourceLanguageFlag
    {
        enum Enum : SourceLanguageFlags
        {
            Unknown = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_UNKNOWN,
            Slang = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_SLANG,
            HLSL = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_HLSL,
            GLSL = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_GLSL,
            C = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_C,
            CPP = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_CPP,
            CUDA = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_CUDA,
            SPIRV = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_SPIRV,
        };
    };

    /// Get info for a compiler type
    static const This& getInfo(SlangPassThrough compiler);
    /// True if this compiler can compile the specified language
    static bool canCompile(SlangPassThrough compiler, SlangSourceLanguage sourceLanguage);

    DownstreamCompilerInfo()
        : sourceLanguageFlags(0)
    {
    }

    DownstreamCompilerInfo(SourceLanguageFlags inSourceLanguageFlags)
        : sourceLanguageFlags(inSourceLanguageFlags)
    {
    }
    SourceLanguageFlags sourceLanguageFlags;
};


// Combination of a downstream compiler type (pass through) and
// a match version.
struct DownstreamCompilerMatchVersion
{
    DownstreamCompilerMatchVersion(SlangPassThrough inType, MatchSemanticVersion inMatchVersion)
        : type(inType), matchVersion(inMatchVersion)
    {
    }

    DownstreamCompilerMatchVersion()
        : type(SLANG_PASS_THROUGH_NONE)
    {
    }

    SlangPassThrough type;             ///< The type of the compiler
    MatchSemanticVersion matchVersion; ///< The match version
};

struct DownstreamCompilerUtil : public DownstreamCompilerUtilBase
{
    enum class MatchType
    {
        MinGreaterEqual,
        MinAbsolute,
        Newest,
    };

    /// Find a compiler
    static IDownstreamCompiler* findCompiler(
        const DownstreamCompilerSet* set,
        MatchType matchType,
        const DownstreamCompilerDesc& desc);
    static IDownstreamCompiler* findCompiler(
        const List<IDownstreamCompiler*>& compilers,
        MatchType matchType,
        const DownstreamCompilerDesc& desc);

    static IDownstreamCompiler* findCompiler(
        const List<IDownstreamCompiler*>& compilers,
        SlangPassThrough type,
        const SemanticVersion& version);
    static IDownstreamCompiler* findCompiler(
        const List<IDownstreamCompiler*>& compilers,
        const DownstreamCompilerDesc& desc);

    /// Find all the compilers with the version
    static void findVersions(
        const List<IDownstreamCompiler*>& compilers,
        SlangPassThrough compiler,
        List<SemanticVersion>& versions);


    /// Find the compiler closest to the desc
    static IDownstreamCompiler* findClosestCompiler(
        const List<IDownstreamCompiler*>& compilers,
        const DownstreamCompilerMatchVersion& version);
    static IDownstreamCompiler* findClosestCompiler(
        const DownstreamCompilerSet* set,
        const DownstreamCompilerMatchVersion& version);

    /// Get the information on the compiler used to compile this source
    static DownstreamCompilerMatchVersion getCompiledVersion();

    static void updateDefault(DownstreamCompilerSet* set, SlangSourceLanguage sourceLanguage);
    static void updateDefaults(DownstreamCompilerSet* set);

    static void setDefaultLocators(
        DownstreamCompilerLocatorFunc outFuncs[int(SLANG_PASS_THROUGH_COUNT_OF)]);

    /// Attempts to determine what 'path' is and load appropriately. Is it a path to a shared
    /// library? Is it a directory holding the libraries? Some downstream shared libraries need
    /// other shared libraries to be loaded before the main shared library, such that they are in
    /// the same directory otherwise the shared library could come from some unwanted location.
    /// dependentNames names shared libraries which should be attempted to be loaded in the path of
    /// the main shared library. The list is optional (nullptr can be passed in), and the list is
    /// terminated by nullptr.
    static SlangResult loadSharedLibrary(
        const String& path,
        ISlangSharedLibraryLoader* loader,
        const char* const* dependantNames,
        const char* libraryName,
        ComPtr<ISlangSharedLibrary>& outSharedLib);

    /// Append the desc as text
    static void appendAsText(const DownstreamCompilerDesc& desc, StringBuilder& out);
};

} // namespace Slang

#endif