#include <cstdlib>
#include <math.h>
#include <time.h>
#include <GL/glfw.h>
#include <queue>

#ifndef M_PI
	#define M_PI 3.141592
#endif // M_PI
#define sphere 1
#define cylinder 2

int na = 32;
int nb = 16;
std::queue < float* > pts;
std::queue < float* > lines;
std::queue < float* > triangles;

bool running()
{
    return( !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam( GLFW_OPENED) );
}

void init()
{
    int width, height;

    glfwInit();
    if( !glfwOpenWindow( 640, 480, 0, 0, 0, 0, 8, 0, GLFW_WINDOW ) ) return;

    glfwGetWindowSize( &width, &height );
    height = height > 0 ? height : 1;

    glViewport( 0, 0, width, height );
    glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );

    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective( 65.0f, (GLfloat)width/(GLfloat)height, 1.0f, 100.0f );


    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    gluLookAt(0.0f, -10.0f, 0.0f,
            0.0f, 0.0f, 0.0f,
            0.0f, 0.0f, 1.0f );
}

void finit()
{
    glfwTerminate();
}

void drawOxyz()
{
    // Рисуване на лъчите
    glBegin( GL_LINES );
        // OX
        glVertex3f( 0.0, 0.0, 0.0 );
        glVertex3f( 5.0, 0.0, 0.0 );
        // OY
        glVertex3f( 0.0, 5.0, 0.0 );
        glVertex3f( 0.0, 0.0, 0.0 );
        // OZ
        glVertex3f( 0.0, 0.0, 5.0 );
        glVertex3f( 0.0, 0.0, 0.0 );
    glEnd();

    // Рисуване на стрелките
    glBegin( GL_TRIANGLES );
        // OX
        glVertex3f( 5.0, 0.0, 0.0 );
        glVertex3f( 4.5, 0.2, 0.0 );
        glVertex3f( 4.5,-0.2, 0.0 );
        // OY
        glVertex3f( 0.0, 5.0, 0.0 );
        glVertex3f( 0.2, 4.5, 0.0 );
        glVertex3f(-0.2, 4.5, 0.0 );
        // OZ
        glVertex3f( 0.0,  0.0,  5.0 );
        glVertex3f(+0.14,-0.14, 4.5 );
        glVertex3f(-0.14,+0.14, 4.5 );
    glEnd();
}

struct OKG_POINT
{
    float x;
    float y;
    float z;
} ;

OKG_POINT point( float x, float y, float z)
{
    OKG_POINT p;
    p.x = x;
    p.y = y;
    p.z = z;
    return( p );
}

void drawSolidCylinder ( float x, float y, float z, float r, float h )
{
    float alpha = 0.0;
    float dalpha = 2*M_PI/na;

    for( int i=0; i<na; i++)
    {
        float dx1 = r*cos(alpha);
        float dy1 = r*sin(alpha);

        float dx2 = r*cos(alpha+dalpha);
        float dy2 = r*sin(alpha+dalpha);

        // Рисуване на околна стена
        glBegin( GL_POLYGON );
            glNormal3f( cos(alpha+dalpha/2), sin(alpha+dalpha/2), 0 );
            glVertex3f( x+dx1, y+dy1, z );
            glVertex3f( x+dx2, y+dy2, z );
            glVertex3f( x+dx2, y+dy2, z+h );
            glVertex3f( x+dx1, y+dy1, z+h );
        glEnd();

        // Рисуване на парче от долната основа
        glBegin( GL_POLYGON );
            glNormal3f( 0, 0, -1 );
            glVertex3f( x,     y,     z );
            glVertex3f( x+dx1, y+dy1, z );
            glVertex3f( x+dx2, y+dy2, z );
        glEnd();

        // Рисуване на парче от горната основа
        glBegin( GL_POLYGON );
            glNormal3f( 0, 0, 1 );
            glVertex3f( x,     y,     z+h );
            glVertex3f( x+dx1, y+dy1, z+h );
            glVertex3f( x+dx2, y+dy2, z+h );
        glEnd();

        alpha += dalpha;
    }
}


