#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include <cmath>
#define pi 3.14159265358979324

GLuint upN = 4;
GLfloat right = 0;
GLfloat incR = 0;
GLfloat up = 0;
GLfloat incU = 0;

GLfloat red[] = { 1, 0, 0 };
GLfloat blue[] = { 0, 0, 1 };
GLfloat green[] = { 0, 1, 0 };
GLfloat yellow[] = { 1, 1, 0 };
GLfloat white[] = { 1, 1, 1 };
GLfloat grey[] = { 0.2, 0.2, 0.2 };
GLfloat p = 0.1;
GLfloat q = 0.1;
int verts_count = 20;
int z_count = 20;


bool isFill = 1;
bool v=0;

void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) {
    if (key == GLFW_KEY_P && action == GLFW_PRESS) {
        upN = upN + 1;
    }
    if (key == GLFW_KEY_O && action == GLFW_PRESS) {
        upN = upN - 1;
    }
    if (key == GLFW_KEY_LEFT && action == GLFW_PRESS) {
        incR = incR - 0.05f;
    }
    if (key == GLFW_KEY_RIGHT && action == GLFW_PRESS) {
        incR = incR + 0.05f;
    }
    if (key == GLFW_KEY_UP && action == GLFW_PRESS) {
        incU = incU + 0.05f;
    }
    if (key == GLFW_KEY_DOWN && action == GLFW_PRESS) {
        incU = incU - 0.05f;
    }
    if (key == GLFW_KEY_Q && action == GLFW_PRESS) {
        isFill = !isFill;
    }
    if (key == GLFW_KEY_P && action == GLFW_PRESS) {
        z_count++;
        if (z_count>30) z_count=30;
        verts_count++;
        if (verts_count>30) verts_count=30;
        v=1;
    }
    if (key == GLFW_KEY_O && action == GLFW_PRESS) {
        z_count--;
        if (z_count<10) z_count=10;
        verts_count--;
        if (verts_count<10) verts_count=10;
        v=1;
    }
}

GLfloat V1[] = { 1, -1, -1 };
GLfloat V2[] = { 1, -1, 1 };
GLfloat V3[] = { 1, 1, -1 };
GLfloat V4[] = { 1, 1, 1 };
GLfloat V5[] = { -1, 1, -1 };
GLfloat V6[] = { -1, 1, 1 };
GLfloat V7[] = { -1, -1, -1 };
GLfloat V8[] = { -1, -1, 1 };

GLfloat Verts[2800];

void giperboloidVerts() {
    for (int i=0; i<=z_count; i++) {
        GLfloat z1 = z_count;
        GLfloat z = -1.1 + (i * 2.2)/z1;
        GLfloat v = atan(z);
        for (int j=0; j<verts_count; j++) {
            GLfloat u = 0 + j * 2*pi/verts_count;
            Verts[3*i*verts_count+j*3] = 1/cos(v) * cos(u);
            Verts[3*i*verts_count+j*3+1] = 1/cos(v) * sin(u);
            Verts[3*i*verts_count+j*3+2] = z;
        }
    }
}

