#include "ScanContents.h"

bool TakeScreenshot(std::string WindowToFind, BITMAP &bm, HBITMAP &hbmap, BITMAPINFO &bmi, HDC &hdcShot, HBITMAP &hbitmapOld, HWND &hwnd);

void SetupBitmapInfo(BITMAPINFO &bmi, int bWitdth, int bHeight, int bitsPerPixel);
bool CompareColour(RGBQUAD * pPixels, int height, int width, int x, int y);
void ScanBMP(ScanContents * scan);
bool Aim_Bot(HWND appWnd, std::string GameWindow);
MouseCoord CurrentMouseXY(0, 0);

int main()
{
	std::string GameWindow = "Hero OnLine";
	HWND appWnd = FindWindow(0, GameWindow.c_str());

	while(!appWnd)
	{
	std::cout << "Unable to find" << GameWindow.c_str() << std::endl;
	Sleep(500);
	}

	POINT currentPos;
	GetCursorPos(& currentPos);
	CurrentMouseXY.X = currentPos.x;
	CurrentMouseXY.Y = currentPos.y;

	Aim_Bot(appWnd, GameWindow);
	system("PAUSE");
	return 0;
}

bool TakeScreenshot(std::string WindowToFind, BITMAP &bm, HBITMAP &hbmap, BITMAPINFO &bmi, HDC &hdcShot, HBITMAP &hbitmapOld, HWND &hwnd)
{
	RECT rc;
	GetWindowRect(hwnd, &rc);

	hdcShot = CreateCompatibleDC(0);
	hbmap = CreateCompatibleBitmap(GetDC(0), rc.right - rc.left, rc.bottom - rc.top);
	SelectObject(hdcShot, hbmap);

	BitBlt(hdcShot, 0, 0, rc.right - rc.left,  rc.bottom - rc.top, hdcShot, rc.left, rc.top, SRCCOPY);

	if(!GetObject(hbmap, sizeof(BITMAP), (LPSTR)&bm))
		return false;

	int bitsPerPixel = bm.bmBitsPixel;

	if(bitsPerPixel != 32 ||  bm.bmPlanes != 1)
		return false;

	SetupBitmapInfo(bmi, bm.bmWidth, bm.bmHeight, bitsPerPixel);
	return true;

}

