#ifndef _SCENE_HPP
#define _SCENE_HPP

#include <QOpenGLWidget>
#include <QOpenGLFunctions>
#include <QOpenGLVertexArrayObject>
#include <QOpenGLBuffer>
#include <QOpenGLShaderProgram>
#include <QOpenGLTexture>
#include <QVector4D>
#include <QMatrix4x4>
#include <QMouseEvent>
#include <QWheelEvent>

#include "camera.hpp"
#include "../element/trajectory.hpp"
#include "../element/sphere.hpp"
#include "../element/arrow.hpp"
#include "../element/wall.hpp"

/// Instance třídy představuje vykreslovanou 3D scénu.
class Scene: public QOpenGLWidget
{
    Q_OBJECT
    
    public:
        /// Konstruktor.
        /// Vytvoření instancí vykreslovaných prvků, nastavení cest k texturám,
        /// nastavení barev a inicializace dalších instančních atributů.
        /// @param QWidget *parent - reference na rodiče.
        Scene(QWidget *parent = 0);

        /// Destruktor.
        /// Uvolení alokované paměti.
        ~Scene();
        
        /// Nastavení křivky. Zjištění rozsahu souřadnic a jejich středu. Podle
        /// středu pak provedeno posunutí do počátku soustavy souřadnic. Nastavení
        /// hodnot pro dráhu, kouli a zdi. Změna kamery, pozice světla. Vynulování
        /// rotace.
        /// @param QList<QVector4D> curve - seznam bodů definující křivku.
        void setCurve(QList<QVector4D> curve);
        
        /// Nastaveni pozice koule a vektoru pro obě šipky.
        /// @param const QVector3D &position - pozice koule.
        /// @param const QVector3D &fArrow - vektor pro první (důležitějši) šipku.
        /// @param const QVector3D &sArrow - vektor pro druhou šipku.
        void setSphereData(const QVector3D &position, const QVector3D &fArrow, const QVector3D &sArrow);

        void setTestSphereData(const QVector3D &position);
        
        /// @return vektor definující danou šipku.
        /// @param bool first - jestli se má vrátit vektor první nebo druhé šipky.
        QVector3D getArrow(bool first);
        
        /// Nastavi dane šipce její vektor.
        /// @param bool first - jestli se má vektor nastavit první šipce.
        /// @param QVector3D vector - vektor šipky.
        void setArrow(bool first, QVector3D vector);

        /// Nastavení barvy křivky.
        void setTubusColor(QVector4D color);

        /// Nastavení dalšího bodu křivky.
        /// Přidá další bod do křivky.
        /// @param position QVector3D position - pozice dalšího bodu
        /// @param bool start - příznak prvního bodu křivky
        /// @param bool finish - příznak posledního bodu křivky
        void addSphereData(QVector3D position, const bool start, const bool finish);

    protected:
        // Protected funkce jsou vsechny prekryte, detailni komentare naleznete
        // v QT dokumentaci.
        
        // Minimální velikost okna 100x100.
        QSize minimumSizeHint() const override;
        
        // Defaultní velikost okna 500x500.
        QSize sizeHint() const override;
        
        // Inicializace OpenGL scény.
        void initializeGL() override;
        
        // Vykresleni (prekresleni) sceny.
        void paintGL() override;
        
        // Zmena velikost OpenGL sceny.
        void resizeGL(int width, int height) override;
        
        // Pri stisknuti tlacitka zapamatovat jeho souradnici kvuli globalni rotaci.
        void mousePressEvent(QMouseEvent *event) override;
        
        // Pri pohybu mysi provest rotaci podle osy X a Y.
        void mouseMoveEvent(QMouseEvent *event) override;
        
        // Pri pohybu koleckem mysi provest problizeni/oddaleni sceny (kamery).
        void wheelEvent(QWheelEvent *e) override;
        
    private:
        /// Index v poli ELEMENTS, kde se nachází dráha.
        static const int TRAJECTORY_I;
        
        /// Index v poli ELEMENTS, kde se nachází koule.
        static const int SPHERE_I;
        static const int SPHERE_II;

        /// Index v poli ELEMENTS, kde se nachází první šipka.
        static const int FIRST_ARROW_I;
        
        /// Jak široká má být první šipka (resp. jak moc se má změnit měřítko pro
        /// tloušťku šipky).
        static const float FIRST_ARROW_WIDTH_SCALING;
        
