/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

/**
 * @author Pavel Rebriy
 */

#include "agent.h"

static bool error = false;

static void
set_test_success( jvmtiEnv* jvmti_env,
                  JNIEnv* jni_env)
{
    CHECK_ERROR();

    DEBUG("Setting test success...");
    jclass klass = jni_env->FindClass("PopFrame1/PopFrame1");
    if(!klass) {
        ERR_REPORT("get class");
        return;
    }
    jfieldID field = jni_env->GetStaticFieldID(klass, "status", "Z");
    if( !field ) {
        ERR_REPORT("get 'status' field");
        return;
    }
    jni_env->SetStaticBooleanField(klass, field, JNI_TRUE);
    return;
}

static void JNICALL
agent_function(jvmtiEnv * jvmti_env,
               JNIEnv * jni_env,
               void *args)
{
    CHECK_ERROR();

    DEBUG("agent: Getting java.lang.Thread ...");
    jclass klass = jni_env->FindClass("java/lang/Thread");
    if(!klass) {
        ERR_REPORT("get java.lang.Thread");
        return;
    }

    DEBUG("agent: Getting java.lang.Thread.yield() method...");
    jmethodID yield_method = jni_env->GetStaticMethodID(klass, "yield", "()V");
    if(!yield_method) {
        ERR_REPORT("get java.lang.Thread.yield() method");
        return;
    }

    jvmtiError result;
    int count = 0;
    bool test = false;
    jthread test_thread = (jthread)args;
    while( !test ) {
        DEBUG("agent: Checking test thread suspend state...");
        int index = 0;
        while(true) {
            jvmtiThreadInfo thread_info;
            result = jvmti_env->GetThreadInfo(test_thread, &thread_info);
            if(JVMTI_ERROR_NONE != result) {
                ERR_REPORT("GetThreadInfo");
                return;
            }

            jint state;
            result = jvmti_env->GetThreadState(test_thread, &state);
            if(JVMTI_ERROR_NONE != result) {
                ERR_REPORT("GetThreadInfo");
                return;
            }
            if(state & JVMTI_THREAD_STATE_SUSPENDED) {
                DEBUG("agent: Test thread is suspended!");
                break;
            }
            jni_env->CallStaticVoidMethod(klass, yield_method, NULL);
            if( !((++index) % 1000) ) {
                DEBUG("Stage = " << std::hex << state );
                DEBUG("agent: Waiting suspension of test thread...");
            }
        }

        DEBUG("agent: ----- " << ++count << " PopFrame call -----");
        result = jvmti_env->PopFrame(test_thread);
        if(JVMTI_ERROR_NONE != result) {
            if(JVMTI_ERROR_NO_MORE_FRAMES == result) {
                DEBUG("agent: PopFrame result is JVMTI_ERROR_NO_MORE_FRAMES!");
                test = true;
                break;
            } else {
                ERR_REPORT("PopFrame result is " << result);
                jvmti_env->ResumeThread(test_thread);
                return;
            }
        } else {
            DEBUG("agent: ...success!");
        }

        DEBUG("agent: Resume test thread");
        result = jvmti_env->ResumeThread(test_thread);
        if (result != JVMTI_ERROR_NONE) {
            ERR_REPORT("ResumeThread");
            return;
        }
    }

    if(!test || count != 3) {
        ERR_REPORT("Test failed! - unknown interruption");
        return;
    }

    DEBUG("agent: Removing SingleStep event...");
    result = jvmti_env->SetEventNotificationMode(JVMTI_DISABLE,
        JVMTI_EVENT_SINGLE_STEP, test_thread);
    if(result != JVMTI_ERROR_NONE) {
        ERR_REPORT("SingleStep: SetEventNotificationMode result is " << result );
        return;
    }

    set_test_success( jvmti_env, jni_env );
   
    DEBUG("agent: Resume test thread");
    result = jvmti_env->ResumeThread(test_thread);
    if (result != JVMTI_ERROR_NONE) {
        ERR_REPORT("ResumeThread");
        return;
    }

    DEBUG("agent: thread is done!");
    return;
}

static void
do_agent_notify(jvmtiEnv* jvmti_env)
{
    DEBUG("test: Suspending test thread...");
    jvmtiError result = jvmti_env->SuspendThread(NULL);
    if(result != JVMTI_ERROR_NONE) {
        ERR_REPORT("SuspendThread result is " << result );
        return;
    }

    DEBUG("test: Breakpoint callback is done!");
    return;
}

void JNICALL
agent_callback_Breakpoint( jvmtiEnv* jvmti_env,
                           JNIEnv* jni_env,
                           jthread thread,
                           jmethodID method,
                           jlocation location)
{
    CHECK_ERROR();

    char *name;
    char *descr;
    jvmtiError result = jvmti_env->GetMethodName(method, &name, &descr, NULL);
    if( result != JVMTI_ERROR_NONE
        || strcmp(name, "third_step") || strcmp(descr, "()V" ) )
    {
        return;
    }
    jclass klass;
    result = jvmti_env->GetMethodDeclaringClass(method, &klass);
    if(result != JVMTI_ERROR_NONE) {
        ERR_REPORT("get method class");
        return;
    }
    char *class_name;
    result = jvmti_env->GetClassSignature(klass, &class_name, NULL);
    if(result != JVMTI_ERROR_NONE
        || strcmp(class_name, "LPopFrame1/PopFrame1$1;"))
    {
        ERR_REPORT("wrong Breakpoint callback");
        return;
    }
    DEBUG("test: Breakpoint occupied in function PopFrame1.PopFrame1.third_step()");

    DEBUG("test: Clearing breakpoint...");
    result = jvmti_env->ClearBreakpoint(method, location);
    if(result != JVMTI_ERROR_NONE) {
        ERR_REPORT("clear breakpoint");
        return;
    }

    DEBUG("test: Setting SingleStep event...");
    result = jvmti_env->SetEventNotificationMode(JVMTI_ENABLE,
        JVMTI_EVENT_SINGLE_STEP, thread);
    if(result != JVMTI_ERROR_NONE) {
        ERR_REPORT("SingleStep: SetEventNotificationMode result is " << result );
        return;
    }

    do_agent_notify(jvmti_env);

    DEBUG("test: Breakpoint callback is done!");
    return;
}

