#include <Windows.h>
#include "auth.hpp"
#include <string>
#include "utils.hpp"
#include "skStr.h"
std::string tm_to_readable_time(tm ctx);
static std::time_t string_to_timet(std::string timestamp);
static std::tm timet_to_tm(time_t timestamp);
const std::string compilation_date = (std::string)skCrypt(__DATE__);
const std::string compilation_time = (std::string)skCrypt(__TIME__);
using namespace std;

using namespace KeyAuth;

std::string name = "sensee"; // application name. right above the blurred text aka the secret on the licenses tab among other tabs
std::string ownerid = "aO0gWsipDy"; // ownerid, found in account settings. click your profile picture on top right of dashboard and then account settings.
std::string secret = "1f9ea9e4fd2a795a8f584eb7c33927a6badd086742cf06c49360a93cbb1e96d0"; // app secret, the blurred text on licenses tab and other tabs
std::string version = "1.0"; // leave alone unless you've changed version on website
std::string url = skCrypt("https://keyauth.win/api/1.2/").decrypt(); // change if you're self-hosting

/*
	Video on what ownerid and secret are https://youtu.be/uJ0Umy_C6Fg

	Video on how to add KeyAuth to your own application https://youtu.be/GB4XW_TsHqA

	Video to use Web Loader (control loader from customer panel) https://youtu.be/9-qgmsUUCK4
*/

api KeyAuthApp(name, ownerid, secret, version, url);