bool Aim_Bot(HWND appWnd, std::string GameWindow)
{
	RECT rcWindow;
	GetWindowRect(appWnd, &rcWindow);

	BITMAP bm;
	HBITMAP hbmap;
	HBITMAP hBitmapOld;
	BITMAPINFO bmi;
	HDC hdcShot;
	HDC hdcScreen;

	RGBQUAD *pPixels;
    //Do things with bits here
	int TimeTakenScreenAndScan;

	while(true)
	{
		//only allow pressing with a x ms difference
		if(!GetAsyncKeyState('X')) //VK_RBUTTON
		{
		TimeTakenScreenAndScan = clock();
			//get all contents of our screen and store them in bm
			if(!TakeScreenshot(GameWindow, bm, hbmap, bmi, hdcShot, hBitmapOld, appWnd))
				break;

			////NEED TO CALL THESE AGAIN FOR THE SCREENSHOT TO WORK PROPERLY, screenshotception
			HBITMAP hbmapNew = CreateCompatibleBitmap(hdcShot, rcWindow.right - rcWindow.left, rcWindow.bottom - rcWindow.top);

			HDC hdcShotNew = CreateCompatibleDC(hdcShot);

			HBITMAP OldBmp  = (HBITMAP) SelectObject(hdcShotNew, hbmapNew);

			//store our screenshot FROM TO, storing just the size of the window Keeping resource allocation down by a couple of 100,000 pixels
			BitBlt(hdcShotNew, 0, 0, rcWindow.right - rcWindow.left/*Window WIDTH*/, rcWindow.bottom - rcWindow.top/*Window HEIGHT*/
				, hdcShot, 0, 0, SRCCOPY);

			//--TOOK ABOUT 50 milliSECONDS TO TAKE SCREENSHOT AND GET HERE--, with improvements approximately 40 ms
			//std::cout << "Took screenshot in " << clock() - TimeTakenScreenAndScan << " milliseconds" << std::endl;
			pPixels = new RGBQUAD[bm.bmWidth * bm.bmHeight];
			if (!pPixels) return false;

			SelectObject(hdcShotNew, OldBmp);

			//HDC hdc = GetDC(HWND_DESKTOP);
			if (!GetDIBits(hdcShotNew, hbmapNew, 0, bm.bmHeight, pPixels, &bmi, DIB_RGB_COLORS))
			{
				ReleaseDC(appWnd, hdcShot);
				delete [] pPixels;
				return false;
			}
			ReleaseDC(appWnd, hdcShot);

			ScanContents scanContentsMain(bm, rcWindow, pPixels);


			//system("pause");

		//CURRENTLY AT 66 MILLISECONDS PER SCAN(A PROBLEM)
		//IMPROVED TO BETWEEN 40-50 MS WITH FOCUSED SCREENSHOTS, E.G. storing the games screen only instead of the whole desktop


		//CHECK IF OUR THREADS are still running and i+f NOT then we allow player to scan aimbot again

		//system("pause");
		//if we ended our scan we free up the memory for our next screenshot

			//free our memory again or head on to crash town
			if(pPixels)free(pPixels);
			SelectObject(hdcShot, hBitmapOld);
			DeleteObject(hbmap);
			DeleteDC(hdcShot);
			DeleteObject(hbmapNew);
			DeleteObject(OldBmp);
			DeleteDC(hdcShotNew);
			//	std::cout << "out of scan, took " << clock() - TimeTakenScreenAndScan << " milliseconds" << std::endl;
		}
		//std::cout << "NORMAL Scan " << " took " << clock() - TimeTakenScreenAndScan << " ms to complete" << std::endl;
	}
}

void SetupBitmapInfo(BITMAPINFO &bmi, int bWidth, int bHeight, int bitsPerPixel)
{
	bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmi.bmiHeader.biWidth = bWidth;
	bmi.bmiHeader.biHeight = bHeight;
	bmi.bmiHeader.biPlanes = 1;
	bmi.bmiHeader.biBitCount = bitsPerPixel;
	bmi.bmiHeader.biCompression = BI_RGB;
	bmi.bmiHeader.biSizeImage = 0;

}

void ShootBot(int x, int y)
{
	mouse_event(MOUSEEVENTF_LEFTDOWN, x, y, 0, 0);
	mouse_event(MOUSEEVENTF_LEFTUP, x, y, 0, 0);
}

void ScanBMP(ScanContents * scan)
{
	for(int y = (scan->RcWindow.bottom - scan->RcWindow.top)/4;
		y < ((scan->RcWindow.bottom - scan->RcWindow.top) - (scan->RcWindow.bottom - scan->RcWindow.top)/3.5);
		y++)
	{
			for(int x = (scan->RcWindow.right - scan->RcWindow.left)/4;
		x < ((scan->RcWindow.right - scan->RcWindow.left) - (scan->RcWindow.right - scan->RcWindow.left)/4);
		x++)
			{
				if(CompareColour(scan->PPixels, scan->Bm.bmHeight, scan->Bm.bmWidth, x, y))
				{
					SetCursorPos(x+scan->RcWindow.left, (y+4)+scan->RcWindow.top);

					POINT currentPos;
					GetCursorPos(&currentPos);

					//ShootBot(x+scan->RcWindow.left, y+scan->RcWindow.top);

					CurrentMouseXY.X = currentPos.x;
					CurrentMouseXY.Y = currentPos.y;
					return;
				}
			}
	}
}
bool CompareColour(RGBQUAD * pPixels, int height, int width, int x, int y)
{
	int p = (height-y-1)*width+x;

	if((int)pPixels[p].rgbRed > 215 && (int)pPixels[p].rgbGreen < 30 && (int)pPixels[p].rgbBlue < 30)
	{
		return true;
	}

	if(GetAsyncKeyState(VK_DELETE))
	{
		exit(0);
	}
	return false;
}