#include "il2cpp-config.h"
#include "StackTrace.h"
#include <cassert>

#if IL2CPP_DEBUGGER_ENABLED
#include "il2cpp-debugger.h"
#endif // IL2CPP_DEBUGGER_ENABLED

#if IL2CPP_ENABLE_STACKTRACES
#ifdef IL2CPP_ENABLE_NATIVE_STACKTRACES
#include "os/Event.h"
#include "os/StackTrace.h"
#include "os/Thread.h"
#include "vm-utils/NativeSymbol.h"
#endif // IL2CPP_ENABLE_NATIVE_STACKTRACES
#include "os/ThreadLocalValue.h"
#endif // IL2CPP_ENABLE_STACKTRACES

namespace mono
{
namespace vm
{
#if IL2CPP_ENABLE_STACKTRACES

    class MethodStack
    {
    protected:
        il2cpp::os::ThreadLocalValue s_StackFrames;

        inline StackFrames* GetStackFramesRaw()
        {
            StackFrames* stackFrames;

            il2cpp::os::ErrorCode result = s_StackFrames.GetValue(reinterpret_cast<void**>(&stackFrames));
            assert(result == il2cpp::os::kErrorCodeSuccess);

            return stackFrames;
        }

    public:
        inline void InitializeForCurrentThread()
        {
            if (GetStackFramesRaw() != NULL)
                return;

            StackFrames* stackFrames = new StackFrames();
            stackFrames->reserve(64);

            il2cpp::os::ErrorCode result = s_StackFrames.SetValue(stackFrames);
            assert(result == il2cpp::os::kErrorCodeSuccess);
        }

        inline void CleanupForCurrentThread()
        {
            StackFrames* frames = GetStackFramesRaw();

            if (frames == NULL)
                return;

            delete frames;

            il2cpp::os::ErrorCode result = s_StackFrames.SetValue(NULL);
            assert(result == il2cpp::os::kErrorCodeSuccess);
        }
    };

#if IL2CPP_ENABLE_STACKTRACE_SENTRIES

    class StacktraceSentryMethodStack : public MethodStack
    {
    public:
        inline const StackFrames* GetStackFrames()
        {
            return GetStackFramesRaw();
        }

        inline bool GetStackFrameAt(int32_t depth, MonoStackFrameInfo& frame)
        {
            const StackFrames& frames = *GetStackFramesRaw();

            if (static_cast<int>(frames.size()) + depth < 1)
                return false;

            frame = frames[frames.size() - 1 + depth];
            return true;
        }

        inline void PushFrame(MonoStackFrameInfo& frame)
        {
            GetStackFramesRaw()->push_back(frame);

#if IL2CPP_DEBUGGER_ENABLED
            il2cpp_debugger_method_entry(frame);
#endif
        }

        inline void PopFrame()
        {
            StackFrames* stackFrames = GetStackFramesRaw();

#if IL2CPP_DEBUGGER_ENABLED
            MonoStackFrameInfo frame = stackFrames->back();
#endif

            stackFrames->pop_back();

#if IL2CPP_DEBUGGER_ENABLED
            il2cpp_debugger_method_exit(frame);
#endif
        }
    };

#endif // IL2CPP_ENABLE_STACKTRACE_SENTRIES

#if IL2CPP_ENABLE_NATIVE_STACKTRACES

    class NativeMethodStack : public MethodStack
    {
        static bool GetStackFramesCallback(Il2CppMethodPointer frame, void* context)
        {
            MonoMethod* method = const_cast<MonoMethod*>(il2cpp::utils::NativeSymbol::GetMethodFromNativeSymbol(frame));
            StackFrames* stackFrames = static_cast<StackFrames*>(context);

            if (method != NULL)
            {
                MonoStackFrameInfo frameInfo;
                memset(&frameInfo, 0, sizeof(frameInfo));
                frameInfo.method = method;
                frameInfo.actual_method = method;
                frameInfo.type = FRAME_TYPE_MANAGED;
                frameInfo.managed = 1;
                frameInfo.il_offset = 0;
                frameInfo.native_offset = 0;
                frameInfo.ji = (MonoJitInfo*)-1;
                stackFrames->push_back(frameInfo);
            }

            return true;
        }