        /// Jak široká má být druhá šipka (resp. jak moc se má změnit měřítko pro
        /// tloušťku šipky).
        static const float SECOND_ARROW_WIDTH_SCALING;
        
        /// Světlo se defaultně umistujě na pozici kamery, tento atribut umožňuje
        /// jeho posunutí v závislosti na pozici kamery (čím blíže k počátku
        /// soustavy souřadnic, tím menší osvětlení).
        static const QVector3D MODIFY_LIGHT_POSITION;
        
        /// Atribut sloužící pro zmenšení nastavených úhlů pro rotaci kolem X a Y.
        static const int ROTATE_REDUCTION;
        
        /// Kamera pohledu představující matici pohledu.
        Camera camera;
        
        /// O kolik stupňů se ma provést rotace podle osy X a Y.
        int xAngle, yAngle;
        
        /// Poslední pozice kurzoru (když uživatel stiskne tlačítko myši).
        QPoint lastPosition;
        
        /// Kolik prvků bude vykreslováno a vytvořeni pole referencí pro tyto prvky.
        static const int ELEMENT_COUNT = 8;
        /// Kolik prvků bude vykreslováno a vytvořeni pole referencí pro tyto prvky.
        Element *elements[ELEMENT_COUNT];
        
        /// Kolik bude využíváno textur, vytvoření pole referencí pro tyto textury
        /// a vytvoření pole pro cesty k texturám.
        static const int TEXTURE_COUNT = 3;
        /// Kolik bude využíváno textur, vytvoření pole referencí pro tyto textury
        /// a vytvoření pole pro cesty k texturám.
        QOpenGLTexture *textures[TEXTURE_COUNT];
        /// Kolik bude využíváno textur, vytvoření pole referencí pro tyto textury
        /// a vytvoření pole pro cesty k texturám.
        QString texturePath[TEXTURE_COUNT];
        
        /// Pole pro vrcholy grafických prvků.
        QOpenGLVertexArrayObject vao;
        /// Pameť pro hodnoty týkajících se vrcholů grafických prvků.
        QOpenGLBuffer buffer;
        /// GLSL podprogram.
        QOpenGLShaderProgram *shaderProgram;
        
        /// Atributy pro lokaci uniform (globálních) proměnných v shader programu.
        /// Kromě klasických atributů se vytváří i pole, protože pro každý grafický
        /// prvek (az na zdi) potřebujeme znát lokaci atributu představující jeho
        /// vlastní normálovou a model-view matici.
        /**@{*/
        static const int FIRST_TYPE_WALL_I = 5; // Index prvni zdi (v seznamu prvku jsou nakonci).
        int projectionLocation; // Lokace uniform atributu matice projekce.
        int lightLocation; // Lokace uniform atributu svetla.
        int normalLocations[FIRST_TYPE_WALL_I]; // Pro pro normalove matice.
        int mvLocations[FIRST_TYPE_WALL_I]; // Pole pro model-view matice.
        /**@}*/
        
        /// Barvy využívané při vykreslování.
        /**@{*/
        QVector3D backgroundColor; // Barva pozadi cele sceny.
        QVector4D colorValues[FIRST_TYPE_WALL_I]; // Barvy pro vsechny graficke prvky.
        /**@}*/

        /// Zorný ůhel na grafickou scénu.
        float eyeAngle;
        
        /// Matice projekce.
        QMatrix4x4 projection;
        
        /// Matice pro celou scénu, kterými nastavuje rotaci, posunutí, apod.
        QMatrix4x4 worlds[FIRST_TYPE_WALL_I];
        
        /// Vektory šipek.
        QVector3D firstArrow, secondArrow;
        
        /// Vektor středu původní křivky (než se posunula do počátku soustavy souřadnic).
        QVector3D center;
        
        /// Přenastaví data v bufferu. Využíváno, když se změní data grafických
        /// prvků.
        void updateBufferData();
        
        /// Nastaví daný počet stupňů atributu XANGLE.
        /// @param int angle - o kolik má být provedena rotace podle osy X.
        void setXAngle(int angle);
        
        /// Nastaví daný počet stupňů atributu YANGLE.
        /// @param int angle - o kolik má být provedena rotace podle osy Y.
        void setYAngle(int angle);
        
    private slots:
        /// Vyčištění paměti od bufferu s hodnotami pro vrcholy a uvolnění
        /// paměti od vytvořeného GLSL podprogramu.
        void clear();
};

#endif