/*!\file window.c
 * \brief Utilisation du raster "maison" pour finaliser le pipeline de
 * rendu 3D. Ici on peut voir les géométries disponibles.
 * \author Farès BELHADJ, amsi@up8.edu
 * \date December 4, 2020.
 * \todo pour les étudiant(e)s : changer la variation de l'angle de
 * rotation pour qu'il soit dépendant du temps et non du framerate
 */
#include <assert.h>
/* inclusion des entêtes de fonctions de gestion de primitives simples
 * de dessin. La lettre p signifie aussi bien primitive que
 * pédagogique. */
#include <GL4D/gl4dp.h>
/* inclure notre bibliothèque "maison" de rendu */
#include "moteur.h"

/* inclusion des entêtes de fonctions de création et de gestion de
 * fenêtres système ouvrant un contexte favorable à GL4dummies. Cette
 * partie est dépendante de la bibliothèque SDL2 */
#include <GL4D/gl4duw_SDL2.h>

/* protos de fonctions locales (static) */
static void init(void);
static void draw(void);
static void key(int keycode);
static void sortie(void);
static void pmotion(int x, int y);
static void mouse(int button, int state, int x, int y);

/*!\brief un identifiant pour l'écran (de dessin) */
static uint _screenId = 0;

/*!\brief une surface représentant une sphere */
static surface_t * _sun = NULL;
static surface_t * _mercury = NULL;
static surface_t * _venus = NULL;
static surface_t * _earth = NULL;

/* des variable d'états pour activer/désactiver des options de rendu */
static int _use_tex = 1, _use_color = 0, _use_lighting = 1;

typedef struct cam_t cam_t;

struct cam_t {
	float x, y, z;
	float theta;
};

static cam_t _cam = {0, 1.0f, 50, 0};

static float _v = 0.1f;

static int _wW = 1200, _wH = 1000;
static int _xm = 400, _ym = 300;

static int _pause = 0;

/*!\brief paramètre l'application et lance la boucle infinie. */
int main(int argc, char ** argv) {
	/* tentative de création d'une fenêtre pour GL4Dummies */
	if(!gl4duwCreateWindow(argc, argv, /* args du programme */
				"Solar System", /* titre */
				10, 10, _wW, _wH, /* x, y, largeur, heuteur */
				GL4DW_SHOWN) /* état visible */) {
		/* ici si échec de la création souvent lié à un problème d'absence
		 * de contexte graphique ou d'impossibilité d'ouverture d'un
		 * contexte OpenGL (au moins 3.2) */
		return 1;
	}
	/* Pour forcer la désactivation de la synchronisation verticale */
	SDL_GL_SetSwapInterval(0);
	init();
	/* création d'un screen GL4Dummies (texture dans laquelle nous
	 * pouvons dessiner) aux dimensions de la fenêtre */
	_screenId = gl4dpInitScreen();
	/* mettre en place la fonction d'interception clavier */
	gl4duwMouseFunc(mouse);
	gl4duwKeyDownFunc(key);
	gl4duwPassiveMotionFunc(pmotion);
	/* mettre en place la fonction de display */
	gl4duwDisplayFunc(draw);
	/* boucle infinie pour éviter que le programme ne s'arrête et ferme
	 * la fenêtre immédiatement */
	gl4duwMainLoop();
	return 0;
}

/*!\brief init de nos données, spécialement les trois surfaces
 * utilisées dans ce code */