        struct GetStackFrameAtContext
        {
            int32_t currentDepth;
            const MonoMethod* method;
        };

        static bool GetStackFrameAtCallback(Il2CppMethodPointer frame, void* context)
        {
            const MonoMethod* method = il2cpp::utils::NativeSymbol::GetMethodFromNativeSymbol(frame);
            GetStackFrameAtContext* ctx = static_cast<GetStackFrameAtContext*>(context);

            if (method != NULL)
            {
                if (ctx->currentDepth == 0)
                {
                    ctx->method = method;
                    return false;
                }

                ctx->currentDepth++;
            }

            return true;
        }

    public:
        inline const StackFrames* GetStackFrames()
        {
            StackFrames* stackFrames = GetStackFramesRaw();
            stackFrames->clear();

            il2cpp::os::StackTrace::WalkStack(&NativeMethodStack::GetStackFramesCallback, stackFrames, il2cpp::os::StackTrace::kFirstCalledToLastCalled);

            return stackFrames;
        }

        inline bool GetStackFrameAt(int32_t depth, MonoStackFrameInfo& frame)
        {
            GetStackFrameAtContext context = { depth, NULL };

            il2cpp::os::StackTrace::WalkStack(&NativeMethodStack::GetStackFrameAtCallback, &context, il2cpp::os::StackTrace::kLastCalledToFirstCalled);

            if (context.method != NULL)
            {
                MonoMethod* method = const_cast<MonoMethod*>(context.method);
                frame.method = method;
                frame.actual_method = method;
                frame.type = FRAME_TYPE_MANAGED;
                frame.managed = 1;
                frame.il_offset = 0;
                frame.native_offset = 0;
                frame.ji = (MonoJitInfo*)-1;
                return true;
            }

            return false;
        }

        inline void PushFrame(MonoStackFrameInfo& frame)
        {
        }

        inline void PopFrame()
        {
        }
    };

#endif // IL2CPP_ENABLE_NATIVE_STACKTRACES

#else

    static StackFrames s_EmptyStack;

    class NoOpMethodStack
    {
    public:
        inline void InitializeForCurrentThread()
        {
        }

        inline void CleanupForCurrentThread()
        {
        }

        inline const StackFrames* GetStackFrames()
        {
            return &s_EmptyStack;
        }

        inline bool GetStackFrameAt(int32_t depth, MonoStackFrameInfo& frame)
        {
            return false;
        }

        inline void PushFrame(MonoStackFrameInfo& frame)
        {
        }

        inline void PopFrame()
        {
        }
    };

#endif // IL2CPP_ENABLE_STACKTRACES

#if IL2CPP_ENABLE_STACKTRACES

#if IL2CPP_ENABLE_STACKTRACE_SENTRIES

    StacktraceSentryMethodStack s_MethodStack;

#elif IL2CPP_ENABLE_NATIVE_STACKTRACES

    NativeMethodStack s_MethodStack;

#endif

#else

    NoOpMethodStack s_MethodStack;

#endif // IL2CPP_ENABLE_STACKTRACES

// Current thread functions

    void StackTrace::InitializeStackTracesForCurrentThread()
    {
        s_MethodStack.InitializeForCurrentThread();
    }

    void StackTrace::CleanupStackTracesForCurrentThread()
    {
        s_MethodStack.CleanupForCurrentThread();
    }

    const StackFrames* StackTrace::GetStackFrames()
    {
        return s_MethodStack.GetStackFrames();
    }

    bool StackTrace::GetStackFrameAt(int32_t depth, MonoStackFrameInfo& frame)
    {
        assert(depth <= 0 && "Frame depth must be 0 or less");
        return s_MethodStack.GetStackFrameAt(depth, frame);
    }

    void StackTrace::WalkFrameStack(MonoInternalStackWalk callback, MonoContext* context, void *user_data)
    {
        const StackFrames& frames = *GetStackFrames();

        for (StackFrames::const_reverse_iterator it = frames.rbegin(); it != frames.rend(); ++it)
        {
            if (callback(const_cast<MonoStackFrameInfo*>(&*it), context, user_data))
                break;
        }
    }

    void StackTrace::PushFrame(MonoStackFrameInfo& frame)
    {
        s_MethodStack.PushFrame(frame);
    }

