#include "PapyrusArgs.h"

class SKSEScaleform_GetVMVariable : public GFxFunctionHandler
{
    virtual void    Invoke(Args * args)
    {
        if(!g_loadGameLock.TryEnter())
            return;

        ASSERT(args->numArgs >= 1);
        ASSERT(args->args[0].GetType() == GFxValue::kType_Number);
        ASSERT(args->args[1].GetType() == GFxValue::kType_String);

        const char * varName = args->args[1].GetString();
        BSFixedString variableName(varName);

        UInt32      formId;
        TESForm     * form = NULL;


        if (args->numArgs >= 1) {
            formId = (UInt32)args->args[0].GetNumber();
            if(formId > 0)
                form = LookupFormByID(formId);
        }

        args->result->SetNull();

        if(form) {
            VMClassRegistry     * registry =    (*g_skyrimVM)->GetClassRegistry();
            IObjectHandlePolicy * policy =      registry->GetHandlePolicy();

            UInt64 handle = policy->Create(form->formType, form);
            if (handle != policy->GetInvalidHandle())
            {
                GetScriptVariableFunctor scriptVariable(registry, handle, variableName);
                registry->VisitScripts(handle, &scriptVariable);
                VMValue * retValue;
                if((retValue = scriptVariable.getResult()) != NULL)
                {
                    switch(retValue->type)
                    {
                    case VMValue::kType_Bool:
                        {
                            bool b;
                            UnpackValue<bool>(&b, retValue);
                            args->result->SetNumber(b);
                        }
                        break;
                    case VMValue::kType_Int:
                        {
                            SInt32 i;
                            UnpackValue<SInt32>(&i, retValue);
                            args->result->SetNumber(i);
                        }
                        break;
                    case VMValue::kType_Float:
                        {
                            float f;
                            UnpackValue<float>(&f, retValue);
                            args->result->SetNumber(f);
                        }
                        break;
                    case VMValue::kType_String:
                        {
                            BSFixedString str;
                            UnpackValue<BSFixedString>(&str, retValue);
                            args->movie->CreateString(args->result, str.data);
                        }
                        break;
                    case VMValue::kType_BoolArray:
                        {
                            VMArray<bool> bArray;
                            UnpackValue<VMArray<bool>>(&bArray, retValue);
                            args->movie->CreateArray(args->result);

                            bool tmp;
                            for(int i = 0; i < bArray.Length(); i++) {
                                GFxValue gfxValue;
                                bArray.Get(&tmp, i);
                                gfxValue.SetNumber(tmp);
                                args->result->PushBack(&gfxValue);
                            }
                        }
                        break;
                    case VMValue::kType_IntArray:
                        {
                            VMArray<SInt32> iArray;
                            UnpackValue<VMArray<SInt32>>(&iArray, retValue);
                            args->movie->CreateArray(args->result);

                            SInt32 tmp;
                            for(int i = 0; i < iArray.Length(); i++) {
                                GFxValue gfxValue;
                                iArray.Get(&tmp, i);
                                gfxValue.SetNumber(tmp);
                                args->result->PushBack(&gfxValue);
                            }
                        }
                        break;
                    case VMValue::kType_FloatArray:
                        {
                            VMArray<float> fArray;
                            UnpackValue<VMArray<float>>(&fArray, retValue);
                            args->movie->CreateArray(args->result);

                            float tmp;
                            for(int i = 0; i < fArray.Length(); i++) {
                                GFxValue gfxValue;
                                fArray.Get(&tmp, i);
                                gfxValue.SetNumber(tmp);
                                args->result->PushBack(&gfxValue);
                            }
                        }
                        break;
                    case VMValue::kType_StringArray:
                        {
                            VMArray<BSFixedString> sArray;
                            UnpackValue<VMArray<BSFixedString>>(&sArray, retValue);
                            args->movie->CreateArray(args->result);

                            BSFixedString tmp;
                            for(int i = 0; i < sArray.Length(); i++) {
                                GFxValue gfxValue;
                                sArray.Get(&tmp, i);
                                args->movie->CreateString(&gfxValue, tmp.data);
                                args->result->PushBack(&gfxValue);
                            }
                        }
                        break;
                    }
                }
            }
        }

        g_loadGameLock.Leave();
    }
};