void init(void) {
	uint sun_id, mercury_id, venus_id, earth_id;
	/*vec4 g = {0, 1, 0, 1};*/
	/* on créé nos trois type de surfaces */
	_sun = mkSphere(12, 12, 1);  /*ça fait 12x12x2 trianles !*/
	/* on change les couleurs de surfaces */
	/*_sun->dcolor = g; */
	_mercury = mkSphere(12, 12, (1/227.0f) * 12.0f);
	_venus = mkSphere(12, 12, (1/113.0f) * 12.0f);
	_earth = mkSphere(12, 12, (1/108.0f) * 12.0f);

	sun_id = getTexFromBMP("images/2k-sun.bmp");
	mercury_id = getTexFromBMP("images/2k-mercury.bmp");
	venus_id = getTexFromBMP("images/2k-venus-surface.bmp");
	earth_id = getTexFromBMP("images/2k-earth-daymap.bmp");
	setTexId(_sun, sun_id);
	setTexId(_mercury, mercury_id);
	setTexId(_venus, venus_id);
	setTexId(_earth, earth_id);
	/* si _use_tex != 0, on active l'utilisation de la texture pour les
	 * trois */
	if(_use_tex) {
		enableSurfaceOption(_mercury, SO_USE_TEXTURE);
		enableSurfaceOption(_sun, SO_USE_TEXTURE);
		enableSurfaceOption(_venus, SO_USE_TEXTURE);
		enableSurfaceOption(_earth, SO_USE_TEXTURE);
	}
	/* si _use_lighting != 0, on active l'ombrage */
	if(_use_lighting) {
		enableSurfaceOption(_sun, SO_USE_LIGHTING);
		enableSurfaceOption(_mercury, SO_USE_LIGHTING);
		enableSurfaceOption(_venus, SO_USE_LIGHTING);
		enableSurfaceOption(_earth, SO_USE_LIGHTING);
	}
	disableSurfaceOption(_sun, SO_USE_COLOR);
	disableSurfaceOption(_mercury, SO_USE_COLOR);
	disableSurfaceOption(_venus, SO_USE_COLOR);
	disableSurfaceOption(_earth, SO_USE_COLOR);
	atexit(sortie);
}

/*!\brief la fonction appelée à chaque display. */
void draw(void) {
	static float a = 0.0f;
	static double t0 = 0, t, dt;
	t = gl4dGetElapsedTime();
	dt = (t - t0) / 10000.0;
	t0 = t;
	float mvMat[16], projMat[16], nmv[16];
	/* effacer l'écran et le buffer de profondeur */
	gl4dpClearScreen();
	clearDepth();
	/* des macros facilitant le travail avec des matrices et des
	 * vecteurs se trouvent dans la bibliothèque GL4Dummies, dans le
	 * fichier gl4dm.h */
	/* charger un frustum dans projMat */
	MFRUSTUM(projMat, -0.05f, 0.05f, -0.05f, 0.05f, 0.1f, 1000.0f);
	/* charger la matrice identité dans model-view */
	MIDENTITY(mvMat);
	/* on place la caméra en arrière-haut, elle regarde le centre de la scène */
	/*lookAt(mvMat, _xcam, _ycam, _zcam, _x, _y, _z, 0, 1, 0);*/
	/*lookAt(mvMat, _cam.x, 0.0, _cam.z, _cam.x - sin(_cam.theta), 1.0f - _ym / 200.0f, _cam.z - cos(_cam.theta), 0.0, 1.0, 0.0);*/
	/*_cam.x = (_xm - (_wW >> 1)) / (float)_wW;*/

	/*_cam.y = 1.0 - (_ym - (_wH >> 1)) / 300.0f;*/
	lookAt(mvMat, _cam.x, _cam.y, _cam.z, _cam.x - sin(_cam.theta), 1.0 - (_ym - (_wH >> 1)) / 300.0f, _cam.z - cos(_cam.theta), 0.0, 1.0, 0.0);

	/* la sphère est laissée au centre et tourne autour de son axe y */
	memcpy(nmv, mvMat, sizeof nmv); /* copie mvMat dans nmv */
	rotate(nmv, a, 0.0f, 1.0f, 0.0f);
	translate(nmv, 0.0f, 1.0f, 0.0f);
	transform_n_raster(_sun, nmv, projMat);

	memcpy(nmv, mvMat, sizeof nmv); /* copie mvMat dans nmv */
	rotate(nmv, a, 0.0f, 1.0f, 0.0f); // orbit mouvement
	translate(nmv, 10.0f, 1.0f, 0.0f);
	rotate(nmv, a, 0.0f, 1.0f, 0.0f); // rotation
	transform_n_raster(_mercury, nmv, projMat);

	memcpy(nmv, mvMat, sizeof nmv); /* copie mvMat dans nmv */
	rotate(nmv, a - 10, 0.0f, 1.0f, 0.0f); // orbit mouvement
	translate(nmv, 20.0f, 1.0f, 0.0f);
	rotate(nmv, a, 0.0f, -1.0f, 0.0f); // rotation anti-clockwise
	transform_n_raster(_venus, nmv, projMat);

	memcpy(nmv, mvMat, sizeof nmv); /* copie mvMat dans nmv */
	rotate(nmv, a - 20, 0.0f, 1.0f, 0.0f); // orbit mouvement
	translate(nmv, 30.0f, 1.0f, 0.0f);
	rotate(nmv, a, 0.0f, 1.0f, 0.0f); // rotation
	transform_n_raster(_earth, nmv, projMat);

	/* déclarer qu'on a changé (en bas niveau) des pixels du screen  */
	gl4dpScreenHasChanged();
	/* fonction permettant de raffraîchir l'ensemble de la fenêtre*/
	gl4dpUpdateScreen(NULL);
	if (_pause != 1)
		a += 360 * dt;
}