    void StackTrace::PopFrame()
    {
        s_MethodStack.PopFrame();
    }

// Remote thread functions

    struct GetThreadFrameAtContext
    {
        //il2cpp::os::Event apcDoneEvent;
        int32_t depth;
        MonoStackFrameInfo* frame;
        bool hasResult;
    };

    struct WalkThreadFrameStackContext
    {
        //il2cpp::os::Event apcDoneEvent;
        MonoInternalStackWalk callback;
        MonoContext* context;
        void *user_data;
    };

    struct GetThreadStackDepthContext
    {
        //il2cpp::os::Event apcDoneEvent;
        int32_t stackDepth;
    };

    struct GetThreadTopFrameContext
    {
        //il2cpp::os::Event apcDoneEvent;
        MonoStackFrameInfo* frame;
        bool hasResult;
    };

    static void STDCALL GetThreadFrameAtCallback(void* context)
    {
        GetThreadFrameAtContext* ctx = static_cast<GetThreadFrameAtContext*>(context);

        ctx->hasResult = StackTrace::GetStackFrameAt(ctx->depth, *ctx->frame);
        //ctx->apcDoneEvent.Set();
    }

    bool StackTrace::GetThreadStackFrameAt(MonoThread* thread, int32_t depth, MonoStackFrameInfo& frame)
    {
#if IL2CPP_ENABLE_STACKTRACES
        //GetThreadFrameAtContext apcContext;

        //apcContext.depth = depth;
        //apcContext.frame = &frame;

        //thread->GetInternalThread()->handle->QueueUserAPC(GetThreadFrameAtCallback, &apcContext);
        //apcContext.apcDoneEvent.Wait();

        //return apcContext.hasResult;
        return false;
#else
        return false;
#endif
    }

    static void STDCALL WalkThreadFrameStackCallback(void* context)
    {
        WalkThreadFrameStackContext* ctx = static_cast<WalkThreadFrameStackContext*>(context);

        StackTrace::WalkFrameStack(ctx->callback, ctx->context, ctx->user_data);
        //ctx->apcDoneEvent.Set();
    }

    void StackTrace::WalkThreadFrameStack(MonoThread* thread, MonoInternalStackWalk callback, MonoContext *context, void *user_data)
    {
#if IL2CPP_ENABLE_STACKTRACES
        WalkThreadFrameStackContext apcContext;

        apcContext.callback = callback;
        apcContext.context = context;
        apcContext.user_data = user_data;

        //thread->GetInternalThread()->handle->QueueUserAPC(WalkThreadFrameStackCallback, &apcContext);
        //apcContext.apcDoneEvent.Wait();
#endif
    }

    static void STDCALL GetThreadStackDepthCallback(void* context)
    {
        GetThreadStackDepthContext* ctx = static_cast<GetThreadStackDepthContext*>(context);

        ctx->stackDepth = static_cast<int32_t>(StackTrace::GetStackDepth());
        //ctx->apcDoneEvent.Set();
    }

    int32_t StackTrace::GetThreadStackDepth(MonoThread* thread)
    {
#if IL2CPP_ENABLE_STACKTRACES
        //GetThreadStackDepthContext apcContext;

        //thread->GetInternalThread()->handle->QueueUserAPC(GetThreadStackDepthCallback, &apcContext);
        //apcContext.apcDoneEvent.Wait();

        //return apcContext.stackDepth;
        return 0;
#else
        return 0;
#endif
    }

    static void STDCALL GetThreadTopFrameCallback(void* context)
    {
        GetThreadTopFrameContext* ctx = static_cast<GetThreadTopFrameContext*>(context);

        ctx->hasResult = StackTrace::GetTopStackFrame(*ctx->frame);
        //ctx->apcDoneEvent.Set();
    }

    bool StackTrace::GetThreadTopStackFrame(MonoThread* thread, MonoStackFrameInfo& frame)
    {
#if IL2CPP_ENABLE_STACKTRACES
        //GetThreadTopFrameContext apcContext;
        //apcContext.frame = &frame;

        //thread->GetInternalThread()->handle->QueueUserAPC(GetThreadTopFrameCallback, &apcContext);
        //apcContext.apcDoneEvent.Wait();

        //return apcContext.hasResult;
        return false;
#else
        return false;
#endif
    }
}
}