void drawGiperboloid() {
    if (isFill) {
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    }
    else {
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    }
    for (int z=0; z<z_count; z++) {
        glColor3f(1,1,1);
        //круги сверху снизу
        if ((z==0) || (z==z_count-1)) {
            if (z==z_count-1) z=z_count;
            for (int j=0; j<verts_count-1; j++){
                glBegin(GL_TRIANGLES);
                glVertex3f(Verts[z*verts_count*3+j*3], Verts[z*verts_count*3+j*3+1], Verts[z*verts_count*3+j*3+2]);
                glVertex3f(0,0,Verts[z*verts_count*3+j*3+2]);
                glVertex3f(Verts[z*verts_count*3+(j+1)*3], Verts[z*verts_count*3+(j+1)*3+1], Verts[z*verts_count*3+(j+1)*3+2]);
                glEnd();
            }
            glBegin(GL_TRIANGLES);
            glVertex3f(Verts[z*verts_count*3+(verts_count-1)*3], Verts[z*verts_count*3+(verts_count-1)*3+1], Verts[z*verts_count*3+(verts_count-1)*3+2]);
            glVertex3f(0,0,Verts[z*verts_count*3+0*3+2]);
            glVertex3f(Verts[z*verts_count*3+0*3], Verts[z*verts_count*3+0*3+1], Verts[z*verts_count*3+0*3+2]);
            glEnd();
        }
        if (z==z_count) z--;
        for (int i=0; i<verts_count;i++) {
            glBegin(GL_TRIANGLES);

            glVertex3d (Verts[z*verts_count*3+i*3], Verts[z*verts_count*3+i*3+1], Verts[z*verts_count*3+i*3+2]);
            glVertex3d (Verts[(z+1)*verts_count*3+i*3], Verts[(z+1)*verts_count*3+i*3+1], Verts[(z+1)*verts_count*3+i*3+2]);
            if (i==verts_count-1) {
                glVertex3d (Verts[z*verts_count*3+0*3], Verts[z*verts_count*3+0*3+1], Verts[z*verts_count*3+0*3+2]);
            }
            else {
                glVertex3d (Verts[z*verts_count*3+(i+1)*3], Verts[z*verts_count*3+(i+1)*3+1], Verts[z*verts_count*3+(i+1)*3+2]);
            }
            glEnd();

            glBegin(GL_TRIANGLES);
            if (i==0) {
                glVertex3d (Verts[(z+1)*verts_count*3+(verts_count-1)*3], Verts[(z+1)*verts_count*3+(verts_count-1)*3+1], Verts[(z+1)*verts_count*3+(verts_count-1)*3+2]);
            }
            else {
                glVertex3d (Verts[(z+1)*verts_count*3+(i-1)*3], Verts[(z+1)*verts_count*3+(i-1)*3+1], Verts[(z+1)*verts_count*3+(i-1)*3+2]);
            }
            glVertex3d (Verts[z*verts_count*3+i*3], Verts[z*verts_count*3+i*3+1], Verts[z*verts_count*3+i*3+2]);
            glVertex3d (Verts[(z+1)*verts_count*3+i*3], Verts[(z+1)*verts_count*3+i*3+1], Verts[(z+1)*verts_count*3+i*3+2]);
            glEnd();
        }
    }
}

void draw4Polygon(GLfloat *v1, GLfloat *v2, GLfloat *v3, GLfloat *v4, GLfloat * col) {
    if (isFill) {
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    }
    else {
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    }
    glBegin(GL_QUADS);
    glColor3d(col[0], col[1], col[2]);
    glVertex3d(v1[0], v1[1], v1[2]);
    glVertex3d(v2[0], v2[1], v2[2]);
    glVertex3d(v3[0], v3[1], v3[2]);
    glVertex3d(v4[0], v4[1], v4[2]);
    glEnd();
}


int main(void)
{
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
    glfwWindowHint(GLFW_RESIZABLE, GL_TRUE);

    GLFWwindow* window = glfwCreateWindow(900, 900, "OpenGL", NULL, NULL);
    if (window == NULL) {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    int screenWidth, screenHeight;
    glfwGetFramebufferSize(window, &screenWidth, &screenHeight);

    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)){
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    glViewport(0.0f, 0.0f, screenWidth, screenHeight);


    glfwSetKeyCallback(window, key_callback);
    glEnable(GL_DEPTH_TEST);
    glMatrixMode(GL_PROJECTION);
    glOrtho(-5, 5, -5, 5, 0.5, 100);
    glMatrixMode(GL_MODELVIEW);
    giperboloidVerts();
    while (!glfwWindowShouldClose(window))
    {
        right += incR;
        up += incU;
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glLoadIdentity();

        glPushMatrix();
        glTranslatef(0, 0, -10);
        glRotatef(right, 0, 1, 0);
        glRotatef(up, 1, 0, 0);

        if (v==1) {
            giperboloidVerts();
            v=0;
        }
        drawGiperboloid();
        glPopMatrix();

        glPushMatrix();
        glTranslatef(-4, -4, -6);
        glScalef (0.5, 0.5, 0.5);
        glRotatef (45, 1, 0, 0);
        glRotatef (45, 0,1,0);


        draw4Polygon(V1, V2, V4, V3, green);
        draw4Polygon(V3, V4, V6, V5, blue);
        draw4Polygon(V6, V5, V7, V8, red);
        draw4Polygon(V2, V2, V7, V8, yellow);
        draw4Polygon(V2, V4, V6, V8, white);
        draw4Polygon(V1, V3, V5, V7, grey);

        glPopMatrix();
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}