void JNICALL 
agent_callback_SingleStep( jvmtiEnv * jvmti_env,
                           JNIEnv * jni_env,
                           jthread thread,
                           jmethodID method,
                           jlocation location)
{
    CHECK_ERROR();

    char *name;
    char *descr;
    jvmtiError result = jvmti_env->GetMethodName(method, &name, &descr, NULL);
    if(result != JVMTI_ERROR_NONE) {
        ERR_REPORT("get method name");
        return;
    }
    jclass klass;
    result = jvmti_env->GetMethodDeclaringClass(method, &klass);
    if(result != JVMTI_ERROR_NONE) {
        ERR_REPORT("get method class");
        return;
    }
    char *class_name;
    result = jvmti_env->GetClassSignature(klass, &class_name, NULL);
    if(result != JVMTI_ERROR_NONE) {
        ERR_REPORT("get class name");
        return;
    }
    DEBUG("test: SingleStep occupied in function: " << name << descr
        << ", class: " << class_name);

    do_agent_notify(jvmti_env);

    DEBUG("test: SingleStep callback is done!");
    return;
}

void JNICALL
agent_callback_ThreadStart(jvmtiEnv* jvmti_env,
                           JNIEnv* jni_env,
                           jthread start_thread)
{
    jvmtiPhase phase;
    jvmtiError result = jvmti_env->GetPhase(&phase);
    if(phase != JVMTI_PHASE_LIVE) {
        return;
    }

    jvmtiThreadInfo thread_info;
    result = jvmti_env->GetThreadInfo(start_thread, &thread_info);
    if(JVMTI_ERROR_NONE != result) {
        ERR_REPORT("GetThreadInfo");
        return;
    }
    if (strcmp(thread_info.name, "Test thread")) {
        return;
    }
    DEBUG("Tested thread is started!");

    DEBUG("Creating AgentThread...");
    DEBUG("Getting java.lang.Thread ...");
    jclass klass = jni_env->FindClass("java/lang/Thread");
    if(!klass) {
        ERR_REPORT("get java.lang.Thread");
        return;
    }

    DEBUG("Getting java.lang.Thread contructor...");
    jmethodID method = jni_env->GetMethodID(klass, "<init>", "(Ljava/lang/String;)V");
    if(!method) {
        ERR_REPORT("get java.lang.Thread contructor");
        return;
    }

    DEBUG("Getting name string...");
    jstring name = jni_env->NewStringUTF("AgentThread");
    if(!name) {
        ERR_REPORT("get name string");
        return;
    }

    DEBUG("Creating agent thread...");
    jthread thread = jni_env->NewObject(klass, method, name);
    if(!thread) {
        ERR_REPORT("create thread");
        return;
    }

    DEBUG("Creating global reference for test thread...");
    jobject test_thread = jni_env->NewGlobalRef(start_thread);
    if(!test_thread) {
        ERR_REPORT("create thread");
        return;
    }

    DEBUG("Getting PopFrame1.PopFrame1$1 ...");
    klass = jni_env->FindClass("PopFrame1/PopFrame1$1");
    if(!klass) {
        ERR_REPORT("get PopFrame1.PopFrame1$1");
        return;
    }

    DEBUG("Getting PopFrame1.PopFrame1$1.third_step() method...");
    method = jni_env->GetMethodID(klass, "third_step", "()V");
    if(!method) {
        ERR_REPORT("get PopFrame1.PopFrame1$1.third_step() method");
        return;
    }

    DEBUG("Getting line number table...");
    jvmtiLineNumberEntry *table;
    jint number;
    result = jvmti_env->GetLineNumberTable( method, &number, &table );
    if(result != JVMTI_ERROR_NONE) {
        ERR_REPORT("get line number table, error = " << result);
        return;
    }

    jlocation location = 0; 
    for(jint index = 0; index < number - 1; index++) {
        if( table[index].line_number == 67) {
            location = table[index].start_location;
            break;
        }
    }

    DEBUG("Setting breakpint...")
    result = jvmti_env->SetBreakpoint( method, location );
    if(result != JVMTI_ERROR_NONE) {
        ERR_REPORT("set breakpoint");
        return;
    }

    DEBUG("Run agent thread...");
    result = jvmti_env->RunAgentThread(thread, agent_function,
        (void*)test_thread, JVMTI_THREAD_NORM_PRIORITY);
    if(result != JVMTI_ERROR_NONE) {
        ERR_REPORT("agent thread start");
        return;
    }

    return;
}