#include <windows.h>
#include <stdint.h> 
#include <xinput.h>
#include <winuser.h>
#include <dsound.h>



#define internal static
#define local_persist static
#define global_variable static



typedef uint8_t uint8;
typedef uint16_t uint16;
typedef uint32_t uint32;
typedef uint64_t uint64;

typedef int8_t int8;
typedef int16_t int16;
typedef int32_t int32;
typedef int64_t int64;

typedef int32 bool32;

// *TODO: This is all global...for now...
global_variable bool GlobalRunning;
global_variable LPDIRECTSOUNDBUFFER GlobalSecondarySoundBuffer;


struct win32_window_dimension
{
	int Width;
	int Height;
};

struct win32_offscreen_buffer 
{
	//NOTE: Always assumes bytesperpixel is 4 (32 bit), memory order: BB GG RR XX -> in mem: 0x xx RR GG BB
	BITMAPINFO Info;
	void *Memory;
	int Width, Height;
	//int BytesPerPixel;
	int Pitch;
};
global_variable win32_offscreen_buffer GlobalBackBuffer;
// We've created a macro stub function and turned it into a type
// we then create a global var pointing to the type of the function stub
// we then redefine the function stub pointer so it assumes the name 
// of the function we want to steal out of the original lib we don't want to load

// XInputGetState
//create the macro using define, so name will now assume the function signature

#define X_INPUT_GET_STATE(name) DWORD WINAPI name(DWORD dwUserIndex, XINPUT_STATE *pState)
typedef X_INPUT_GET_STATE(x_input_get_state); // this is actually a macro'd stub function named: x_input_get_state(DWORD dwUserIndex, XINPUT_STATE *pState);

// this is the stub function's definition
X_INPUT_GET_STATE(XInputGetStateStub)
{
	return(ERROR_DEVICE_NOT_CONNECTED);
}

// this is a global pointer pointing to: x_input_get_state(DWORD dwUserIndex, XINPUT_STATE *pState); now we use XInputGetState as the stub function
global_variable x_input_get_state *XInputGetState_ = XInputGetStateStub;
#define XInputGetState XInputGetState_

// XInputeSetSTATE
#define X_INPUT_SET_STATE(name) DWORD WINAPI name(DWORD dwUserIndex, XINPUT_VIBRATION *pVibration)
typedef X_INPUT_SET_STATE(x_input_set_state);

X_INPUT_SET_STATE(XInputSetStateStub)
{
	return(ERROR_DEVICE_NOT_CONNECTED);
}

global_variable x_input_set_state *XInputSetState_ = XInputSetStateStub;
#define XInputSetState XInputSetState_


#define DIRECT_SOUND_CREATE(name) HRESULT WINAPI name( LPCGUID pcGuidDevice,  LPDIRECTSOUND *ppDS,  LPUNKNOWN pUnkOuter)
typedef DIRECT_SOUND_CREATE(direct_sound_create);

//DIRECT_SOUND_CREATE(DirectSoundCreate)
//{
//	return(DSERR_NODRIVER);
//}



internal void Win32LoadXInput(void)
{
	//we're going to do the steps the window loader does when it loads our program
	HMODULE XInputLibrary = LoadLibrary("xinput1_4");
	if (!XInputLibrary)
	{
		// *TODO : Create diagnostics
		HMODULE XInputLibrary = LoadLibrary("xinput1_3");
	}

	
	if (XInputLibrary)
	{
		XInputGetState = (x_input_get_state *)GetProcAddress(XInputLibrary, "XInputGetState");
		if (!XInputGetState) { XInputGetState = XInputGetStateStub; }

		XInputSetState = (x_input_set_state *)GetProcAddress(XInputLibrary, "XInputSetState");
		if (!XInputSetState) { XInputSetState = XInputSetStateStub; }
		// *TODO : Create diagnostics

	}
	else
	{
		// *TODO : Create diagnostics
		OutputDebugString("Module load failed!");
	}
}


internal win32_window_dimension Win32GetWindowDimension(HWND Window)
{
	win32_window_dimension Result;
	RECT ClientRect;
	GetClientRect(Window, &ClientRect);
	Result.Height = ClientRect.bottom - ClientRect.top;
	Result.Width = ClientRect.right - ClientRect.left;

	return(Result);
}