OKG_POINT spherical( float alpha, float beta, float r )
{
    OKG_POINT p;
    p.x = r*cos(alpha)*cos(beta);
    p.y = r*sin(alpha)*cos(beta);
    p.z = r*sin(beta);
    return p;
}

void drawSmoothSphere( float x, float y, float z, float r )
{
    float alpha;
    float dalpha = 2.0*M_PI/na;
    float beta;
    float dbeta = 1.0*M_PI/nb;

    beta = M_PI/2;
    for( int j=0; j<nb; j++, beta-=dbeta)
    {
        alpha = 0;
        for( int i=0; i<na; i++, alpha+=dalpha)
        {
            OKG_POINT p;
            glBegin( GL_POLYGON );

            p = spherical(alpha,beta,1);
            glNormal3f(p.x,p.y,p.z);
            glVertex3f(x+r*p.x,y+r*p.y,z+r*p.z);

            p = spherical(alpha+dalpha,beta,1);
            glNormal3f(p.x,p.y,p.z);
            glVertex3f(x+r*p.x,y+r*p.y,z+r*p.z);

            p = spherical(alpha+dalpha,beta-dbeta,1);
            glNormal3f(p.x,p.y,p.z);
            glVertex3f(x+r*p.x,y+r*p.y,z+r*p.z);

            p = spherical(alpha,beta-dbeta,1);
            glNormal3f(p.x,p.y,p.z);
            glVertex3f(x+r*p.x,y+r*p.y,z+r*p.z);

            glEnd( );
        }
    }
}

void drawUnitCylinder ( )
{
    float dalpha = 2*M_PI/na;
    float dx = cos(dalpha);
    float dy = sin(dalpha);

    float x1 = 1;
    float y1 = 0;

    for( int i=0; i<na; i++)
    {

        float x2 = x1*dx-y1*dy;
        float y2 = y1*dx+x1*dy;

        // Рисуване на околна стена
        glBegin( GL_POLYGON );
            glNormal3f( x1, y1, 0 );
            glVertex3f( x1, y1, 0 );
            glVertex3f( x1, y1, 1 );
            glNormal3f( x2, y2, 0 );
            glVertex3f( x2, y2, 1 );
            glVertex3f( x2, y2, 0 );
        glEnd();

        // Рисуване на парче от долната основа
        glBegin( GL_POLYGON );
            glNormal3f(  0,  0, -1 );
            glVertex3f(  0,  0,  0 );
            glVertex3f( x1, y1,  0 );
            glVertex3f( x2, y2,  0 );
        glEnd();

        // Рисуване на парче от горната основа
        glBegin( GL_POLYGON );
            glNormal3f(  0,  0, 1 );
            glVertex3f(  0,  0, 1 );
            glVertex3f( x1, y1, 1 );
            glVertex3f( x2, y2, 1 );
        glEnd();

        x1 = x2;
        y1 = y2;
    }
}


void prepareUnits(){
    glNewList(sphere, GL_COMPILE);
        drawSmoothSphere(0,0,0,0.5);
    glEndList();
    glNewList(cylinder, GL_COMPILE);
        drawUnitCylinder();
    glEndList();
}

void drawPoint(float x, float y, float z){
    float *qr = new float[3];
    qr[0] = x;
    qr[1] = y;
    qr[2] = z;
    pts.push(qr);
}

void drawLine(float x1, float y1, float z1, float x2, float y2, float z2){
    float *qr = new float[6];
    qr[0] = x1;
    qr[1] = y1;
    qr[2] = z1;
    qr[3] = x2;
    qr[4] = y2;
    qr[5] = z2;
    lines.push(qr);
}