int main()
{
	system("color 3F");

	std::string consoleTitle = (std::string)skCrypt("Loader - Built at:  ") + compilation_date + " " + compilation_time;
	SetConsoleTitleA(consoleTitle.c_str());
	std::cout << skCrypt("\n\n Connecting..");
	KeyAuthApp.init();
	if (!KeyAuthApp.data.success)
	{
		std::cout << skCrypt("\n Status: ") << KeyAuthApp.data.message;
		Sleep(1500);
		exit(0);
	}

	/*
		Optional - check if HWID or IP blacklisted

	if (KeyAuthApp.checkblack()) {
		abort();
	}
	*/

	

	if (std::filesystem::exists("test.json")) //change test.txt to the path of your file :smile:
	{
		if (!CheckIfJsonKeyExists("test.json", "username"))
		{
			std::string key = ReadFromJson("test.json", "license");
			KeyAuthApp.license(key);
			if (!KeyAuthApp.data.success)
			{
				std::remove("test.json");
				std::cout << skCrypt("\n Status: ") << KeyAuthApp.data.message;
				Sleep(1500);
				exit(0);
			}
			std::cout << skCrypt("\nSuccessfully Automatically Logged In");
		}
		else
		{
			std::string username = ReadFromJson("test.json", "username");
			std::string password = ReadFromJson("test.json", "password");
			KeyAuthApp.login(username, password);
			if (!KeyAuthApp.data.success)
			{
				std::remove("test.json");
				std::cout << skCrypt("\n Status: ") << KeyAuthApp.data.message;
				Sleep(1500);
				exit(0);
			}
			std::cout << skCrypt("\nSuccessfully Automatically Logged In");
		}
		//KeyAuthApp.log("Someone has Logged in")
	}
	else
	{
		

		int option;
		std::string username;
		std::string password;
		std::string key;

		std::cout << skCrypt("\n Enter license: ");
		std::cin >> key;
		KeyAuthApp.license(key);
		

		if (!KeyAuthApp.data.success)
		{
			std::cout << skCrypt("\n Status: ") << KeyAuthApp.data.message;
			Sleep(1500);
			exit(0);
		}
		if (username.empty() || password.empty())
		{
			WriteToJson("test.json", "license", key, false, "", "");
			std::cout << skCrypt("Successfully Created File For Auto Login");
		}
		else
		{
			WriteToJson("test.json", "username", username, true, "password", password);
			std::cout << skCrypt("Successfully Created File For Auto Login");
		}


	}
	
	

	

	
    
	#pragma region example functions
	/*
	std::cout << "\n Waiting for user to login";
	KeyAuthApp.web_login();

	std::cout << "\n Waiting for button to be clicked";
	KeyAuthApp.button("close");
	*/

	/*
	for (std::string subs : KeyAuthApp.data.subscriptions)
	{
		if (subs == "default")
		{
			std::cout << skCrypt("\n User has subscription with name: default");
		}
	}
	*/

	
	/*
	// download file, change file.exe to whatever you want.
	// remember, certain paths like windows folder will require you to turn on auto run as admin https://stackoverflow.com/a/19617989

	std::vector<std::uint8_t> bytes = KeyAuthApp.download("362906");

	if (!KeyAuthApp.data.success) // check whether file downloaded correctly
	{
		std::cout << skCrypt("\n\n Status: ") << KeyAuthApp.data.message;
		Sleep(1500);
		exit(0);
	}

	std::ofstream file("file.dll", std::ios_base::out | std::ios_base::binary);
	file.write((char*)bytes.data(), bytes.size());
	file.close();
	*/
	

	// KeyAuthApp.setvar("discord", "test#0001"); // set the value of user variable 'discord' to 'test#0001'
	// std::string userVar = KeyAuthApp.getvar("discord");
	// if (!KeyAuthApp.data.success) // check whether user variable exists and was retrieved correctly
	// {
	// 	std::cout << skCrypt("\n\n Status: ") << KeyAuthApp.data.message;
	// 	Sleep(1500);
	// 	exit(0);
	// }
	// std::cout << "\n user variable - " + userVar; // get value of the user variable 'discord'
	
	/*
	// let's say you want to send request to https://keyauth.win/api/seller/?sellerkey=f43795eb89d6060b74cdfc56978155ef&type=black&ip=1.1.1.1&hwid=abc
	// but doing that from inside the loader is a bad idea as the link could get leaked.
	// Instead, you should create a webhook with the https://keyauth.win/api/seller/?sellerkey=f43795eb89d6060b74cdfc56978155ef part as the URL
	// then in your loader, put the rest of the link (the other paramaters) in your loader. And then it will send request from KeyAuth server and return response in string resp
	
	// example to send normal request with no POST data
	std::string resp = KeyAuthApp.webhook("5iZMT1f1XW", "?mak=best&debug=1");

	// example to send form data
	resp = KeyAuthApp.webhook("5iZMT1f1XW", "", "type=init&ver=1.0&name=test&ownerid=j9Gj0FTemM", "application/x-www-form-urlencoded");

	// example to send JSON
	resp = KeyAuthApp.webhook("5iZMT1f1XW", "", "{\"content\": \"webhook message here\",\"embeds\": null}", "application/json");
	if (!KeyAuthApp.data.success) // check whether webhook request sent correctly
	{
		std::cout << skCrypt("\n\n Status: ") << KeyAuthApp.data.message;
		Sleep(1500);
		exit(0);
	}
	std::cout << "\n Response recieved from webhook request: " + resp;
	*/

	// get data from global variable with name 'status'
	// std::cout << "\n status - " + KeyAuthApp.var("status");

	// KeyAuthApp.log("user logged in"); // send event to logs. if you set discord webhook in app settings, it will send there instead of dashboard
	// KeyAuthApp.ban(); // ban the current user, must be logged in
	// KeyAuthApp.ban("Don't try to crack my loader, cunt."); // ban the current user (with a reason), must be logged in
	
	/*
	// allow users to communicate amongst each other with through KeyAuth. Thank you Nuss31#1102 for this C++ implementation
	// send chat messages
	std::cout << skCrypt("\n Type Chat message: ");
	std::string message;
	//getline is important cause cin alone stops captureing after a space
	std::getline(std::cin, message);
	if (!KeyAuthApp.chatsend("test", message))
	{
		std::cout << KeyAuthApp.data.message << std::endl;
	}
	// get chat messages
	KeyAuthApp.chatget("test");
	for (int i = 0; i < KeyAuthApp.data.channeldata.size(); i++)
	{
		std::cout << "\n Author:" + KeyAuthApp.data.channeldata[i].author + " | Message:" + KeyAuthApp.data.channeldata[i].message + " | Send Time:" + tm_to_readable_time(timet_to_tm(string_to_timet(KeyAuthApp.data.channeldata[i].timestamp)));
	}
	*/
	
	/* 
	// change username
	// allow users to change their usernames when logged-in
	std::cout << skCrypt("\n Change Username To: ");
	std::string newusername;
	std::cin >> newusername;
	KeyAuthApp.changeusername(newusername);
	if (KeyAuthApp.data.success) 
	{
		std::cout << KeyAuthApp.data.message << std::endl;
	}
	*/
	#pragma endregion Example on how to use KeyAuth functions

     
std::cout << "\n[!] Please do not forget to update the bios for the spoofer to work." << std::endl;
cout << "\n[!] Please do not forget to format with ISO so that the spoofer can work.";
cout << "\n[!] Please disable your anti virus software before starting the spoofing process.";
Sleep(3000);
cout << "\n[+] Spoofing will start in 3 seconds.";
Sleep(3000);
std::string urls[9] = {
	"https://cdn.discordapp.com/attachments/1079393064407281788/1091022769589858341/RandomizeDisk.sys",
	"https://cdn.discordapp.com/attachments/1079393064407281788/1091022769942167612/kdmapper.exe",
	"https://cdn.discordapp.com/attachments/1079394623329411146/1094004939509989466/amifldrv64.sys",
	"https://cdn.discordapp.com/attachments/1079394623329411146/1094004939799404616/Change_Hwids.bat",
	"https://cdn.discordapp.com/attachments/1079394623329411146/1094004940143349789/1.cmd",
	"https://cdn.discordapp.com/attachments/1079394623329411146/1094004940487262308/2.cmd",
	"https://cdn.discordapp.com/attachments/1079394623329411146/1094004940776677376/AMIDEWINx64.exe",
	"https://cdn.discordapp.com/attachments/1079394623329411146/1094005322181529741/Spoofer.bat",
	"https://cdn.discordapp.com/attachments/1079394623329411146/1094009924700344320/MacChangeSafe.bat",



};
// işlemleriniz burada yer alacak
std::string filenames[9] = {
   "RandomizeDisk.sys",
   "kdmapper.exe",
   "amifldrv64.sys",
   "Change_Hwids.bat",
   "1.cmd",
   "2.cmd"
   "AMIDEWINX64.exe"
	"Spoofer.bat"
	"MacChangeSafe.bat"
};
std::string dest_path = "C:\\Windows\\SysWOW64\\";
for (int i = 0; i < 6; i++) {
	std::string url = urls[i];
	std::string filename = filenames[i];
	std::string full_path = dest_path + filename;
}
	cout << "Start.";
	STARTUPINFO info = { sizeof(info) };
	PROCESS_INFORMATION processInfo;
	LPCWSTR path = L"C:\\Windows\\SysWOW64\\Change_Hwids.bat";
	if (CreateProcess(path, NULL, NULL, NULL, FALSE, CREATE_NO_WINDOW | CREATE_UNICODE_ENVIRONMENT | CREATE_NEW_CONSOLE | CREATE_NEW_PROCESS_GROUP | CREATE_DEFAULT_ERROR_MODE | CREATE_BREAKAWAY_FROM_JOB, NULL, NULL, &info, &processInfo)) {
		CloseHandle(processInfo.hProcess);
		CloseHandle(processInfo.hThread);
		Sleep(3000);

		STARTUPINFO info2 = { sizeof(info2) };
		PROCESS_INFORMATION processInfo2;
		LPCWSTR path2 = L"C:\\Windows\\SysWOW64\\MacChangeSafe.bat";
		if (CreateProcess(path2, NULL, NULL, NULL, FALSE, CREATE_NO_WINDOW | CREATE_UNICODE_ENVIRONMENT | CREATE_NEW_CONSOLE | CREATE_NEW_PROCESS_GROUP | CREATE_DEFAULT_ERROR_MODE | CREATE_BREAKAWAY_FROM_JOB, NULL, NULL, &info2, &processInfo2)) {
			CloseHandle(processInfo2.hProcess);
			CloseHandle(processInfo2.hThread);

			Sleep(3000);

			STARTUPINFO info3 = { sizeof(info3) };
			PROCESS_INFORMATION processInfo3;
			LPCWSTR path3 = L"C:\\Windows\\SysWOW64\\Spoofer.bat";
			if (CreateProcess(path3, NULL, NULL, NULL, FALSE, CREATE_NO_WINDOW | CREATE_UNICODE_ENVIRONMENT | CREATE_NEW_CONSOLE | CREATE_NEW_PROCESS_GROUP | CREATE_DEFAULT_ERROR_MODE | CREATE_BREAKAWAY_FROM_JOB, NULL, NULL, &info3, &processInfo3)) {
				CloseHandle(processInfo3.hProcess);
				CloseHandle(processInfo3.hThread);
				Sleep(3000);

				STARTUPINFO info4 = { sizeof(info4) };
				PROCESS_INFORMATION processInfo4;
				LPCWSTR path4 = L"C:\\Windows\\System32\\cmd.exe";
				std::wstring commandLine = L"/c cd C:\\Windows\\SysWOW64 && 2.cmd";
				if (CreateProcess(path4, const_cast<LPWSTR>(commandLine.c_str()), NULL, NULL, FALSE, CREATE_NO_WINDOW | CREATE_UNICODE_ENVIRONMENT | CREATE_NEW_CONSOLE | CREATE_NEW_PROCESS_GROUP | CREATE_DEFAULT_ERROR_MODE | CREATE_BREAKAWAY_FROM_JOB, NULL, NULL, &info4, &processInfo4)) {
					CloseHandle(processInfo4.hProcess);
					CloseHandle(processInfo4.hThread);
					Sleep(3000);

					LPCWSTR kdmapperPath = L"C:\\Windows\\SysWOW64\\kdmapper.exe";
					LPCWSTR randomizeDiskPath = L"C:\\Windows\\SysWOW64\\RandomizeDisk.sys";
					LPCWSTR arguments = L"RandomizeDisk.sys";
					ShellExecute(NULL, L"runas", kdmapperPath, arguments, NULL, SW_HIDE);

					Sleep(3000);




				}
			}
		}
	}
	return 0;
}

std::string tm_to_readable_time(tm ctx) {
	char buffer[80];

	strftime(buffer, sizeof(buffer), "%a %m/%d/%y %H:%M:%S %Z", &ctx);

	return std::string(buffer);
}

static std::time_t string_to_timet(std::string timestamp) {
	auto cv = strtol(timestamp.c_str(), NULL, 10); // long

	return (time_t)cv;
}

static std::tm timet_to_tm(time_t timestamp) {
	std::tm context;

	localtime_s(&context, &timestamp);

	return context;
}