internal void Win32DisplayBufferInWindow(win32_offscreen_buffer *Buffer, HDC BitmapDeviceContext, int WindowWidth, int WindowHeight)
{
	//*TODO: aspect ratio maintain
	//*TODO: Stretch modes
	
	StretchDIBits(
		BitmapDeviceContext, 0, 0, // this is the start of the destination fill upper left corner (0,0)
		WindowWidth, WindowHeight, // size of destination buffer
		0, 0, // start of buffer upper left
		Buffer->Width, Buffer->Height, // buffer width, buffer height
		Buffer->Memory, // memory contents pointer to image in buffer
		&Buffer->Info,  // info about image
		DIB_RGB_COLORS, // what colour 'space'
		SRCCOPY); //rasterizing operation
}


internal void Win32ResizeDIBSection(win32_offscreen_buffer *Buffer, int Width, int Height)
{
	//*TODO: Bulletproof this
	// may don't free first, free after, but if that fails free first

	if (Buffer->Memory)
	{
		VirtualFree(Buffer->Memory, 0, MEM_RELEASE);
	}
		
	Buffer->Height = Height;
	Buffer->Width = Width;
	//BITMAPINFO info = Buffer.Info;
	int BytesPerPixel = 4;
	Buffer->Info.bmiHeader.biSize = sizeof(Buffer->Info.bmiHeader);
	Buffer->Info.bmiHeader.biWidth = Buffer->Width;/*Width; */
	Buffer->Info.bmiHeader.biHeight = -Buffer->Height /*Height;*/;  //the negative makes it a top-down DIB so it draws from top-left
	Buffer->Info.bmiHeader.biPlanes = 1;
	Buffer->Info.bmiHeader.biBitCount = 32;
	Buffer->Info.bmiHeader.biCompression = BI_RGB;
	Buffer->Info.bmiHeader.biSizeImage = 0;
	Buffer->Info.bmiHeader.biXPelsPerMeter = 0;
	Buffer->Info.bmiHeader.biYPelsPerMeter = 0;
	Buffer->Info.bmiHeader.biClrUsed = 0;
	Buffer->Info.bmiHeader.biClrImportant = 0;
	
	

	//int BitmapMemorySize = (Width * Height) * BytesPerPixel;
	int BitmapMemorySize = (Buffer->Width * Buffer->Height) * BytesPerPixel;
	Buffer->Memory = VirtualAlloc(0, BitmapMemorySize, MEM_RESERVE| MEM_COMMIT, PAGE_READWRITE);

	//*TODO: probably want to initialize to black
	Buffer->Pitch = Width*BytesPerPixel;
}