/*!\brief intercepte l'événement clavier pour modifier les options. */
void key(int keycode) {
	double dtheta = M_PI, step = 5.0;
	switch(keycode) {
		case GL4DK_UP:
			break;
		case GL4DK_DOWN:
			break;
		case GL4DK_RIGHT:
			break;
		case GL4DK_LEFT:
			break;
		case GL4DK_w:
			_cam.x += -_v * step * sin(_cam.theta);
			_cam.z += -_v * step * cos(_cam.theta);
			break;
		case GL4DK_s:
			_cam.x += _v * step * sin(_cam.theta);
			_cam.z += _v * step * cos(_cam.theta);
			break;
		case GL4DK_a:
			_cam.theta -= -_v * dtheta;
			break;
		case GL4DK_d:
			_cam.theta += -_v * dtheta;
			break;
		case GL4DK_p:
			if (_pause == 0)
				_pause = 1;
			else
				_pause = 0;
			break;
		case GL4DK_MINUS:
			_v -= 0.001f;
			if (_v < 0.001f){
				_v = 0.001f;
			}
			break;
		case GL4DK_EQUALS:
			_v += 0.001f;
			if (_v > 0.5f){
				_v = 0.5f;
			}
			break;
		case GL4DK_t: /* 't' la texture */
			_use_tex = !_use_tex;
			if(_use_tex) {
				enableSurfaceOption(_sun, SO_USE_TEXTURE);
				enableSurfaceOption(_mercury, SO_USE_TEXTURE);
			} else {
				disableSurfaceOption(_sun, SO_USE_TEXTURE);
				disableSurfaceOption(_mercury, SO_USE_TEXTURE);
			}
			break;
		case GL4DK_c: /* 'c' utiliser la couleur */
			_use_color = !_use_color;
			if(_use_color) {
				enableSurfaceOption(_sun, SO_USE_COLOR);
				enableSurfaceOption(_mercury, SO_USE_COLOR);
			} else {
				disableSurfaceOption(_sun, SO_USE_COLOR);
				disableSurfaceOption(_mercury, SO_USE_COLOR);
			}
			break;
		case GL4DK_l: /* 'l' utiliser l'ombrage par la méthode Gouraud */
			_use_lighting = !_use_lighting;
			if(_use_lighting) {
				enableSurfaceOption(_sun, SO_USE_LIGHTING);
				enableSurfaceOption(_mercury, SO_USE_LIGHTING);
			} else {
				disableSurfaceOption(_sun, SO_USE_LIGHTING);
				disableSurfaceOption(_mercury, SO_USE_LIGHTING);
			}
			break;
		default: break;
	}
}

static void pmotion(int x, int y) {
	_xm = x;
	_ym = y;
}

static void mouse(int button, int state, int x, int y) {
	double dtheta = M_PI;
	if (button == GL4D_BUTTON_LEFT)
		_cam.y += (_v/2) * dtheta;
	if (button == GL4D_BUTTON_RIGHT)
		_cam.y -= (_v/2) * dtheta;
	if (button == GL4D_BUTTON_MIDDLE)
		_cam.y = 1.0f;
}

/*!\brief à appeler à la sortie du programme. */
void sortie(void) {
	if(_mercury) {
		freeSurface(_mercury);
		_mercury = NULL;
	}
	if(_sun) {
		freeSurface(_sun);
		_sun = NULL;
	}
	if(_venus) {
		freeSurface(_venus);
		_venus = NULL;
	}
	if(_earth) {
		freeSurface(_earth);
		_earth = NULL;
	}
	/* libère tous les objets produits par GL4Dummies, ici
	 * principalement les screen */
	gl4duClean(GL4DU_ALL);
}