#include <windows.h>
#include <stdlib.h>
#include <math.h>
#include <GL/gl.h>
#include <GL/glu.h>

// position of observer
struct observer {
    double x = 5.0;
    double y = 5.0;
    double z = 5.0;
} obv;

// size of cuboid
const struct cuboid {
    const double x = 3.0;
    const double y = 1.0;
    const double z = 4.0;
} qb;

double length = 2.0;

bool task1 = false;
bool task2 = false;
bool task3 = false;

void DrawScene(GLfloat xRot, GLfloat yRot)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();

    glRotatef(xRot, 1.0f, 0.0f, 0.0f);
    glRotatef(yRot, 0.0f, 1.0f, 0.0f);

    glBegin(GL_POINTS);
    glPointSize(20);
    glVertex3f(obv.x, obv.y, obv.z);
    glColor3f(1, 0, 0);
    glRotatef(5, 1.0f, 0.0f, 0.0f);
    glRotatef(5, 0.0f, 1.0f, 0.0f);
    glRotatef(5, 0.0f, 0.0f, 1.0f);
    glEnd();

    // lines from centres of walls to observer
    glBegin(GL_LINES);
    glColor3f(0, 1, 0);

    glVertex3f(0, 0, qb.z);
    glVertex3f(obv.x, obv.y, obv.z);
    glVertex3f(0, 0, -qb.z);
    glVertex3f(obv.x, obv.y, obv.z);

    glVertex3f(0, qb.y, 0);
    glVertex3f(obv.x, obv.y, obv.z);
    glVertex3f(0, -qb.y, 0);
    glVertex3f(obv.x, obv.y, obv.z);

    glVertex3f(qb.x, 0, 0);
    glVertex3f(obv.x, obv.y, obv.z);
    glVertex3f(-qb.x, 0, 0);
    glVertex3f(obv.x, obv.y, obv.z);

    // centres of walls (normals)
    glColor3f(1, 0, 0); // red

    glVertex3f(qb.x, 0, 0);
    glVertex3f(qb.x + length, 0, 0);

    glVertex3f(0, qb.y, 0);
    glVertex3f(0, qb.y + length, 0);

    glVertex3f(0, 0, qb.z);
    glVertex3f(0, 0, qb.z + length);

    glVertex3f(-qb.x, 0, 0);
    glVertex3f(-qb.x - length, 0, 0);

    glVertex3f(0, -qb.y, 0);
    glVertex3f(0, -qb.y - length, 0);

    glVertex3f(0, 0, -qb.z);
    glVertex3f(0, 0, -qb.z - length);

    glEnd();

    glBegin(GL_QUADS);
    if (obv.z > qb.z)
    {
        // wall 1
        glColor3f(0, 0, 1); // blue
        glVertex3f(-qb.x, -qb.y, qb.z);
        glVertex3f(-qb.x, qb.y, qb.z);
        glVertex3f(qb.x, qb.y, qb.z);
        glVertex3f(qb.x, -qb.y, qb.z);
    }
    if (obv.z < -qb.z)
    {
        // wall 2
        glColor3f(0, 1, 0); // green
        glVertex3f(-qb.x, -qb.y, -qb.z);
        glVertex3f(-qb.x, qb.y, -qb.z);
        glVertex3f(qb.x, qb.y, -qb.z);
        glVertex3f(qb.x, -qb.y, -qb.z);
    }
    if (obv.y > qb.y)
    {
        // wall 3
        glColor3f(0, 1, 1); // cyan
        glVertex3f(-qb.x, qb.y, -qb.z);
        glVertex3f(-qb.x, qb.y, qb.z);
        glVertex3f(qb.x, qb.y, qb.z);
        glVertex3f(qb.x, qb.y, -qb.z);
    }
    if (obv.y < -qb.y)
    {
        // wall 4
        glColor3f(1, 0, 0); // red
        glVertex3f(-qb.x, -qb.y, -qb.z);
        glVertex3f(-qb.x, -qb.y, qb.z);
        glVertex3f(qb.x, -qb.y, qb.z);
        glVertex3f(qb.x, -qb.y, -qb.z);
    }
    if (obv.x > qb.x)
    {
        // wall 6
        glColor3f(1, 1, 0); // yellow
        glVertex3f(qb.x, -qb.y, -qb.z);
        glVertex3f(qb.x, -qb.y, qb.z);
        glVertex3f(qb.x, qb.y, qb.z);
        glVertex3f(qb.x, qb.y, -qb.z);
    }
    if (obv.x < -qb.x)
    {
        // wall 5
        glColor3f(1, 0, 1); // magenta
        glVertex3f(-qb.x, -qb.y, -qb.z);
        glVertex3f(-qb.x, -qb.y, qb.z);
        glVertex3f(-qb.x, qb.y, qb.z);
        glVertex3f(-qb.x, qb.y, -qb.z);
    }
    glEnd();

    glFinish();
}