// define the windows callback messaging responses
LRESULT CALLBACK Win32MainWindowCallback( HWND Window,UINT Message,WPARAM WParam,LPARAM LParam)	
{

	LRESULT Result = 0;
	//win32_offscreen_buffer Buffer;
	
	switch(Message)
	{
	case WM_KEYDOWN:
	
	case WM_KEYUP:

	case WM_SYSKEYDOWN:

	case WM_SYSKEYUP:
	{
		uint32 VKCode = WParam;
		#define KeyWasDownMessageBit (1<<30)
		#define KeyIsDownMessageBit (1<<31)
		#define AltKeyIsDownMessageBit (1<<29)

		bool32 wasKeyDown = ((LParam & KeyWasDownMessageBit) != 0); //use expression since results will be 0 or bit 30, not 1;
		bool32 isKeyDownNow = ((LParam & KeyIsDownMessageBit) == 0);
		
  		if (wasKeyDown != isKeyDownNow)
		{

			if (VKCode == 'W')
			{

			}
			else if (VKCode == 'S')
			{

			}
			else if (VKCode == 'A')
			{

			}
			else if (VKCode == 'D')
			{

			}

			else if (VKCode == 'Q')
			{

			}
			else if (VKCode == 'E')
			{

			}

			else if (VKCode == VK_UP)
			{

			}
			else if (VKCode == VK_DOWN)
			{

			}
			else if (VKCode == VK_LEFT)
			{
				OutputDebugString("LEFT :");
				if (isKeyDownNow)
				{
					OutputDebugString(" IS down!\n");
				}
				if (wasKeyDown)
				{
					OutputDebugString(" WAS down!\n");
				}
			}
			else if (VKCode == VK_RIGHT)
			{

			}
			else if (VKCode == VK_ESCAPE)
			{
				GlobalRunning = false;
			}
			else if (VKCode == VK_SPACE && isKeyDownNow)
			{
				OutputDebugString("Space is down\n");
			}
			else if (VKCode == VK_SPACE && wasKeyDown)
			{
				OutputDebugString("Space is up\n");
			}

		}
		
		bool32 AltKeyWasDown = (LParam & AltKeyIsDownMessageBit);
	

		if ((VKCode == VK_F4) && AltKeyWasDown)
		{
			GlobalRunning = false;
		}
	}break;

		case WM_SETFOCUS:
		{
			
			
		}break;

		case WM_KILLFOCUS:
		{


		}break;

		case WM_PAINT:
		{
			PAINTSTRUCT Paint;
			HDC BitmapDeviceContext = BeginPaint(Window, &Paint);
		
			win32_window_dimension Dimension = Win32GetWindowDimension(Window);
			int X = Paint.rcPaint.left;
			int Y = Paint.rcPaint.top;
			int Height = Paint.rcPaint.bottom - Paint.rcPaint.top;
			int Width = Paint.rcPaint.right - Paint.rcPaint.left;
			Win32DisplayBufferInWindow(&GlobalBackBuffer, BitmapDeviceContext, Dimension.Width, Dimension.Height);
		
			EndPaint(Window, &Paint);
			OutputDebugStringA("WM_SIZE\n");
		}break;

		case WM_DESTROY:
		{
			//*TODO: Handle this as an error - recreate window?
			GlobalRunning = false;
			OutputDebugStringA("PostQuitMessage(0) - WM_DESTROY\n");
		}break;

		case WM_CLOSE:
		{
			//*TODO: Handle this with a message to the user?
			GlobalRunning = false;
			OutputDebugStringA("WM_CLOSE\n");
		}break;

		case WM_ACTIVATEAPP: //let's us know if user has clicked and made the window active
		{
			OutputDebugStringA("WM_ACTIVATEAPP\n");
		}break;

		default:
		{
		//	OutputDebugStringA("Default case!\n");
			//this is the catchall LRESULT return to windows, there's a default Windows way to do this
			Result = DefWindowProc(Window, Message, WParam, LParam);
		}break;
	}

	return(Result);

}


internal void RenderWeirdGrad(win32_offscreen_buffer *Buffer, int XOffset, int YOffset)
{
	//*TODO: Let's see what the optimizer does in regard to using a pointer to win32_offscreen_buffer vs. copying it directly

	uint8 *Row = (uint8 *)Buffer->Memory; // this ensures as we move the pointer it's moving by 1 byte (8bits)

	for (int Y = 0;
		Y < Buffer->Height;
		++Y)
	{
		//uint32 *Pixel = (uint32 *)Row; //cast it so it now jumps by 4 bytes (1 pixel) instead of just 1 as cast above
		uint32 *Pixel = (uint32 *)Row;


		for (int X = 0;
			X < Buffer->Width;
			++X)
		{
			// fractally weirdness
			//YOffset += Y;
			//XOffset += X;
			uint8 Red = (Y + XOffset); // this makes the weird scan line effect
			uint8 Gr = (X + XOffset);
			uint8 Bl = (Y + YOffset);

			//this shifts the green values so it sits after yet before the blue (ie: xx RR GG BB - so green's 8 bits needs to actually sit in the 9-16 area
			*Pixel++ = ((Red << 16) | (Gr << 8) | Bl);
		

		}
		Row += Buffer->Pitch;

	}
}