void drawTriangle(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3){
    float *qr = new float[9];
    qr[0] = x1;
    qr[1] = y1;
    qr[2] = z1;
    qr[3] = x2;
    qr[4] = y2;
    qr[5] = z2;
    qr[6] = x3;
    qr[7] = y3;
    qr[8] = z3;
    triangles.push(qr);
}

void __drawPoint(float x, float y, float z){
    glPushMatrix();
        glTranslatef(x,y,z);
        glCallList(sphere);
    glPopMatrix();
}

void __drawLine(float x1, float y1, float z1, float x2, float y2, float z2){
    float length = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) + (z2-z1)*(z2-z1));
    float xyLen = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
    float xyCos = xyLen/length;

    float xxyCos = abs(x2-x1)/xyLen;

    glColor3ub(255,255,0);
    glPushMatrix();
        glTranslatef(x1,y1,z1);
        glRotatef( acos(xxyCos) * 180 / M_PI,0,0,1);
        glRotatef( 90 - acos(xyCos) * 180 / M_PI,0,1,0);
        glScalef(0.2,0.2,length);
        glCallList(cylinder);
    glPopMatrix();
}

void __drawTriangle(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3){
    glBegin(GL_POLYGON);
        glVertex3f(x1,y1,z1);
        glVertex3f(x2,y2,z2);
        glVertex3f(x3,y3,z3);
    glEnd();
}

void __drawAllPoints(){
    std::queue < float* > temp = pts;
    float tmp[3];
    float* t = tmp;
    glColor3ub(0,0,255);
    while(!temp.empty()){
        t = temp.front();
        __drawPoint(t[0],t[1],t[2]);
        temp.pop();
    }
}

void __drawAllLines(){
    std::queue < float* > temp = lines;
    float tmp[6];
    float* t = tmp;
    glColor3ub(255,255,0);
    while(!temp.empty()){
        t = temp.front();
        __drawLine(t[0],t[1],t[2],t[3],t[4],t[5]);
        temp.pop();
    }
}

void __drawAllTriangles(){
    std::queue < float* > temp = triangles;
    float tmp[9];
    float* t = tmp;
    glColor4f(1.0f,0.6f,0.6f,0.8f);
    while(!temp.empty()){
        t = temp.front();
        __drawTriangle(t[0],t[1],t[2],t[3],t[4],t[5],t[6],t[7],t[8]);
        temp.pop();
    }
    glColor4f(1.0f,0.0f,0.0f,1.0f);
}

void run(){

    init();

    glClearColor( 1.0f, 1.0f, 1.0f, 1.0f );
    glEnable( GL_DEPTH_TEST );

    glEnable( GL_LIGHTING );
    glEnable( GL_LIGHT0 );
    glEnable( GL_COLOR_MATERIAL );
    glEnable(GL_BLEND); //Enable blending.
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //Set blending function.

    glEnable(GL_SMOOTH);
	glShadeModel(GL_SMOOTH);


    float t = 0;

    prepareUnits();

    while( running() )
    {
        glClear( GL_COLOR_BUFFER_BIT+GL_DEPTH_BUFFER_BIT );
        t=t+0.001;
        glLoadIdentity();
        gluLookAt(10*cos(t),10*sin(t),15, 0,0,0, 0,0,1 );

        glColor3ub(0,0,0);
        drawOxyz();

        glEnable( GL_LIGHTING );

        __drawAllPoints();
        __drawAllLines();
        __drawAllTriangles();

        glColor4f(0.85f,0.85f,1.0f,0.8f);
        glPushMatrix();
        glScalef(100,100,0);
        glBegin(GL_POLYGON);
            glVertex3f(-1,-1,0);
            glVertex3f(1,-1,0);
            glVertex3f(1,1,0);
            glVertex3f(-1,1,0);
        glEnd();
        glPopMatrix();


        glDisable( GL_LIGHTING );

        glfwSwapBuffers();
    }

    finit();

}