#include <GL/freeglut.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

/// Relevante Kreis-Daten
#define PI 3.1415926535898
#define circle_points 200   // Anzahl von Liniensegmenten zur Zeichnung eines Kreises -> Genauigkeit

/// Dimensionen des zugrundegelegten Koordinatensystems
#define Dy 2.5;                  // Dimension der Y-Achse
#define Dx 2.5;                  // Dimension der X-Achse

typedef struct
{
    float rotation;
}Input_t;

typedef struct
{
    double ScaleFactorX;            // Skalierungsfaktor in X-Richtung
    double ScaleFactorY;            // Skalierungsfaktor in Y-Richtung
    double ScaleFactor;             // Hilfsvariable
    double RightShift;              // Rechtsverschiebung
    double TopShift;                // Höhenverschiebung
}State_t;

Input_t input_t;
State_t state_t;





void MyInit()
{
    glClearColor (0.0, 0.0, 0.0, 0.0);  // Hintergrundfarbe schwarz bei "gecleartem" Bildschirm
    glShadeModel (GL_FLAT);
    glEnable(GL_LINE_SMOOTH);

    /// Anti-Aliasing der Linien -> Kreis, Markierungen, etc.
    glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}


void render_circle()
{
    int i;
    int j;
    double angle_start;
    double angle_cur;
    char *text = "Hallo";
    float length;


    angle_start = (2*PI) / circle_points;  // Winkel eines Linienelements des Kreises

    /// Einheitskreis
    glPushMatrix(); // damit Rotation sich nicht aufaddiert
        glRotatef(input_t.rotation*5, 0, 0, 1);

        glBegin(GL_LINE_LOOP);
        glEnable(GL_LINE_SMOOTH);
            glVertex2d(cos(0), sin(0));     // Startpunkt => Einheitskreis mit Radius 1
            for(i=0; i<circle_points; i++)
            {
                glVertex2d(cos(angle_cur), sin(angle_cur));
                angle_cur += angle_start;
            }
        glEnd();

    /// Liniensegmente
        glPushMatrix();
            for(j=0; j<12; j++)         // 12*30 Grad = 360 Grad
            {
                glRotated(30, 0, 0, 1);
                glBegin(GL_LINES);
                    glVertex2f(0, 1.05);
                    glVertex2f(0, 0.95);
                glEnd();
            }
        glPopMatrix();

    /// Beschriftung mit Strokes
        glPushMatrix();

            glTranslatef(0.5, 0.5, 0);
//           glScaled(state_t.ScaleFactor, state_t.ScaleFactor, 1);
            glutStrokeString(GLUT_STROKE_ROMAN, (unsigned char*) text);

    /// Beschriftung mit Bitmaps
//            glRasterPos2f(0.5, 0);
//            glutBitmapString(GLUT_BITMAP_HELVETICA_10, (unsigned char*) text);
        glPopMatrix();
    glPopMatrix();






}


void MyResize(int LocalWidth, int LocalHeight)
{

    glViewport(0, 0, LocalWidth, LocalHeight);

    state_t.ScaleFactorX = LocalWidth  / Dx;
    state_t.ScaleFactorY = LocalHeight / Dy;

    state_t.RightShift = LocalWidth/2;      // Rechtsverschiebung um die halbe Breite des momentan offenen Fensters
    state_t.TopShift   = LocalHeight/2;     // Höhenverschiebung um die halbe Höhe des momentan offenen Fensters



    if(state_t.ScaleFactorX < state_t.ScaleFactorY) // Wenn Breite kleiner als Höhe, dann muss Höhe skaliert werden mit dem Faktor der Breite
    {
        state_t.ScaleFactor = state_t.ScaleFactorX;
    }

    else
    {
        state_t.ScaleFactor = state_t.ScaleFactorY; // s.o.
    }

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0,LocalWidth, 0, LocalHeight, -1, 1);


    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslated(state_t.RightShift, state_t.TopShift, 0);
    glScaled(state_t.ScaleFactor, state_t.ScaleFactor,1);
}


void MyRender()
{
    glClear(GL_COLOR_BUFFER_BIT);   // Leeren des Farbbuffer

    render_circle();                // Rendern des Kreises

    glutSwapBuffers();
}


void MyKeyboard (unsigned char C, int X, int Y)
{
    switch (C)
    {
      case 0x1b:          // Escape Taste beendet das OpenGL Fenster
           exit(1);
          break;
      default:
          printf ("Key: '%c' %i\n", C, (unsigned int)C);
          break;
    }
}


void MySpecial(int Key, int X, int Y)
{
    switch (Key)
    {
    case GLUT_KEY_RIGHT:

        input_t.rotation -= 1;
        break;

    case GLUT_KEY_LEFT:
        input_t.rotation += 1;
        break;
    default:

        break;
    }

}



int main(int argc, char **argv)
{
    int XPos;   // Fensterposition auf der X-Achse
    int YPos;   // Fensterposition auf der Y-Achse
    int XMax;   // Fenstergröße in X-Richtung
    int YMax;   // Fenstergröße in Y-Richtung


    /// Abfragen der Kommandozeilenparameter

//    sscanf(argv[1], "%d", &XPos);
//    sscanf(argv[2], "%d", &YPos);
//    sscanf(argv[3], "%d", &XMax);
//    sscanf(argv[4], "%d", &YMax);


    /// Wesentliche Glut Initialisierungen

    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
//    glutInitWindowSize(XMax, YMax);
//    glutInitWindowPosition(XPos, YPos);
    glutInitWindowSize(500, 500);
    glutInitWindowPosition(1, 1);
    glutCreateWindow("Bewegbarer Kreis, etc.");


    MyInit();
    glutDisplayFunc(MyRender);
    glutReshapeFunc(MyResize);
    glutKeyboardFunc(MyKeyboard);
    glutSpecialFunc(MySpecial);
    glutIdleFunc(MyRender);       


    glutMainLoop();




    return 0;
}