internal void Win32InitDSound(HWND Window, int32 BufferSize, int32 SamplesPerSecond)
{
	//we're going to do the steps the window loader does when it loads our program
	HMODULE DSoundLibrary = LoadLibrary("dsound.dll");

	if (DSoundLibrary)
	{
		direct_sound_create *DirectSoundCreate = (direct_sound_create *)GetProcAddress(DSoundLibrary, "DirectSoundCreate");

		LPDIRECTSOUND DirectSound;
 		if (DirectSoundCreate && SUCCEEDED(DirectSoundCreate(0, &DirectSound, 0)))
		{
			WAVEFORMATEX Waveformat = {}; 
			Waveformat.wFormatTag = WAVE_FORMAT_PCM;
			Waveformat.nChannels = 2;
			Waveformat.nSamplesPerSec = SamplesPerSecond;
			Waveformat.wBitsPerSample = 16;
			Waveformat.nBlockAlign = (Waveformat.nChannels * Waveformat.wBitsPerSample) / 8;
			Waveformat.nAvgBytesPerSec = Waveformat.nSamplesPerSec * Waveformat.nBlockAlign;
			Waveformat.cbSize = 0;

			if (SUCCEEDED(DirectSound->SetCooperativeLevel(Window, DSSCL_PRIORITY)))
			{
				// *TODO: look into DSBCAPS_GETCURRENTPOSITION2
				DSBUFFERDESC BufferDescription = {};
				BufferDescription.dwSize = sizeof(BufferDescription); // primary buffer must be set to 0
				BufferDescription.dwFlags = DSBCAPS_PRIMARYBUFFER;

				//create primary buffer - THIS IS NOT ACTUALLY A BUFFER IT IS A HANDLE TO THE PRIMARY SOUND DEVICE THAT PUTS THE SOUNDCARD
				// INTO A MODE TO PLAY THE FORMAT! - HELLO WINDOWS PLEASE PLAY THIS FORMAT ON THE SOUNDCARD 
				LPDIRECTSOUNDBUFFER PrimaryBuffer;

				if (SUCCEEDED(DirectSound->CreateSoundBuffer(&BufferDescription, &PrimaryBuffer, 0)))
				{

					HRESULT Error = PrimaryBuffer->SetFormat(&Waveformat);

					OutputDebugString("Primary buffer created!\n\n");
					//if (SUCCEEDED(PrimaryBuffer->SetFormat(&Waveformat)))
					if (SUCCEEDED(Error))
					{
						// format is set!
						OutputDebugString("Primary sound buffer set format succeeded!\n\n");
					}
					else
					{
						// *TODO: DIAGNOSTIC
					}
				}
				else
				{
					//*TODO: Create Diagnostic
				}
			}
			else
			{
				// *TODO: DIAGNOSTIC
			}
				DSBUFFERDESC BufferDescription = {};

				BufferDescription.dwSize = sizeof(BufferDescription); 
				BufferDescription.dwFlags = 0;
				BufferDescription.dwBufferBytes = BufferSize;
				BufferDescription.lpwfxFormat = &Waveformat;

				
				if (SUCCEEDED(DirectSound->CreateSoundBuffer(&BufferDescription, &GlobalSecondarySoundBuffer, 0)))
				{
					OutputDebugString("Secondary sound buffer creation succeeded!\n\n");

				}
				else // DirectSoundCreate failed!
				{
					// *TODO: Create diagnostic
				}


		}
		else // No direct sound library found!
		{
			// *TODO: Create diagnostic
		}


	}
}



// **** MAIN MAIN MAIN MAIN ****
// **** MAIN MAIN MAIN MAIN ****
// **** MAIN MAIN MAIN MAIN ****

