#include <Windows.h>
#include <stdint.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;



//This is a global for now
global_variable bool Running;
global_variable BITMAPINFO BitmapInfo;
global_variable void* BitmapMemory;
global_variable int BitmapWidth;
global_variable int BitmapHeight;





internal void Win32ResizeDIBsection(int Width, int Height)
{
    // Bulletproof this
    //Maybe don't free the memory first, use the old memory of the buffer 

    //free after it is created, free first is that fails however
    
    if(BitmapMemory)
    {   
        VirtualFree(BitmapMemory, 0, MEM_RELEASE);
    }
    BitmapWidth = Width;
    BitmapHeight = Height;

    //Set the bitmapinfo to define the limits of the buffer
    BitmapInfo.bmiHeader.biSize = sizeof(BitmapInfo.bmiHeader);
    BitmapInfo.bmiHeader.biWidth = BitmapWidth;
    BitmapInfo.bmiHeader.biHeight = -BitmapHeight;
    BitmapInfo.bmiHeader.biPlanes = 1;
    BitmapInfo.bmiHeader.biBitCount = 32;
    BitmapInfo.bmiHeader.biCompression = BI_RGB;
    
    //Allocate ourselves
    int BytesPerPixel = 4;
    int BitmapMemorySize = (BitmapWidth * BitmapHeight) * BytesPerPixel;
    BitmapMemory = VirtualAlloc(0, BitmapMemorySize, MEM_COMMIT, PAGE_READWRITE);

    int Pitch  = Width * BytesPerPixel;
    uint8* Row = (uint8*)BitmapMemory;
    for(int y = 0; y < BitmapHeight; ++y)
    {
        uint8* Pixel = (uint8*)Row;
        for(int x = 0; y < BitmapWidth; ++x)
        {
            /*                0  1   2  3
            Pixel in memory: BB GG  RR xx
            Little Endian Arcitecture
            0x xxGGBBRR
            >  xxRRGGBB They swapped it, B is first, G is second, R is last
            */
            
            *Pixel = 0; //It throws the exception here
            ++Pixel;


            *Pixel = 0;
            ++Pixel;

            
            *Pixel = 255;
            ++Pixel;

            
            *Pixel = 0;
            ++Pixel;
            
        }

        Row += Pitch;
    }
}





internal void Win32UpdateWindow(HDC DeviceContext, RECT *WindowRect,int x,int y,int Width,int Height)
{

    int WindowWidth = WindowRect->right - WindowRect->left;
    int WindowHeight = WindowRect->bottom - WindowRect->top;

    //Stretches or updates the pixels within the rectangle that has just been changed in size
    StretchDIBits(DeviceContext, 
                  /*
                  x, y, Width, Height,
                  x, y, Width, Height,
                  */
                  0, 0, BitmapWidth, BitmapHeight,
                  0, 0, WindowWidth, WindowHeight,
                  BitmapMemory,
                  &BitmapInfo,
                  DIB_RGB_COLORS, SRCCOPY);
}





LRESULT CALLBACK 
Win32MainWindowCallback(HWND   Window,
                   UINT   Message, 
                   WPARAM WParam,
                   LPARAM LParam)
{
    LRESULT Result = 0;

//  A switch statement that takes in a message and outputs it in the debugger
//  It also takes in a paint message that once called, it draws a rectangle 
    switch(Message)
    {
        case WM_SIZE:
        {
            RECT ClientRect;
            GetClientRect(Window, &ClientRect);
            int Height = ClientRect.bottom - ClientRect.top;
            int Width = ClientRect.right - ClientRect.left;
        

            Win32ResizeDIBsection(Width, Height);
            OutputDebugStringA("WM_SIZE\n");
        } break;

        case WM_DESTROY:
        {
            //Handle this as an error, recreate window
            Running = false;
            OutputDebugStringA("WM_DESTROY\n");
        }break;
        
        case WM_CLOSE:
        {
            //Handle this as a pop up message to the user
            Running = false;
            OutputDebugStringA("WM_CLOSE\n");
        }break;

        case WM_ACTIVATEAPP:
        {
            OutputDebugStringA("WM_ACTIVATEAPP\n");
        }break;

        case WM_PAINT:
        {
            // Contains a pain struct with a RECT function that draws a rectangle
            // We create a handle and set a few variables
            // We draw a rectangle using the variables from rcpaint
            // We go back and fourth between black and white background when the window is updated
            PAINTSTRUCT Paint;
            RECT ClientRect;
            GetClientRect(Window, &ClientRect);
            HDC DeviceContext = BeginPaint(Window, &Paint);
            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;
            Win32UpdateWindow(DeviceContext, &ClientRect, x, y, Width, Height);
            EndPaint(Window, &Paint);
            
        }break;

        default:
        {
//            OutputDebugStringA("Default\n");
            Result = DefWindowProc(Window, Message, WParam, LParam);
        }break;
    }

    return (Result);

}





int CALLBACK WinMain(
    HINSTANCE Instance,
    HINSTANCE PrevInstance,
    LPSTR     CommandLine,
    int       ShowCode)
{
    WNDCLASS WindowClass = {};
    
    WindowClass.style = CS_OWNDC;
    WindowClass.lpfnWndProc = Win32MainWindowCallback;
    WindowClass.hInstance = Instance;
//    HICON     hIcon;
    WindowClass.lpszClassName = "HandMadeHeroWindowClass";
    
    if(RegisterClass(&WindowClass))
    {
        //Creates an overlapping window that is visible and has a border
    HWND WindowHandle = 
        CreateWindowExA(
        0,
        WindowClass.lpszClassName,
        "ThisIsWindowYo",
        WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_BORDER,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        0,
        0,      
        Instance,
        0);

        if(WindowHandle)
        {
            Running = true;   
            while(Running)
            {
                //Loops through messages that are past to windows, it breaks when it recives a quit message
                //This allows the window to be displayed for more than one message
                MSG Message;
                BOOL MessageResult = GetMessage(&Message, 0, 0, 0);
                if(MessageResult > 0)
                {
                    TranslateMessage(&Message);
                    DispatchMessage(&Message);
                }
                else
                {
                 break;   
                }
            }
            
        }
        else
        {
            //Logging
        }

    }
    else 
    {
        //Logging
    }
    return(0);



}