#include <unistd.h>
#include <cstdlib>
#include <GL/gl.h>
#include <GL/glut.h>
#include <ctime>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;


typedef float point3[3];
static GLfloat light_position[] = {10.0, 10.0, 10.0, 1.0};
static GLfloat observerPosition[] = {0.0, 0.0, 15.0};
static GLfloat thetaU = 1.0;
static GLfloat thetaV = 1.0;
static int buttonState = 0;
static int xMousePosition = 0;
static int xMousePositionDifference = 0;
static int yMousePosition = 0;
static int yMousePositionDifference = 0;
static GLfloat xAngleInPixels;
static GLfloat yAngleInPixels;

static GLfloat radiusStart = 15.0;
static GLfloat raduisCurrent = 0.0;
static GLfloat radiusDifference = 0.0;

float aspectRatio;

float randFloat(){
    return (float)(rand()%101/100.0F);
}
float xi(GLfloat u, GLfloat v){
    return (float)(radiusStart*cos(u)*cos(v));
}
float yi(int u, int v){
    return (float)(radiusStart*sin(v));
}
float zi(int u, int v){
    return (float)(radiusStart*sin(u)*cos(v));
}

void Mouse(int btn, int state, int x, int y)
{

       if (btn == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
       {
               xMousePosition = x;
               yMousePosition = y;
               buttonState = 1;
       }
       else if (btn == GLUT_RIGHT_BUTTON && state == GLUT_DOWN)
       {
               raduisCurrent = y;
               buttonState = 2;
       }
       else
               buttonState = 0;
    }


void Motion( GLsizei x, GLsizei y )
{
           xMousePositionDifference = x - xMousePosition;
           yMousePositionDifference = y - yMousePosition;
           radiusDifference = y - raduisCurrent;
           xMousePosition = x;
           yMousePosition = y;
           raduisCurrent = y;
           glutPostRedisplay();
}

class Point{ //klasa Punkty posiadająca 6 pól typu float - te od polozenia (x,y,z) i koloru (r,g,b)
public:
    float x,y,z,r,g,b;
    Point(float x,float y, float z){ //konstruktor punktu przypisujacy mu zadane koordynaty i losowe skladniki RGB
        this->x=x;
        this->y=y;
        this->z=z;
        this->r=randFloat();
        this->g=randFloat();
        this->b=randFloat();
    }
    Point(){
    }
};



float x (float u, float v){ //wyliczenie wartosci funkcji x(u,v)
    return (float)(-90*pow(u,5)+225*pow(u,4)-270*pow(u,3)+180*pow(u,2)-45*u)*cos(M_PI*v);
}
float y (float u, float v){ //wyliczenie wartoscy funkcji y(u,v)
    return (160*pow(u,4)-320*pow(u,3)+160*pow(u,2))-5;
}

float z (float u, float v){ //wyliczenie wartosci funkcji z(u,v)
    return (-90*pow(u,5)+225*pow(u,4)-270*pow(u,3)+180*pow(u,2)-45*u)*sin(M_PI*v);
}

float xu(float u, float v)
{
    return (-450*pow(u, 4) + 900*pow(u, 3) - 810*pow(u, 2) + 360*u - 45) * cos(M_PI * v);
}

float xv(float u, float v)
{
    return M_PI * (90*pow(u, 5) - 225*pow(u, 4) + 270*pow(u, 3) - 180*pow(u, 2) + 45*u) * sin(M_PI * v);
}

float yu(float u, float v)
{
    return (640*pow(u, 3) - 960*pow(u, 2) + 320*u);
}

float yv(float u, float v)
{

}

void Egg(int N){ //funkcja rysujaca jajko

    //deklaracja tablicy punktow o rozmiarze N*N
    Point tablica[N][N];

    //uzupelnienie tablice punktami
    for(int i=0;i<N;i++)
        for(int j=0;j<N;j++){
            float u = i / ((float)N - 1);
            float v =j / ((float)N - 1);
            tablica[i][j]=Point(x(u,v),y(u,v),z(u,v));
        }

    for (int i = 0; i < N-1; i++)
        for (int j = 0; j < N-1; ++j)
        {
            glBegin(GL_TRIANGLES); //podobnie jak w przypdku wyzej, rysowanie trojkatych tworzacych
            glVertex3f(tablica[i][j].x,tablica[i][j].y ,tablica[i][j].z);
            glVertex3f(tablica[(i + 1)][j].x,tablica[(i + 1)][j].y, tablica[(i + 1) ][j].z);
            glVertex3f(tablica[(i + 1)][(j + 1) ].x, tablica[(i + 1) ][(j + 1) ].y, tablica[(i + 1) ][(j + 1) ].z);
            glVertex3f(tablica[i][j].x, tablica[i][j].y , tablica[i][j].z);
            glVertex3f(tablica[i][(j + 1) ].x, tablica[i][(j + 1) ].y, tablica[i][(j + 1) ].z);
            glVertex3f(tablica[(i + 1) ][(j + 1) ].x, tablica[(i + 1) ][(j + 1) ].y , tablica[(i + 1) ][(j + 1) ].z);
            glEnd();
        }
}

void Axes(void) //funkcja rysująca układ współrzednych
{
    point3  x_min = {-5.0, 0.0, 0.0};
    point3  x_max = { 5.0, 0.0, 0.0};
    // początek i koniec obrazu osi x
    point3  y_min = {0.0, -5.0, 0.0};
    point3  y_max = {0.0,  5.0, 0.0};
    // początek i koniec obrazu osi y
    point3  z_min = {0.0, 0.0, -5.0};
    point3  z_max = {0.0, 0.0,  5.0};
    //  początek i koniec obrazu osi y
    glColor3f(1.0f, 0.0f, 0.0f);  // kolor rysowania osi - czerwony
    glBegin(GL_LINES); // rysowanie osi x
    glVertex3fv(x_min);
    glVertex3fv(x_max);
    glEnd();
    glColor3f(0.0f, 1.0f, 0.0f);  // kolor rysowania - zielony
    glBegin(GL_LINES);  // rysowanie osi y
    glVertex3fv(y_min);
    glVertex3fv(y_max);
    glEnd();
    glColor3f(0.0f, 0.0f, 1.0f);  // kolor rysowania - niebieski
    glBegin(GL_LINES); // rysowanie osi z
    glVertex3fv(z_min);
    glVertex3fv(z_max);
    glEnd();
}

void renderScene()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    if (buttonState == 1)
    {
            thetaU += xMousePositionDifference * xAngleInPixels * 0.1;
            thetaV += yMousePositionDifference * yAngleInPixels * 0.1;
    }
    if (buttonState == 2)
    {
            radiusStart += radiusDifference * yAngleInPixels;
    }
    gluLookAt(observerPosition[0], observerPosition[1], observerPosition[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    light_position[0] = radiusStart * cos(thetaU) * cos(thetaV);
    light_position[1] = radiusStart * sin(thetaV);
    light_position[2] = radiusStart * sin(thetaU) * cos(thetaV);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);
    Axes();
    Egg(50);


    glFlush();
    glutSwapBuffers();
}

void ChangeSize(GLsizei horizontal, GLsizei vertical)
{
    // Przeliczenie zmiany ilości pikseli w ruchu myszy na stopnie
           xAngleInPixels = 360.0 / (float)horizontal;
           yAngleInPixels = 360.0 / (float)vertical;

           // Przejście w tryb projekcji
           glMatrixMode(GL_PROJECTION);

           // Czyszczenie macierzy bieżącej
           glLoadIdentity();

           aspectRatio = (GLfloat)horizontal / (GLfloat)vertical;

           // Ustawienie parametrów dla rzutu perspektywicznego
           gluPerspective(70, aspectRatio, 1.0, 30.0);

           // Ustawienie okna widoku w zalezności od stostunku x i y okna
           if (horizontal <= vertical)
           {
                   glViewport(0, (vertical - horizontal) / 2, horizontal, horizontal);
           }
           else
           {
                   glViewport((horizontal - vertical) / 2, 0, vertical, vertical);
           }

           // Powrót do trybu modelu
           glMatrixMode(GL_MODELVIEW);

           // Czyszczenie macierzy bieżącej
           glLoadIdentity();
}

void initLight()
{
    /*************************************************************************************/

//  Definicja materiału z jakiego zrobiony jest czajnik
//  i definicja źródła światła

/*************************************************************************************/


/*************************************************************************************/
// Definicja materiału z jakiego zrobiony jest czajnik

    GLfloat mat_ambient[]  = {1.0, 1.0, 1.0, 1.0};
    // współczynniki ka =[kar,kag,kab] dla światła otoczenia

    GLfloat mat_diffuse[]  = {1.0, 1.0, 1.0, 1.0};
    // współczynniki kd =[kdr,kdg,kdb] światła rozproszonego

    GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0};
    // współczynniki ks =[ksr,ksg,ksb] dla światła odbitego

    GLfloat mat_shininess  = {20.0};
    // współczynnik n opisujący połysk powierzchni


/*************************************************************************************/
// Definicja źródła światła


    //  GLfloat light_position[] = {0.0, 0.0, 10.0, 1.0};
    // położenie źródła


    GLfloat light_ambient[] = {0.1, 0.1, 0.1, 1.0};
    // składowe intensywności świecenia źródła światła otoczenia
    // Ia = [Iar,Iag,Iab]

    GLfloat light_diffuse[] = {1.0, 1.0, 1.0, 1.0};
    // składowe intensywności świecenia źródła światła powodującego
    // odbicie dyfuzyjne Id = [Idr,Idg,Idb]

    GLfloat light_specular[]= {1.0, 1.0, 1.0, 1.0};
    // składowe intensywności świecenia źródła światła powodującego
    // odbicie kierunkowe Is = [Isr,Isg,Isb]

    GLfloat att_constant  = {1.0};
    // składowa stała ds dla modelu zmian oświetlenia w funkcji
    // odległości od źródła

    GLfloat att_linear    = {0.05};
    // składowa liniowa dl dla modelu zmian oświetlenia w funkcji
    // odległości od źródła

    GLfloat att_quadratic  = {0.001};
    // składowa kwadratowa dq dla modelu zmian oświetlenia w funkcji
    // odległości od źródła

/*************************************************************************************/
// Ustawienie parametrów materiału i źródła światła

/*************************************************************************************/
// Ustawienie patrametrów materiału


    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
    glMaterialf(GL_FRONT, GL_SHININESS, mat_shininess);


/*************************************************************************************/
// Ustawienie parametrów źródła

    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);

    glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, att_constant);
    glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, att_linear);
    glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, att_quadratic);


/*************************************************************************************/
// Ustawienie opcji systemu oświetlania sceny

    glShadeModel(GL_SMOOTH); // właczenie łagodnego cieniowania
    glEnable(GL_LIGHTING);   // właczenie systemu oświetlenia sceny
    glEnable(GL_LIGHT0);     // włączenie źródła o numerze 0
    glEnable(GL_DEPTH_TEST); // włączenie mechanizmu z-bufora

/*************************************************************************************/
}

void myInit()
{
    glClearColor(0.0F, 0.0F, 0.0F, 1.0F);
    initLight();
}

int main(int argc, char *argv[])
{
    srand((unsigned int)time(NULL));
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(900, 900);
    glutCreateWindow("Oswietlenie");
    glEnable(GL_DEPTH_TEST);
    glutDisplayFunc(renderScene);
    glutReshapeFunc(ChangeSize);
    glutMouseFunc(Mouse);
    glutMotionFunc(Motion);
    myInit();
    glEnable(GL_DEPTH_TEST);
    glutMainLoop();
    return 0;
}