#include "Gunngine_Win32.h"
#include <iostream>

#pragma comment(lib, "opengl32.lib")
#pragma comment(lib, "glew32s.lib")

LRESULT CALLBACK WindProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
        //case WM_SETCURSOR:
        //{
        //  SetCursor(0);
        //} break;

        case WM_DESTROY:
        {
            wglDeleteContext(hglrc);
            ReleaseDC(hWnd, hDc);
            DestroyWindow(hWnd);

            PostQuitMessage(0);
        } break;

        default:
            return DefWindowProc(hWnd, msg, wParam, lParam);
    }
}

#ifdef GUNN_DEBUG
int main()
{
    WinMain(GetModuleHandle(nullptr), GetModuleHandle(nullptr), nullptr, SW_SHOW);

    return(0);
}
#endif

int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hPrevinstance, LPSTR cmdLine, int nCmdShow)
{
    HINSTANCE instance = GetModuleHandle(nullptr);

    wc.style                                     = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc                               = WindProc;
    wc.hInstance                                 = instance;
    wc.lpszClassName                             = "GunngineWindowClass";
    wc.hCursor                                   = LoadCursor(NULL, IDC_ARROW);

    if (!RegisterClass(&wc))
    {
        printf("Error registering window class\n");
        return(-1);
    }

    hWnd = CreateWindow("GunngineWindowClass", "Gunngine", WS_OVERLAPPEDWINDOW&~WS_MAXIMIZEBOX ^ WS_THICKFRAME | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 1280, 720, NULL, NULL, hInstance, NULL);
    if (!hWnd)
    {
        printf("Error creating window\n");
        return(-1);
    }

    hDc = GetDC(hWnd);
    if (!hDc)
    {
        printf("Error creating device context");
        return(-1);
    }

    DesiredPixelFormat.nSize                     = sizeof(PIXELFORMATDESCRIPTOR);
    DesiredPixelFormat.nVersion                  = 1;
    DesiredPixelFormat.dwFlags                   = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER;
    DesiredPixelFormat.cDepthBits                = 24;
    DesiredPixelFormat.cColorBits                = 32;
    DesiredPixelFormat.cAlphaBits                = 8;
    DesiredPixelFormat.iLayerType                = PFD_MAIN_PLANE;

    SuggestedPixelFormatIndex = ChoosePixelFormat(hDc, &DesiredPixelFormat);
    DescribePixelFormat(hDc, SuggestedPixelFormatIndex, sizeof(SuggestedPixelFormat), &SuggestedPixelFormat);
    if (!SetPixelFormat(hDc, SuggestedPixelFormatIndex, &SuggestedPixelFormat))
    {
        printf("Error setting pixel format\n");
        return(-1);
    }

    int attribs[] =
    {
        WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
        WGL_CONTEXT_MINOR_VERSION_ARB, 3,
        WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
        WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
        0,
    };

    hglrc = wglCreateContext(hDc);
    if (!wglMakeCurrent(hDc, hglrc))
    {
        printf("Error creating OpenGL Context!");
        return(-1);
    }
    else
    {
        wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)wglGetProcAddress("wglCreateContextAttribsARB");
        wglSwapInterval = (PFNWGLSWAPINTERVALEXTPROC)wglGetProcAddress("wglSwapIntervalEXT");
        HGLRC sharedContext = 0;
        modernContext = wglCreateContextAttribsARB(hDc, sharedContext, attribs);
        if (!wglMakeCurrent(hDc, modernContext))
        {
            printf("Error creating OpenGL Context with Attribs!");
            return(-1);
        }
        wglDeleteContext(hglrc);
        hglrc = modernContext;
    }
    ReleaseDC(hWnd, hDc);
    wglSwapInterval(1);
    //if (glewInit() != GLEW_OK)
    //{
    //  printf("Failed to initailize GLEW\n");
    //  return(-1);
    //}

    std::cout << glGetString(GL_VERSION);

    QueryPerformanceCounter((LARGE_INTEGER*)&prevTime);
    QueryPerformanceFrequency((LARGE_INTEGER*)&countsPerSec);
    secondsPerCount = 1.0f / countsPerSec;

    while (msg.message != WM_QUIT)
    {
        if (PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else
        {
            currentTime = 0;
            QueryPerformanceCounter((LARGE_INTEGER*)&currentTime);
            deltaTime = (currentTime - prevTime) * secondsPerCount * 1000;

            HandleEvents();
            Update();
            Render(hDc);

            prevTime = currentTime;
        }
    }

    return(0);
}

void HandleEvents()
{

}

void Update()
{
#if 0
    printf("%F\n", deltaTime);

    std::stringstream ss;
    ss << "Frame Time: " << deltaTime;

    SetWindowText(hWnd, ss.str().c_str());
#endif
}

void Render(HDC hDc)
{
    glViewport(0, 0, 1280, 720);

    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);

    SwapBuffers(hDc);
}