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

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

using namespace std;

double scale = 1.0;
double vx=0,vy=0;
double p=3.14,r_1=1;
double kx=5,ky=5;


int msec = 5;
double angle_step = M_PI / 30 / 1000.0 * msec;

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();
}
class Vector{
public:
    float x,y;
    Vector(float a,float b):x(a),y(b){
    }
    Vector operator +(Vector other){
        return Vector(x+other.x, y+other.y);
    }
    Vector operator -(Vector other){
        return Vector(x-other.x, y-other.y);
    }
    Vector operator *(float a){
        return Vector(x*a,y*a);
    }
    Vector operator /(float a){
        return Vector(x/a,y/a);
    }
    float dot (Vector other){
        return x*other.x+y*other.y;
    }
    void print(){
        cout<<'('<<x<<','<<y<<')'<<endl;
    }
    void draw(){
        static float d = 10;
        Vector n1(-y, x);
        Vector n2(y, -x);
        Vector a(x, y);
        Vector ar_1 = (n1 - a*3) / d;
        Vector ar_2 = (n2 - a*3) / d;
        draw_line(0,0,x,y);
        draw_line(x, y, ar_1.x + x, ar_1.y + y);
        draw_line(x, y, ar_2.x + x, ar_2.y + y);
    }
};

class circle{
public:
    double x,y,r,vx,vy;
    circle(double x_, double y_, double r_, double vx_, double vy_):r(r_), x(x_), y(y_){
        vx = vx_ / 1000.0 * msec;
        vy = vy_ / 1000.0 * msec;
    }
    void print_circle(){
        int n=41;
        double cx=x + r;
        double cy=y;
        double step = p/n;
        for (float f=step; f<=p*2;f+=step){
            draw_line(cx ,cy ,cos(f)*r+x ,sin(f)*r+y);
             cx=x + cos(f)*r;
             cy=y + sin(f)*r;
        }
    }
    void update(){
        if(x+r_1>kx || x-r_1<-kx){
            vx*=-1;
        }
        if(y+r_1>ky || y-r_1<-ky){
            vy*=-1;
        }
        x+=vx;
        y+=vy;
    }
};

circle a(4, 0, r_1, 0.5, 1);
circle b1(-3,0,1,1,1);
vector<circle>particles;


void draw_clocks(float rad, float stop_angle){
    float coef = 6.0;
    for(float angle = -0.5 * M_PI; angle < stop_angle; angle += M_PI / 7){
        float x = rad * cos(-angle);
        float y = rad * sin(-angle);
        draw_line(x, y, x - x / coef,y  - y / coef);
    }
    for(float angle = -0.5 * M_PI; angle < stop_angle; angle += M_PI / 14){
        float x = rad * cos(-angle);
        float y = rad * sin(-angle);
        draw_line(x, y, x - x / coef*0.5,y  - y / coef*0.5);
    }
}
void collide(vector <circle> & particles){
    for(int i = 0; i < particles.size(); i++){
        for(int j = i + 1; j < particles.size(); j++){
            double l = (particles[i].x - particles[j].x) * (particles[i].x - particles[j].x) + (particles[i].y - particles[j].y) * (particles[i].y - particles[j].y);
            double r = (particles[i].r + particles[j].r) * (particles[i].r + particles[j].r);
            if(l <= r){
                double abx = particles[j].x - particles[i].x;
                double aby = particles[j].y - particles[i].y;
                double abd = sqrt (abx*abx + aby*aby);
                double lx = abx / abd;
                double ly = aby / abd;
                double delta = (sqrt(r) - abd) * 0.5;
                double p[2] = {ly, -lx};
                double V2l = particles[j].vx * lx + particles[j].vy*ly;
                double V2p = particles[j].vx * p[0] + particles[j].vy*p[1];
                double V1l = particles[i].vx * lx + particles[i].vy*ly;
                double V1p = particles[i].vx * p[0] + particles[i].vy*p[1];
                particles[i].vx = V2l * lx + V1p * p[0];
                particles[i].vy = V2l * ly + V1p * p[1];
                particles[j].vx = V1l * lx + V2p * p[0];
                particles[j].vy = V1l * ly + V2p * p[1];
            }

        }
    }
}

void Render() {
        static float cur_angle = -0.5 * M_PI;
        float cur_angle_1=-0.5*M_PI;
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();
        glTranslatef(0, 0, -10);
        glColor3d(1, 1, 1);
        glScalef(scale, scale, scale);
        Vector b(cos(-cur_angle),sin(-cur_angle));
        cur_angle += angle_step;
       // if (cur_angle==-M_PI*0.5){
          //  cur_angle_1+=angle_step;
          //  Vector c(cos(-cur_angle_1),sin(-cur_angle_1));
        //}
        draw_clocks(1, 2*M_PI);
        /*
        if(cur_angle%M_PI/6==0){
            draw_line();
        }
        */
        if (cur_angle > 2 * M_PI) cur_angle -= 2 * M_PI;
        draw_line(-kx,-ky,kx,-ky);
        draw_line(kx,-ky,kx,ky);
        draw_line(kx,ky,-kx,ky);
        draw_line(-kx,ky,-kx,-ky);
        for (int i=0;i<particles.size();i+=1){
            particles[i].print_circle();
            particles[i].update();
        }
        b.draw();
        collide(particles);
        glFlush();
}

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

void keyb(unsigned char key, int x, int y) {
    if(key == '+') {
        scale *= 1.1;
    }
    if(key == '-') {
        scale *= 0.9;
    }
    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)
{
    particles.push_back(a);
    particles.push_back(b1);
    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, 1.0, 0.0);

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

    }