/*
 * glut_gamemode.c
 *
 * Adapted from the FreeGLUT library by Hans de Ruiter.
 * The FreeGLUT license holds for this file.
 *
 * The game mode handling code.
 *
 * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
 * Written by Pawel W. Olszta, <olszta@sourceforge.net>
 * Creation date: Thu Dec 16 1999
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include "mgl/gl.h"
#include <GL/glut.h>
#include <mgl/minigl.h>
#include <interfaces/minigl.h>
#include "glut_internal.h"

extern struct MiniGLIFace *IMiniGL;

/* -- PRIVATE FUNCTIONS ---------------------------------------------------- */

/**
 * Returns true if the game mode specified in the last game mode string is valid
 */
static GLboolean isModeValid(GLsizei width, GLsizei height, GLint depth)
{
	return IMiniGL->ScreenModeIsSupported(width, height, depth);
}

/* -- INTERFACE FUNCTIONS -------------------------------------------------- */

/*
 * Sets the game mode display string
 */
void glut_GLUTGameModeString(struct GlutIFace *Self,  const char* string )
{
	GLUTcontext ctx = (GLUTcontext)GET_INSTANCE(Self);
	int width = 640, height = 480, depth = 16, refresh = 72;

	/*
	 * This one seems a bit easier than glutInitDisplayString. The bad thing
	 * about it that I was unable to find the game mode string definition, so
	 * that I assumed it is: "[width]x[height]:[depth]@[refresh rate]", which
	 * appears in all GLUT game mode programs I have seen to date.
	 */
	if (sscanf(string, "%ix%i:%i@%i", &width, &height, &depth, &refresh) != 4) {
		if (sscanf(string, "%ix%i:%i", &width, &height, &depth) != 3) {
			if (sscanf(string, "%ix%i@%i", &width, &height, &refresh) != 3) {
				if (sscanf(string, "%ix%i", &width, &height) != 2) {
					if (sscanf(string, ":%i@%i", &depth, &refresh) != 2) {
						if (sscanf(string, ":%i", &depth) != 1) {
							if (sscanf(string, "@%i", &refresh) != 1) {
								dprintf(
									"unable to parse game mode string `%s'",
									string
								);
							}
						}
					}
				}
			}
		}
	}

	/* Hopefully it worked, and if not, we still have the default values */
	ctx->gameModeSize.X  = width;
	ctx->gameModeSize.Y  = height;
	ctx->gameModeDepth   = depth;
	ctx->gameModeRefresh = refresh;

	if(depth == 32) {
		// A workaround for Warp3D not knowing what a 32-bit screenmode is
		ctx->gameModeDepth   = 24;
	}
}

/*
 * Enters the game mode
 */
int glut_GLUTEnterGameMode(struct GlutIFace *Self)
{
	GLUTcontext ctx = (GLUTcontext)GET_INSTANCE(Self);

	if(ctx->gameModeData.gameModeActive) {
		return ctx->gameModeData.windowID;
	}

	if (ctx->__glutContext) {
		ctx->__glutContext->DeleteContext();
		ctx->__glutContext = 0;
	}

	ctx->gameModeData.windowID = Self->GLUTCreateWindow("");

	dprintf("windowID %d\n", ctx->gameModeData.windowID);

	if(ctx->gameModeData.windowID == -1) {
		return -1;
	}

	if (
		ctx->__glutContext->SetDisplayMode(
			GL_FALSE, ctx->gameModeSize.X, ctx->gameModeSize.Y, ctx->gameModeDepth
		) == GL_FALSE
	) {
		Self->GLUTDestroyWindow(ctx->gameModeData.windowID);
		ctx->gameModeData.windowID = -1;
		ctx->gameModeData.gameModeActive = GL_FALSE;
		return -1;
	}
	ctx->gameModeData.gameModeActive = GL_TRUE;

	ctx->GlutW = ctx->gameModeSize.X;
	ctx->GlutH = ctx->gameModeSize.Y;

	return ctx->gameModeData.windowID;
}

/*
 * Leaves the game mode
 */
void glut_GLUTLeaveGameMode(struct GlutIFace *Self)
{
	GLUTcontext ctx = (GLUTcontext)GET_INSTANCE(Self);

	if(ctx->gameModeData.gameModeActive) {
		Self->GLUTDestroyWindow(ctx->gameModeData.windowID);
		ctx->gameModeData.gameModeActive = GL_FALSE;
	}
}

/*
 * Returns information concerning the freeglut game mode
 */
int glut_GLUTGameModeGet(struct GlutIFace *Self,  GLenum eWhat )
{
	GLUTcontext ctx = (GLUTcontext)GET_INSTANCE(Self);
	FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutGameModeGet" );

	switch (eWhat) {
		case GLUT_GAME_MODE_ACTIVE:
			return ctx->gameModeData.gameModeActive;

		case GLUT_GAME_MODE_POSSIBLE:
			return isModeValid(ctx->gameModeSize.X, ctx->gameModeSize.Y, ctx->gameModeDepth);

		case GLUT_GAME_MODE_WIDTH:
			return ctx->gameModeSize.X;

		case GLUT_GAME_MODE_HEIGHT:
			return ctx->gameModeSize.Y;

		case GLUT_GAME_MODE_PIXEL_DEPTH:
			return ctx->gameModeDepth;

		case GLUT_GAME_MODE_REFRESH_RATE:
			return ctx->gameModeRefresh;

		case GLUT_GAME_MODE_DISPLAY_CHANGED:
		 /*
			* This is true if the game mode has been activated successfully..
			*/
			return ctx->gameModeData.gameModeActive;
		default:
			break;
	}

	dprintf( "Unknown gamemode get: %d", eWhat );
	return -1;

}

/*** END OF FILE ***/