#include <iostream>
#include <list>
#include<cmath>
#include <algorithm>
#include <ctime>

#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>

using namespace std;
int SOME_TIMER_ANG = 16;
bool TIMER_IS_ON = false;

double scale = 1.0;

void render_square(double x, double y) {
    glPushMatrix();

    double dx = 0.5;
    double dy = 0.5;
    glBegin(GL_POLYGON);
    glVertex2f(x, y);
    glVertex2f(x + dx, y);
    glVertex2f(x + dx, y - dy);
    glVertex2f(x, y - dy);
    glEnd();
    glPopMatrix();
}

void draw_line(double x, double y, double x1, double y1) {
    glBegin(GL_LINES);
    glVertex2d(x, y);
    glVertex2d(x1, y1);
    glEnd();
}
void draw_rectangle(float cx, float cy,float r){

    double da=2*M_PI/360;
    for(double angle=0;angle<=2* M_PI;angle += da){
        double x=r * cos(angle);
        double y=r * sin(angle);
        double angle2 = angle+da;
        if(angle2 > 2*M_PI){
            angle2=2* M_PI;
        }

        double x1=r * cos(angle2);
        double y1=r * sin(angle2);

        draw_line(x + cx, y + cy, x1 + cx, y1 + cy);
    }
    double dg=2*M_PI/12;
        for(double angle=0;angle<=2* M_PI;angle += dg){
            double x=r * cos(angle);
            double y=r * sin(angle);
            double x0=r*0.8 * cos(angle);
            double y0=r*0.8 * sin(angle);




            draw_line(x + cx, y + cy, x0 + cx, y0 + cy);
}
        double dr=2*M_PI/60;
            for(double angle=0;angle<=2* M_PI;angle += dr){
                double x=r * cos(angle);
                double y=r * sin(angle);
                double x0=r*0.9 * cos(angle);
                double y0=r*0.9 * sin(angle);




                draw_line(x + cx, y + cy, x0 + cx, y0 + cy);
    }

}

double sx=0;
double sy=0;
double sx1=0;
double sy1=0;
//
double DX = 0;
double DY = 0;
//

void draw_arrows(float cx, float cy, float r, float sec_angle, float min_angle) {
     float r_sec = 0.7 * r;
     float r_min = 0.5 * r;
     //
     float minute_x = r_min * cos(min_angle);
     float minute_y = r_min * sin(min_angle);
     //
     float seconds_x = r_sec * cos(sec_angle);
     float seconds_y = r_sec * sin(sec_angle);
     //
     draw_line(cx, cy, cx + minute_x, cy + minute_y);
     draw_line(cx, cy, cx + seconds_x, cy + seconds_y);
}
struct vector2d{
float x,y;
    void show(){
        cout<<x<<' '<<y<<endl;
    }
    vector2d (float x_, float y_){
    x=x_;
    y=y_;
    }
    vector2d add(vector2d b){
        return vector2d (x+b.x,y+b.y);
    void
    float dot(vector2d b){
            return x*b.x + y*b.y;
    }
    vector2d mul(float t){
            return vector2d(x*t,y*t);
    }
    void line (){
        draw_line(0,0,x,y);
    }
        }
};
void Render() {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();
        glTranslatef(0, 0, -10);
        glColor3d(1, 1, 1);
        glScalef(scale, scale, scale);

        vector2d i(3.6);
        i.line();
        vector2d j(6,-3);
        j.line()
        cur_time = time(NULL);
        dt=0;
        minute_t = 0;
        if (TIMER_IS_ON){
            dt=cur_time - start_time;
            minute_t = dt/60;
        }

        draw_arrows(1, 1, 3, M_PI/2-dangle*dt, M_PI/2-dangle*minute_t);
        glFlush();
}

void update(int t) {
    Render();
    glutTimerFunc(50, update, 0);
}

void keyb(unsigned char key, int x, int y ) {
    if(key == 'a') {
        DX = 0;
        TIMER_IS_ON = ! TIMER_IS_ON;
        std::cout << "A IS PRESSED " << TIMER_IS_ON << std::endl;
    }
    if(key == 'd') {
        DX += 0.2;
    }
    if(key == 'w') {
        DY += 0.2;
    }
    if(key == 's') {
        DY -= 0.2;
    }


    Render();
}

void reshape(int w, int h) {

    // предупредим деление на ноль
    // если окно сильно перетянуто будет
    if(h == 0)
        h = 1;
    float ratio = 1.0* w / h;

    // используем матрицу проекции
    glMatrixMode(GL_PROJECTION);

        // Reset матрицы
    glLoadIdentity();

    // определяем окно просмотра
    glViewport(0, 0, w, h);

    // установить корректную перспективу.
    gluPerspective(45,ratio,1,1000);

    // вернуться к модели
    glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char **argv)
{
    vector2d v(1,2);
    vector2d c(3,4);
    vector2d d(0,0);
    d = v.add(c);
    vector2d j(3,4);
    vector2d i(0,0);
    d=v.add(c);
    d.show();
    float dot_result = i.dot(j);
    cout <<dot_result<< endl;
    c.show();
    vector2d mul_result = c.mul(2);
    mul_result.show();

    time_t cur_time=time(NULL);
    static time_t start_t=time(NULL);
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(800, 600);
    glutCreateWindow("Physics Engine");
    glEnable(GL_DEPTH_TEST);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glClearColor(0., 0.0, 128.0, 0.0);

    glutTimerFunc(50, update, 0);
    glutReshapeFunc(reshape);
    glutDisplayFunc(Render);
    glutKeyboardFunc(keyb);
    glutMainLoop();
}