/*
1. Vašou úlohou je vytvoriť scénu, ktorá bude ohraničená kockou, v ktorej sa bude odrážať guľa.
2. V rámci scény definujte kameru na kocke, ktorá sa vždy smeruje na stred kocky.
    - Dorobte pohyb kamery po kocke pomocou klávesnice.
    - Treba odlíšiť jednotlivé strany kocky, aby sme vedeli odsledovať korektnosť pohybu (napr. v rámci bodu 5).
3. Dorobte možnosť prepnúť kameru na guľu tj. guľa = avatar.
    - Pozor na ta aby ste kameru neumiestnili do vnútra gule - chceme vidieť stále scénu tj. steny kocky aj guľu.
    - Pozn.: Kamera je nasmerovaná smerom pohybu gule a je umiestnená fixnou odchýlkou za (nad)
      guľou. (čiže ako by sme naháňali guľu :) resp. kamera v NFS, keď sa prepne za auto ...)
4. Dorobte otáčanie kamery v scéne pomocou myši v prípade, že je kamera nastavená na režim sledovanie pohybu gule.
    - Súradnice myši v strede obrazovky (x,y=0) znamená, že smer pohľadu je totožná smeru guličky.
    - Súradnice myši napr. v pravom krajnom rohu (x=1) znamená, že sa otočíme doprava o 180 stupňov (pozeráme sa dozadu).
    - Atď...
5. Na stenách kocky vykreslite fraktály, ktoré si vygenerujete sami experimentovaním s funkciami.
   (To neznamená, že len zmeníte hodnoty v maticiach v programe ktorý ste dostali. Experimentujte
   s pravdepodobnosťami, počtom funkcií, zapojte do toho farbu...).*/

#include <iostream>
#include <math.h>
#include <ctime>
#include <sstream>
#include <string>
#include "glm/glm/glm.hpp"
#include "glut.h"

using namespace std;
using namespace glm;

const vec3 nullvec = vec3(0, 0, 0);
float xx, yy = 0, zz = -2;
float x, y, z = 0;
float angle = 0;
int camera_mode = 0;
GLfloat angle1 = 180, angle2 = 180;


class Ball
{
public:
    Ball(vec3 center = nullvec)
    {
        pos = center;
    }

    void draw()
    {
        glTranslatef(pos.x, pos.y, pos.z);
        glutSolidSphere(size, 20, 20);
        glTranslatef(-pos.x, -pos.y, -pos.z);

        drawDir();
    }

    void drawDir()
    {
        float offs = 10;
        //glColor3f(0, 0, 1);
        /*glBegin(GL_LINES);
        glVertex3f(pos.x - offs*vel.x, pos.y - offs*vel.y, pos.z - offs*vel.z);
        glVertex3f(pos.x, pos.y, pos.z);
        glEnd();*/

        //glColor3f(1, 0, 0);
        glBegin(GL_LINES);
        glVertex3f(pos.x, pos.y, pos.z);
        glVertex3f(pos.x + offs*vel.x, pos.y + offs*vel.y, pos.z + offs*vel.z);
        glEnd();
    }

    void setPos(vec3 pos)
    {
        this->pos = pos;
    }
    vec3 getPos(void)
    {
        return this->pos;
    }

    void setVel(vec3 vel)
    {
        this->vel = vel;
    }

    vec3 getVel(void)
    {
        return this->vel;
    }

    void setSize(float size)
    {
        this->size = size;
    }

    float getSize(void)
    {
        return this->size;
    }

    void setOuterBox(float ob)
    {
        this->outerBox = ob;
    }

    void setSpeed(float speed)
    {
        this->speed = speed;
    }

    //pohyb gulicky s nastavitelnou rychlostou a osetrenymi narazmi do stien
    //ak prekroci stred gulicky + jej polomer ohranicenie stien kocky,
    //dana suradnica v smerovom vektore sa vynasobi -1 a smer sa zrkadlovo zmeni
    void move(void)
    {
        if ((pos.x + size) >= outerBox || (pos.x - size) <= -outerBox)
        {
            vel.x = -vel.x;
        }
        pos.x += vel.x * speed;

        if ((pos.y + size) >= outerBox || (pos.y - size) <= -outerBox)
        {
            vel.y = -vel.y;
        }
        pos.y += vel.y * speed;

        if ((pos.z + size) >= outerBox || (pos.z - size) <= -outerBox)
        {
            vel.z = -vel.z;
        }
        pos.z += vel.z * speed;
    }

