#include "application.h"

#include <AR/gsub_lite.h>
#include <AR/param.h>

#include <SDL/SDL_opengl.h>

#include <iostream>
#include <stdexcept>

Application::Application() {
	ARParam  wparam;
	
	vp = new VideoProvider();
	
	// Set the initial camera parameters.
	if(arParamLoad("camera_para.dat", 1, &wparam) < 0) {
		throw(std::runtime_error("arParamLoad() failed."));
	}

	arParamChangeSize(&wparam, vp->xsize, vp->ysize, &cparam);
	arInitCparam(&cparam);
	std::cout << "*** Camera Parameters ***" << std::endl;
	arParamDisp(&cparam);

	// Initialize SDL
	if(SDL_Init(SDL_INIT_VIDEO)) {
		throw(std::runtime_error("SDL initialization failed"));
	}
	// Fetch the video info
	const SDL_VideoInfo *info = SDL_GetVideoInfo();
	if(!info) {
		throw(std::runtime_error("SDL info query failed"));
	}
	// The SDL mode-flags
	int flags = SDL_OPENGL;       // OpenGL in SDL
	flags |= SDL_GL_DOUBLEBUFFER; // Double buffering
	flags |= SDL_HWPALETTE;       // Hardware palette
	// Check for hardware surface aviability
	if(info->hw_available) {
		flags |= SDL_HWSURFACE;
	} else {
		flags |= SDL_SWSURFACE;
	}
	// Check for hardware blit ability
	if(info->blit_hw) {
		flags |= SDL_HWACCEL;
	}
	// Setup double buffering
	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
	
	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
	
	// Get our surface
	surface = SDL_SetVideoMode(vp->xsize, vp->ysize, 32, flags);
	if(!surface) {
		throw(std::runtime_error("Video mode set failed"));
	}

	argl_ctx = arglSetupForCurrentContext();

	// Texturing
	glEnable(GL_TEXTURE_2D);
	// Blending
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_BLEND);
	// Smooth shading
	glShadeModel(GL_SMOOTH);

	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
	
	please_quit = false;
}

Application::~Application() {
	delete vp;
	arglCleanup(argl_ctx);
}

void Application::run() {
	vp->start();
	
	while(1) {
		SDL_Event event;
		SDL_PollEvent(&event);
		if(event.type == SDL_QUIT) {
			break;
		} else if(event.type == SDL_KEYDOWN) {
			event_keypress(event.key.keysym.sym);
		}
		if(please_quit) {
			return;
		}
		
		main_loop();
	}
}

void Application::main_loop(void) {
	uint8_t         *dataPtr;

	if((dataPtr = vp->get()) == NULL) {
		arUtilSleep(10);
		return;
	}

	if(count == 0) arUtilTimerReset();
	count++;

	arglDispImage(dataPtr, &cparam, 1.0, argl_ctx);

	ARMarkerInfo* marker_info;
	int marker_num;

	if(arDetectMarker(dataPtr, 50, &marker_info, &marker_num) < 0) {
		throw(std::runtime_error("arDetectMarker() failed."));
	}

	GLdouble p[16];
	arglCameraFrustum(&cparam, 0.1, 1000, p);
	glMatrixMode(GL_PROJECTION);
	glLoadMatrixd(p);

	glClearDepth( 1.0 );
	glClear(GL_DEPTH_BUFFER_BIT);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);

	patt->update(marker_info, marker_num);
	if(patt2) { patt2->update(marker_info, marker_num); }

	glDisable( GL_DEPTH_TEST );

	vp->next();
	SDL_GL_SwapBuffers();
}

void Application::quit() {
	please_quit = true;
}

void Application::event_keypress(SDLKey key) {
	switch(key) {
		case SDLK_ESCAPE:
			quit();
			break;
	}
}