#pragma once

#include <Windows.h>

#include <iostream>

namespace Graphics
{
    template <class DERIVED_TYPE>
    class Window
    {
        public:
            static LRESULT CALLBACK WindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
            {
                DERIVED_TYPE *pThis = NULL;

                if (message == WM_NCCREATE)
                {
                    CREATESTRUCT* pCreate = (CREATESTRUCT*)lParam;
                    pThis = (DERIVED_TYPE*)pCreate->lpCreateParams;
                    SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pThis);

                    pThis->windowHandle = hwnd;
                }
                else
                {
                    pThis = (DERIVED_TYPE*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
                }

                if (pThis)
                {
                    return pThis->HandleMessage(message, wParam, lParam);
                }
                else
                {
                    return DefWindowProc(hwnd, message, wParam, lParam);
                }
            }

            Window() : windowHandle(NULL) { }

            BOOL CreateWin(PCWSTR windowName, int width = 800, int height = 600)
            {
                screenWidth = width;
                screenHeight = height;

                instance = GetModuleHandle(NULL);

                windowClass = { 0 };
                windowClass.hbrBackground = NULL;
                windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
                windowClass.hInstance = GetModuleHandle(NULL);
                windowClass.lpfnWndProc = WindowProc;
                windowClass.lpszClassName = ClassName();
                windowClass.style = CS_HREDRAW | CS_VREDRAW;

                if (!RegisterClass(&windowClass))
                {
                    MessageBox(NULL, L"Could not create Window!", L"Error", MB_OK);
                }

                windowHandle = CreateWindowEx(
                    0,
                    ClassName(),
                    windowName,
                    (
                    WS_OVERLAPPED |
                    WS_CAPTION |
                    WS_SYSMENU |
                    WS_MINIMIZEBOX |
                    WS_MAXIMIZEBOX
                    ),
                    CW_USEDEFAULT,
                    CW_USEDEFAULT,
                    screenWidth, screenHeight,
                    NULL,
                    NULL,
                    instance,
                    this
                );

                hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);

                if (FAILED(hr))
                {
                    MessageBox(NULL, L"Could not initialize COM", L"Error", MB_OK);
                }

                return (windowHandle ? TRUE : FALSE);
            }

            WNDCLASS GetClass() const { return windowClass; }
            PCWSTR GetClassN() const { return ClassName(); }
            HWND GetWindow() const { return windowHandle; }
            HINSTANCE GetInstance() const { return instance; }

            int GetScreenWidth() { return screenWidth; }
            int GetScreenHeight() { return screenHeight; }

            BOOL Show()
            {
                if (!ShowWindow(windowHandle, SW_RESTORE))
                {
                    return FALSE;
                }

                return TRUE;
            }

        private:
            virtual PCWSTR ClassName() const = 0;
            virtual LRESULT HandleMessage(UINT message, WPARAM wParam, LPARAM lParam) = 0;

            int screenWidth = 0;
            int screenHeight = 0;

            HRESULT hr;
            WNDCLASS windowClass;

            HINSTANCE instance;
            HWND windowHandle;
    };
}