int CALLBACK WinMain(
	HINSTANCE Instance,
	HINSTANCE PrevInstance,
	LPSTR     CmdLine,
	int       CmdShow
	)
{
	
	Win32LoadXInput();
	// create instance of windowclass and initialize to 0/null
	WNDCLASS WindowClass = {};
	
	// buffer stretch into window (or shrink)
	Win32ResizeDIBSection(&GlobalBackBuffer, 1280, 720);
	
	//create copy of xinputvibration struct for use later
	_XINPUT_VIBRATION InputVibration;
	
	//define the window class fields
	WindowClass.style = CS_HREDRAW|CS_VREDRAW;
	WindowClass.lpfnWndProc = Win32MainWindowCallback; //how window responds to events by passing in a function via pointer, defined above
	WindowClass.hInstance = Instance; // get the windowhandle instance
	//HICON     hIcon; //may be used later
	WindowClass.lpszClassName = "HandMadeHeroWindowClass";

	//MessageBox(0, "This is handmade hero!", "handmade caption", MB_OK | MB_ICONINFORMATION);

	//REGISTERING THE WINDOW CLASS
	
	if (RegisterClass(&WindowClass))
	{
		HWND Window = CreateWindowExA(
			0, // extended style, no thanks
			WindowClass.lpszClassName,
			"Handmadehero!",
			WS_VISIBLE | WS_OVERLAPPEDWINDOW,
			CW_USEDEFAULT,
			CW_USEDEFAULT,
			CW_USEDEFAULT,
			CW_USEDEFAULT,
			0,
			0,
			Instance,
			0);
		
		if (Window)
		{
			GlobalRunning = true;
			// since we used CS_OWNDC we have this device context forever since we are not sharing it with anyone
			/*HDC DeviceContext = GetDC(Window);*/

			// For Graphics Test
			int XOffset = 0;
			int YOffset = 0;
			
			// For sound test
			int SamplesPerSecond = 48000;
			int BytesPerSample = sizeof(int16) * 2; //how many bytes needed for one LEFT ch/RIGHT ch pair
			int Hz = 4000; //random test tone
			uint32 RunningSampleIndex = 0;
			int SecondaryBufferSize = (SamplesPerSecond * BytesPerSample);
			int SquareWavePeriod = SamplesPerSecond/Hz;
			int HalfSquareWavePeriod = SquareWavePeriod / 2;
			int16 VolumeAmount = 14000;
			bool32 isBufferFilled = false;
				
			
			Win32InitDSound(Window, SecondaryBufferSize, SamplesPerSecond);
			
			
			
			while (GlobalRunning)
			{
				MSG Message;
				
				while (PeekMessage(&Message, 0, 0, 0, PM_REMOVE))
				{
					
					if (Message.message == WM_QUIT)
					{
						GlobalRunning = false;
					}
					TranslateMessage(&Message);
					DispatchMessage(&Message);
				}
				//NOTE: Should we poll this more frequently?
				for (DWORD ControllerIndex = 0;
					ControllerIndex < XUSER_MAX_COUNT;
					++ControllerIndex)
				{
					XINPUT_STATE ControllerState;
					if (XInputGetState(ControllerIndex, &ControllerState) == ERROR_SUCCESS )
					{
						// Controller connected!
						//*TODO: Look at ControllerState.dwPacketNumber increments too rapidly
						XINPUT_GAMEPAD *Pad = &ControllerState.Gamepad;

						
						Pad->bLeftTrigger;
						Pad->bRightTrigger;
						Pad->sThumbLX;
						Pad->sThumbLY;
						Pad->sThumbRX;
						Pad->sThumbRY;
						bool32 DPadUp = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_UP);			//	0x0001
						bool32 DPadDown = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_DOWN);		//  0x0002
						bool32 DPadLeft = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_LEFT);		//  0x0004
						bool32 DPadRight = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_RIGHT);	//  0x0008
						
						bool32 DPadButtonA = (Pad->wButtons & XINPUT_GAMEPAD_A);			//	0x1000
						bool32 DPadButtonB = (Pad->wButtons & XINPUT_GAMEPAD_B);			//	0x2000
						bool32 DPadButtonX = (Pad->wButtons & XINPUT_GAMEPAD_X);			//	0x4000
						bool32 DPadButtonY = (Pad->wButtons & XINPUT_GAMEPAD_Y);			//	0x8000
						
						bool32 DPadStart = (Pad->wButtons & XINPUT_GAMEPAD_START);			//	0x0010
						bool32 DPadBack = (Pad->wButtons & XINPUT_GAMEPAD_BACK);			//	0x0020
						
						bool32 DPadLeftThumbSButton = (Pad->wButtons & XINPUT_GAMEPAD_LEFT_THUMB);			//	0x0040
						bool32 DPadRightThumbSButton = (Pad->wButtons & XINPUT_GAMEPAD_RIGHT_THUMB);			//	0x0080
						
						bool32 DPadLBumper = (Pad->wButtons & XINPUT_GAMEPAD_LEFT_SHOULDER);			//	0x0100
						bool32 DPadRBumper = (Pad->wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER);			//	0x0200
					
						uint8 DPadLTrigger = Pad->bLeftTrigger;
						uint8 DPadRTrigger = Pad->bRightTrigger;

						int16 DPadLXAxis = Pad->sThumbLX;
						int16 DPadLYAxis = Pad->sThumbLY;
						int16 DPadRXAxis = Pad->sThumbRX;
						int16 DPadRYAxis = Pad->sThumbRY;

						XOffset += -DPadLXAxis >> 12;
						YOffset += -DPadLYAxis >> 12;
						if (DPadButtonA)
						{
							YOffset += 2;
							
							InputVibration.wLeftMotorSpeed = 10000;
							InputVibration.wRightMotorSpeed = 10000;
						}
						else
						{
							// No controller detected!
							InputVibration.wLeftMotorSpeed = 0;
							InputVibration.wRightMotorSpeed = 0;
						}

					}
					else
					{
						
					}
				}

				HDC DeviceContext = GetDC(Window);
				XInputSetState(0, &InputVibration);
				
				//prepare the backbuffer
				RenderWeirdGrad(&GlobalBackBuffer, XOffset, YOffset);
				// DirectSound output test right here
				//lock the buffer
				
				// Begin Sound Testing
				DWORD CurrentPlayCursor;
				DWORD CurrentWriteCursor;
							
				if (SUCCEEDED(GlobalSecondarySoundBuffer->GetCurrentPosition(
					&CurrentPlayCursor,
					&CurrentWriteCursor
					)))
				{
					DWORD BytesToWrite;
					DWORD ByteToLock = (RunningSampleIndex*BytesPerSample) % (SecondaryBufferSize);
				
					//*TODO: This is pretty dangerous as we could end up overwriting the buffer before 
					// the original contents are played, must find a better way to do this
					if (ByteToLock == CurrentPlayCursor)
					{
						BytesToWrite = SecondaryBufferSize;
					}
					else if (ByteToLock > CurrentPlayCursor)
					{ 
						// add the two chunks of the buffer together [--ChunkA---Play-----Write---ByteToLock---ChunkB---]
						BytesToWrite =  SecondaryBufferSize - ByteToLock; //From end to ByteToLock ChunkB
						BytesToWrite += CurrentPlayCursor; // from 0 to PlayCursor ChunkA
					}
					else
					{
						BytesToWrite = CurrentPlayCursor - ByteToLock;
					}
					
					//DWORD WritePointer = GlobalSecondarySoundBuffer->GetCurrentPosition(0,&WritePointer);
				
					VOID *FirstLock;
					VOID *SecondLock;
					DWORD BytesInFirstLock;
					DWORD BytesInSecondLock;
				

					if (SUCCEEDED(GlobalSecondarySoundBuffer->Lock(ByteToLock, BytesToWrite,
						&FirstLock, &BytesInFirstLock,
						&SecondLock, &BytesInSecondLock,
						0)))
					{
					DWORD FirstLockSampleCount = BytesInFirstLock / BytesPerSample;
					
						//OutputDebugString("Locking of secondary buffer success!\n\n");
						
						//*TODO: assert if BytesInXLock does not return int16*2 size!
						int16 *SampleOut = (int16*)FirstLock;
						for (DWORD SampleIndex = 0;
							SampleIndex < FirstLockSampleCount;
							++SampleIndex)
						{
							
							int16 SampleValue = ((++RunningSampleIndex / HalfSquareWavePeriod) % 2) ? VolumeAmount : -VolumeAmount;

							++*SampleOut = SampleValue; // increment pointer, write samplevalue
							++*SampleOut = SampleValue;
							
						}
						
						DWORD SecondLockSampleCount = BytesInSecondLock / BytesPerSample;
						SampleOut = (int16 *)SecondLock;
						for (DWORD SampleIndex = 0;
							SampleIndex < SecondLockSampleCount;
							++SampleIndex)
						{
								
							int16 SampleValue = ((++RunningSampleIndex / HalfSquareWavePeriod) % 2) ? VolumeAmount : -VolumeAmount;

							++*SampleOut = SampleValue;
							++*SampleOut = SampleValue;
							

						}
						GlobalSecondarySoundBuffer->Unlock(FirstLock, BytesInFirstLock,SecondLock, BytesInSecondLock); // we're done writing to buffer
						if (!isBufferFilled)
						{
							GlobalSecondarySoundBuffer->Play(0, 0, DSBPLAY_LOOPING);
							isBufferFilled = true;
						}

						
					}
					else
					{
						OutputDebugString("Locking failed!\n\n");
					}

				} // end of success check to see if play and write pointers exist
				else
				{
					OutputDebugString("Play and write pointers may not exist!\n\n");
				}

				
				//paint the buffer
				win32_window_dimension Dimension = Win32GetWindowDimension(Window);
				Win32DisplayBufferInWindow(&GlobalBackBuffer, DeviceContext, Dimension.Width, Dimension.Height);
				ReleaseDC(Window, DeviceContext);
				++XOffset;
			
			}

		}
		else 
		{
			//*TODO: Window non-existent Log it!
			OutputDebugStringA("Window non-existent ");
		}
	}
	
	else 
	{
		//*TODO: RegisterClass(&WindowClass) is bad Log it!
		OutputDebugStringA("RegisterClass(&WindowClass) is bad ");
	}
	
	return(0);
}