#include <Windows.h>
#include <stdio.h>
#include <detours.h>
#include <iostream>
#include <string.h>
#include <mono/metadata/object.h>
//#include <mono/metadata/environment.h>
//#include <mono/metadata/assembly.h>
//#include <mono/metadata/debug-helpers.h>


void LogConsole(const char *szFmt, ...)
{
	va_list args;
	va_start(args, szFmt);

	int buffSize = _vscprintf(szFmt, args) + 1;

	if (buffSize <= 1)
		return;

	char *szBuff = new char[buffSize];
	memset(szBuff, 0, buffSize);

	int len = vsprintf_s(szBuff, buffSize, szFmt, args);

	szBuff[buffSize - 1] = 0;

	HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);

	DWORD numWritten = 0;
	WriteFile(hOutput, szBuff, len, &numWritten, NULL);

	delete[] szBuff;
}



HMODULE hMono = GetModuleHandle("mono.dll");

DWORD_PTR GetMonoFunction(char* funcname)
{
	return (DWORD_PTR)GetProcAddress(hMono, funcname);
}

//Class
typedef MonoClass* (__cdecl* mono_class_from_name_t)(MonoImage* image, const char* name_space, const char* name);
typedef MonoMethod* (__cdecl* mono_class_get_method_from_name_t)(MonoClass* mclass, const char* name, int param_count);
mono_class_from_name_t mono_class_from_name_ = (mono_class_from_name_t)GetMonoFunction("mono_class_from_name");
mono_class_get_method_from_name_t mono_class_get_method_from_name_ = (mono_class_get_method_from_name_t)GetMonoFunction("mono_class_get_method_from_name");

//Method
typedef MonoObject* (__cdecl* mono_runtime_invoke_t)(MonoMethod* method, void* obj, void** params, MonoObject** exc);
mono_runtime_invoke_t mono_runtime_invoke_ = (mono_runtime_invoke_t)GetMonoFunction("mono_runtime_invoke");

//Property
typedef MonoProperty* (__cdecl* mono_class_get_property_from_name_t)(MonoClass* mclass, const char* name);
typedef MonoMethod* (__cdecl* mono_property_get_set_method_t)(MonoProperty* prop);
typedef MonoMethod* (__cdecl* mono_property_get_get_method_t)(MonoProperty* prop);
mono_class_get_property_from_name_t mono_class_get_property_from_name_ = (mono_class_get_property_from_name_t)GetMonoFunction("mono_class_get_property_from_name");
mono_property_get_set_method_t mono_property_get_set_method_ = (mono_property_get_set_method_t)GetMonoFunction("mono_property_get_set_method");
mono_property_get_get_method_t mono_property_get_get_method_ = (mono_property_get_get_method_t)GetMonoFunction("mono_property_get_get_method");

//Assembly
typedef MonoAssembly* (__cdecl* mono_assembly_open_t)(const char *filename, MonoImageOpenStatus *status);
typedef MonoImage* (__cdecl* mono_assembly_get_image_t)(MonoAssembly *assembly);
mono_assembly_open_t mono_assembly_open_ = (mono_assembly_open_t)GetMonoFunction("mono_assembly_open");
mono_assembly_get_image_t mono_assembly_get_image_ = (mono_assembly_get_image_t)GetMonoFunction("mono_assembly_get_image");

// Assambly VAN IK
typedef MonoDomain* (__cdecl* mono_domain_get_t)();
typedef MonoDomain* (*mono_get_root_domain_t)();
typedef MonoAssembly* (__cdecl* mono_domain_assembly_open_t)(MonoDomain* domain, const char* fileName);
typedef void*(__cdecl* mono_thread_attach_t)(MonoDomain* domain);
mono_domain_get_t mono_domain_get_ = (mono_domain_get_t)GetMonoFunction("mono_domain_get");
mono_get_root_domain_t mono_get_root_domain_ = (mono_get_root_domain_t)GetMonoFunction("mono_get_root_domain");
mono_domain_assembly_open_t mono_domain_assembly_open_ = (mono_domain_assembly_open_t)GetMonoFunction("mono_domain_assembly_open");
mono_thread_attach_t mono_thread_attach_ = (mono_thread_attach_t)GetMonoFunction("mono_thread_attach");

// Field shizz VAN IK
typedef MonoClassField* (__cdecl*mono_class_get_field_from_name_t)(MonoClass *klass, const char *name);
typedef void* (__cdecl* mono_field_get_value_t)(MonoObject *obj, MonoClassField *field, void *value);
typedef MonoObject* (__cdecl* mono_field_get_value_object_t)(MonoDomain *domain, MonoClassField *field, MonoObject *obj);
typedef MonoObject* (__cdecl* mono_object_new_t)  (MonoDomain *domain, MonoClass *klass);
typedef MonoVTable* (__cdecl* mono_class_vtable_t)(MonoDomain *domain, MonoClass *klass);
typedef void* (__cdecl* mono_field_static_get_value_t)(MonoVTable *vt, MonoClassField *field, void *value);
mono_class_get_field_from_name_t mono_class_get_field_from_name_ = (mono_class_get_field_from_name_t)GetMonoFunction("mono_class_get_field_from_name");
mono_field_get_value_t mono_field_get_value_ = (mono_field_get_value_t)GetMonoFunction("mono_field_get_value");
mono_field_get_value_object_t mono_field_get_value_object_ = (mono_field_get_value_object_t)GetMonoFunction("mono_field_get_value_object");
mono_object_new_t mono_object_new_ = (mono_object_new_t)GetMonoFunction("mono_object_new");
mono_class_vtable_t mono_class_vtable_ = (mono_class_vtable_t)GetMonoFunction("mono_class_vtable");
mono_field_static_get_value_t mono_field_static_get_value_ = (mono_field_static_get_value_t)GetMonoFunction("mono_field_static_get_value");


