MonoScriptingState.h

#pragma once

#ifdef WIN32
#define MONO_API_V2
#endif

#include <mono/jit/jit.h>
#ifdef MONO_API_V2
#include <glib.h>
#endif
#include <mono/metadata/environment.h>
#include <mono/metadata/mono-config.h>
#include <mono/metadata/assembly.h>
#include <mono/metadata/threads.h>
#include <INPLScriptingState.h>
#include <set>
#include <util/mutex.h>

// forward declare
struct AssemblyFile;
struct ClassObject;
class GlobalAssembliesPool;

typedef std::map <std::string, AssemblyFile*>   Assembly_File_Map_Type;
typedef std::map <std::string, ClassObject*>    Class_Map_Type;

struct ClassObject
{
    std::string m_namespace_name;

    std::string m_class_name;

    MonoClass * m_class;
    MonoMethod * m_activate_function;
};

struct AssemblyFile
{
    MonoAssembly* m_assembly;
    MonoImage* m_image;

    Class_Map_Type m_classes;
};

class GlobalAssembliesPool
{
public:
    GlobalAssembliesPool();
    ~GlobalAssembliesPool();

    static GlobalAssembliesPool& GetSingleton();

    // Get mono domain
    inline MonoDomain* GetMonoDomain() {return m_mono_domain;};
    // Set root mono domain in to which all assemblies are loaded. 
    void SetMonoDomain(MonoDomain* domain) {m_mono_domain = domain;};

    ClassObject* GetClass(const string& filePath);

private:

    Assembly_File_Map_Type m_assemblies;

    MonoDomain *    m_mono_domain;

    // mutex for function GetClass().
    ParaEngine::mutex m_mutex;
};

class CMonoScriptingState : public NPL::IMonoScriptingState
{
public:
    CMonoScriptingState();
    ~CMonoScriptingState();

    void Init();

    const char* GetName() const;

    inline MonoDomain* GetMonoDomain() {return s_mono_domain;};

    void LoadNPLLib();

    void LoadParaLib();

public:
    virtual void Release();

    virtual void* GetState(){return (void*)GetMonoDomain();};

    virtual bool IsValid() {return s_mono_domain != 0;}

    virtual bool IsScriptFileLoaded(const string& filepath);

    virtual bool LoadFile(const string& filePath, bool bReload);

    virtual int DoString(const char* sCall, int nLength = 0);

    virtual NPL::NPLReturnCode ActivateFile(const string& filepath, const char * code = NULL, int nLength=0);

    virtual bool CreateState(const char* name, NPL::INPLRuntimeState* pState = 0);

    virtual void DestroyState();

    virtual void SetNPLRuntimeState(NPL::INPLRuntimeState* pState);

    virtual NPL::INPLRuntimeState* GetNPLRuntimeState();

protected:
    void CreateAppDomain();

private:
    string m_name;

    static MonoDomain * s_mono_domain;
    
    GlobalAssembliesPool* m_global_assemblies_pool;

    NPL::INPLRuntimeState* m_npl_runtime_state;
};