    vec3 pos, vel, col;
    float size;
    float outerBox;
    float speed;
};

class Scene
{
public:

    bool orto;
    bool depthtest;
    bool clear;

    Ball *b;

    Scene()
    {
        b = new Ball();

        //nahodne generovanie pociatocnych suradnic smeru pohybu gulicky
        srand(static_cast <unsigned> (time(0)));
        float rx = static_cast <float> (rand()) / static_cast <float> (RAND_MAX / 0.05);
        float ry = static_cast <float> (rand()) / static_cast <float> (RAND_MAX / 0.05);
        float rz = static_cast <float> (rand()) / static_cast <float> (RAND_MAX / 0.05);

        //nastavenie parametrov v gulicke(polomer, pociatocny smer, "rychlost", velkost kocky)
        b->setSize(0.1);
        b->setVel(vec3(rx, ry, rz));
        b->setOuterBox(1);
        b->setSpeed(0.05);
    }

    //vykreslenie kocky, gulicky a jej pohybu
    void draw(void)
    {
        angle = angle + 0.01;
        glClearColor(0.0, 0.0, 0.0, 0.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glPushMatrix();
        //glRotatef(angle, 0, 1, 0);
        center_cube(vec3(0, 0, 0), 1);
        glPopMatrix();

        b->draw();
        b->move();

        glutSwapBuffers();
    }

    //nastavenie sceny
    void setting_projection()
    {
        glMatrixMode(GL_PROJECTION); //len gluPerspective, glFrustum, glOrtho, glOrtho2
        glLoadIdentity();
        glFrustum(-1, 1, -1, 1, 1, 100);
        //4. musim prepnut
        glMatrixMode(GL_MODELVIEW); //camera
        //5. Nastavenie kamery
        glLoadIdentity();
        gluLookAt(xx, yy, zz, 0, 0, 0, 0, 1, 0); //zmena pohladu na kocku
    }

    void set_camera_ball(){

        float nasobok = 20; //glm::sqrt((b->size + 0.2)*(b->size + 0.2) / (b->vel.x*0.1 *b->vel.x*0.1 + b->vel.y*0.1 *b->vel.y*0.1 + b->vel.z*0.1 *b->vel.z*0.1));
        gluLookAt((b->vel.x + b->pos.x), (b->vel.y + b->pos.y), (b->vel.z + b->pos.z), b->pos.x, b->pos.y, b->pos.z, 0, 1, 0);
        glTranslatef(b->pos.x, b->pos.y, b->pos.z);

        //glFrustum(-1, 1, -1, 1, 1, 100);
        glRotatef(angle1, 0, 1, 0);
        glRotatef(angle2, 1, 0, 0);
    }

private:

    //vykreslenie jednej steny kocky
    void center_cube_side(vec3 center, float size)
    {
        glBegin(GL_LINE_LOOP);
        /*glVertex3f(center.x - size / 2, center.y - size / 2, center.z - size / 2);
        glVertex3f(center.x + size / 2, center.y - size / 2, center.z - size / 2);
        glVertex3f(center.x + size / 2, center.y + size / 2, center.z - size / 2);
        glVertex3f(center.x - size / 2, center.y + size / 2, center.z - size / 2);*/

        glVertex3f(size, size, size);
        glVertex3f(-size, size, size);
        glVertex3f(-size, -size, size);
        glVertex3f(size, -size, size);

        glEnd();
    }

    //zoskupenie stien, aby tvorili kocku, vzdy sa vytvori stena,
    //zrotuje o 90 stupnov okolo y osi a ide na rad dalsia
    void center_cube(vec3 center, float size)
    {
        for (int i = 0; i < 4; i++)
        {
            glRotatef(90, 0, 1, 0);
            center_cube_side(center, size);
            if (i % 2 == 0) center_cube_side(center, 0.2);
        }
    }

    vec3 cam_pos, cam_dir, cam_up;
    bool proj;
};

Scene *sc = new Scene();

void kamera()
{
    gluLookAt(xx, yy, zz, 0, 0, 0, 0, 1, 0);
}

void keyboard(unsigned char key, int x, int y)
{
    bool mode = false;
    float smer = 0.05;

    if (key == 'a'){
        if (mode == false && xx < 1.99 && zz < -0.01)
        {
            xx += 0.05;
            zz += 0.05;
        }
        else mode = true;

        if (mode == true && xx > 0.01 && zz < 1.99)
        {
            xx -= 0.05;
            zz += 0.05;
        }
        else mode = false;

        if (mode == false && xx > -1.99 && zz > 0.01)
        {
            xx -= 0.05;
            zz -= 0.05;
        }

        else mode = true;

        ///tu sam itreba vratit na xx == 0, zz == 2 a nejde to
        if (mode == true && xx < -0.01 && zz > -1.99)
        {
            xx += 0.05;
            zz -= 0.05;
        }
        else mode = false;

        //if (mode == true && )

        //else xx -= 0.05;
        //if(zz < -0.01) zz += 0.05;
        //else zz = -2;

        glLoadIdentity();
        kamera();
    }

    if (key == 'd'){
        /*if (xx > -1.99)*/ //xx -= 0.05;
        //else xx += 0.05;
        /*if (zz < -0.01)*/ //zz += 0.05;
        //else zz = -2;
        //xx -= 0.05;
        //zz += 0.05;

        if (/*mode == false &&*/ xx > -1.99 && zz < -0.01)
        {
            xx -= 0.05;
            zz += 0.05;
        }
        else mode = true;

        if (mode == true && xx > 0.01 && zz < 1.99)
        {
            xx -= 0.05;
            zz += 0.05;
        }
        else mode = false;

        if (mode == false && xx > -1.99 && zz > 0.01)
        {
            xx -= 0.05;
            zz -= 0.05;
        }

        else mode = true;

        ///tu sam itreba vratit na xx == 0, zz == 2 a nejde to
        if (mode == true && xx < -0.01 && zz > -1.99)
        {
            xx += 0.05;
            zz -= 0.05;
        }
        else mode = false;


        glLoadIdentity();
        kamera();

    }

    if (key == 'w'){
        //yy += 0.05;
        //zz += 0.05;

        if (mode == false && yy < 1.99 && zz < -0.01)
        {
            yy += 0.05;
            zz += 0.05;
        }
        else mode = true;

        if (mode == true && yy < 3.99 && zz > -1.99)
        {
            yy += 0.05;
            zz -= 0.05;
        }
        else mode = false;

        if (mode == false && yy > -1.99 && zz > 0.01)
        {
            yy -= 0.05;
            zz -= 0.05;
        }

        else mode = true;

        ///tu sa mi treba vratit na xx == 0, zz == 2 a nejde to
        if (mode == true && yy < -0.01 && zz > -1.99)
        {
            yy += 0.05;
            zz -= 0.05;
        }
        else mode = false;
        glLoadIdentity();
        kamera();
    }

    if (key == 's'){
        //yy -= 0.05;
        //zz += 0.05;

        if (mode == false && yy < 1.99 && zz < -0.01)
        {
            yy -= 0.05;
            zz += 0.05;
        }
        else mode = true;

        if (mode == true && yy > 0.01 && zz < 1.99)
        {
            yy -= 0.05;
            zz += 0.05;
        }
        else mode = false;

        if (mode == false && yy > -1.99 && zz > 0.01)
        {
            yy -= 0.05;
            zz -= 0.05;
        }

        else mode = true;

        ///tu sa mi treba vratit na xx == 0, zz == 2 a nejde to
        if (mode == true && yy < -0.01 && zz > -1.99)
        {
            yy += 0.05;
            zz -= 0.05;
        }
        else mode = false;

        glLoadIdentity();
        kamera();
    }

    if (key == '1'){
        camera_mode = 1;
    }

    if (key == '0'){
        camera_mode = 0;
    }
}

void init(void){
    sc->setting_projection();
}

void display(void){
    sc->draw();
}

void idle(void){
    sc->draw();
    if (camera_mode == 1)
    {
        glLoadIdentity();
        sc->set_camera_ball();
    }

    if (camera_mode == 0)
    {
        glLoadIdentity();
        kamera();
    }
}

void onMouseMove(int x, int y) {

    angle1 = (360 * x - 180 * glutGet(GLUT_WINDOW_WIDTH)) / glutGet(GLUT_WINDOW_WIDTH);
    angle2 = (360 * y - 180 * glutGet(GLUT_WINDOW_HEIGHT)) / glutGet(GLUT_WINDOW_HEIGHT);

    idle();

}

void main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
    glutInitWindowSize(600, 600);
    glutCreateWindow("Zadanie 1");

    glutDisplayFunc(display);
    glutKeyboardFunc(keyboard);
    glutPassiveMotionFunc(onMouseMove);
    glutIdleFunc(idle); //ulohy alebo animacie prebiehaju dalej, aj ked nie su prijate ziadne udalosti
    init();
    glutMainLoop();
}