void SetMyPixelFormat(HDC hdc)
{
    PIXELFORMATDESCRIPTOR pfd;
    ZeroMemory(&pfd, sizeof(pfd));
    pfd.nSize = sizeof(pfd);
    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 32;
    pfd.cDepthBits = 16;
    pfd.iLayerType = PFD_MAIN_PLANE;

    int nPixelFormat = ChoosePixelFormat(hdc, &pfd);
    SetPixelFormat(hdc, nPixelFormat, &pfd);
}

void ResizeWindow(int width, int height)
{
    if (height * width == 0) return;
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-10, 10, -10, 10, -10, 10);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glEnable(GL_DEPTH_TEST);

    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);// set the blend mode
    glEnable(GL_BLEND); //obligatory for blending and transparencies
    glEnable(GL_LINE_SMOOTH);

    //glEnable(GL_CULL_FACE);

    glShadeModel(GL_FLAT);
    glShadeModel(GL_SMOOTH);
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    PAINTSTRUCT ps;
    HDC hdc;
    static HGLRC hrc;
    static GLfloat xRot = 0.0f;
    static GLfloat yRot = 0.0f;

    switch (message)
    {
    case WM_SIZE:
        ResizeWindow(LOWORD(lParam), HIWORD(lParam));
        break;
    case WM_CREATE:
        hdc = GetDC(hWnd);
        SetMyPixelFormat(hdc);
        hrc = wglCreateContext(hdc);
        wglMakeCurrent(hdc, hrc);
        ReleaseDC(hWnd, hdc);
        break;
    case WM_KEYDOWN:
        // moving whole scene
        if (wParam == VK_UP) xRot -= 5.0f;
        if (wParam == VK_DOWN) xRot += 5.0f;
        if (wParam == VK_LEFT) yRot -= 5.0f;
        if (wParam == VK_RIGHT) yRot += 5.0f;

        // moving observer
        if (wParam == 'A') obv.x -= 0.5;
        if (wParam == 'D') obv.x += 0.5;
        if (wParam == 'W') obv.y += 0.5;
        if (wParam == 'S') obv.y -= 0.5;
        if (wParam == 'E') obv.z -= 0.5;
        if (wParam == 'Q') obv.z += 0.5;

        // setting observer to see single wall
        if (wParam == '1') { obv.x = 0; obv.y = 0; obv.z = qb.z + length; }
        if (wParam == '2') { obv.x = 0; obv.y = 0; obv.z = -qb.z - length; }
        if (wParam == '3') { obv.x = 0; obv.y = qb.y + length; obv.z = 0; }
        if (wParam == '4') { obv.x = 0; obv.y = -qb.y - length; obv.z = 0; }
        if (wParam == '5') { obv.x = qb.x + length; obv.y = 0; obv.z = 0; }
        if (wParam == '6') { obv.x = -qb.x - length; obv.y = 0; obv.z = 0; }

        // resetting observer to starting point
        if (wParam == 'X') { obv.x = 5; obv.y = 5; obv.z = 5; }

        // additional steering


        if (xRot > 356.0f) xRot = 0.0f;
        if (xRot < -1.0f) xRot = 355.0f;
        if (yRot > 356.0f) yRot = 0.0f;
        if (yRot < -1.0f) yRot = 355.0f;

        InvalidateRect(hWnd, NULL, FALSE);
        break;
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);
        DrawScene(xRot, yRot);
        SwapBuffers(hdc);
        EndPaint(hWnd, &ps);
        break;
    case WM_ERASEBKGND:
        return 1;
        break;
    case WM_DESTROY:
        wglMakeCurrent(NULL, NULL);
        wglDeleteContext(hrc);
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
    wcex.lpfnWndProc = (WNDPROC)WndProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hIcon = NULL;
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszMenuName = NULL;
    wcex.lpszClassName = "Primitives";
    wcex.hIconSm = NULL;
    return RegisterClassEx(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    HWND hWnd;
    hWnd = CreateWindow("Primitives", "OGL color lab", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
    if (!hWnd) return FALSE;
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);
    return TRUE;
}

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
    MSG msg;
    MyRegisterClass(hInstance);
    if (!InitInstance(hInstance, nCmdShow)) return FALSE;
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return (int)msg.wParam;
}