VOID Deject(PCHAR reason) {
	if (reason) {
		MessageBox(NULL, reason, "", MB_OK | MB_ICONERROR | MB_TOPMOST);
	}
}

const char * boolToStr(bool b) {
	if (b == true) {
		return "true";
	}
	else {
		return "false";
	}
}

DWORD WINAPI LoopFunction(LPVOID lpParam) {
	AllocConsole();
	LogConsole("Loaded CodestageBypass x64 \n");

	char path[2048];
	GetModuleFileNameA(NULL, path, 2048);
	LogConsole("Parent executable = %s\n", path);

	mono_thread_attach_(mono_get_root_domain_());


	MonoDomain* domain_ = mono_domain_get_();
	//C:\\Users\\Win7\\Desktop\\Unity Example games\\RogueLike\\Build_Data\\Managed\\Assembly-CSharp.dll
	//E:\\Software\\Steam\\steamapps\\common\\BlockNLoad\\Win64\\BlockNLoad_Data\\Managed\\Assembly-CSharp.dll
	MonoAssembly* assembly_ = mono_domain_assembly_open_(domain_, "E:\\Software\\Steam\\steamapps\\common\\BlockNLoad\\Win64\\BlockNLoad_Data\\Managed\\Assembly-CSharp.dll");
	MonoImage* image_ = mono_assembly_get_image_(assembly_);

	MonoClass* class_ID = mono_class_from_name_(image_, "CodeStage.AntiCheat.Detectors", "InjectionDetector");
	MonoClass* class_OCD = mono_class_from_name_(image_, "CodeStage.AntiCheat.Detectors", "ObscuredCheatingDetector");
	MonoClass* class_SHD = mono_class_from_name_(image_, "CodeStage.AntiCheat.Detectors", "SpeedHackDetector");

	MonoMethod* method_ID = mono_class_get_method_from_name_(class_ID, "StopDetection", 0); // Method for disabling InjectionDetector
	MonoMethod* method_OCD = mono_class_get_method_from_name_(class_OCD, "StopDetection", 0); // Method for disabling ObscuredCheatingDetector
	MonoMethod* method_SHD = mono_class_get_method_from_name_(class_SHD, "StopDetection", 0); // Method for disabling SpeedHackDetector

	bool b = false;
	while (true) {

		MonoVTable* table_ID = mono_class_vtable_(domain_, class_ID);
		MonoVTable* table_OCD = mono_class_vtable_(domain_, class_OCD);
		MonoVTable* table_SHD = mono_class_vtable_(domain_, class_SHD);

		MonoClassField* field_ID = mono_class_get_field_from_name_(class_ID, "isRunning"); // Internal static bool isRunning (InjectionDetector.isRunning)
		MonoClassField* field_OCD = mono_class_get_field_from_name_(class_OCD, "isRunning"); // Internal static bool isRunning (ObscuredCheatingDetector.isRunning)
		MonoClassField* field_SHD = mono_class_get_field_from_name_(class_SHD, "isRunning"); // Internal static bool isRunning (SpeedHackDetector.isRunning)

		bool res_ID;
		bool res_OCD;
		bool res_SHD;

		mono_field_static_get_value_(table_ID, field_ID, &res_ID);
		mono_field_static_get_value_(table_OCD, field_OCD, &res_OCD);
		mono_field_static_get_value_(table_SHD, field_SHD, &res_SHD);

		LogConsole("\n");
		if (res_ID == true) { LogConsole("InjectionDetector.isRunning: true"); }
		else { LogConsole("InjectionDetector.isRunning: false"); }
		LogConsole("\n");
		if (res_OCD == true) { LogConsole("ObscuredCheatingDetector.isRunning: true"); }
		else { LogConsole("ObscuredCheatingDetector.isRunning: false"); }
		LogConsole("\n");
		if (res_SHD == true) { LogConsole("SpeedHackDetector.isRunning: true"); }
		else { LogConsole("SpeedHackDetector.isRunning: false"); }
		LogConsole("\n");



		if (b == false) {
			LogConsole("Disabling InjectionDetector... \n");
			mono_runtime_invoke_(method_ID, NULL, NULL, NULL);
			LogConsole("Disabling ObscuredCheatingDetector... \n");
			mono_runtime_invoke_(method_OCD, NULL, NULL, NULL);
			LogConsole("Disabling SpeedHackDetector... \n");
			mono_runtime_invoke_(method_SHD, NULL, NULL, NULL);
			b = true;
		}
		else {
			Sleep(4000);
		}
	}




	//try
	//{


	//}
	//catch (const std::exception&e)
	//{
	//	LogConsole("Error: ");
	//	LogConsole(e.what());
	//	LogConsole("\n");
	//}

	return 0;
}


BOOL WINAPI DllMain(HMODULE hModule, DWORD dwReason, LPVOID lpReserved)
{
	switch (dwReason)
	{
	case DLL_PROCESS_ATTACH:
		DisableThreadLibraryCalls(hModule);
		//CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)onAttach, NULL, 0, NULL);
		CreateThread(NULL, 0, &LoopFunction, NULL, 0, NULL);
		return true;
		break;

	case DLL_PROCESS_DETACH:
		FreeConsole();
		return true;
		break;
	}


}