/*]  Copyright (c) 2009-2010, Charles McGarvey  [**************************
**]  All rights reserved.
*
* vi:ts=4 sw=4 tw=75
*
* Distributable under the terms and conditions of the 2-clause BSD license;
* see the file COPYING for a complete text of the license.
*
**************************************************************************/

#include <cstdlib>		// atexit, getenv
#include <iostream>
#include <string>
#include <unistd.h>		// access

#include <Moof/Log.hh>
#include <Moof/ModalDialog.hh>
#include <Moof/OpenGL.hh>
#include <Moof/Resource.hh>
#include <Moof/Settings.hh>
#include <Moof/Transition.hh>
#include <Moof/Video.hh>

#include "ErrorHandler.hh"
#include "GameLayer.hh"
#include "Main.hh"
#include "TitleLayer.hh"

#if HAVE_CONFIG_H
#include "config.h"
#endif
#include "version.h"


Main::Main()
{
	mDispatchHandler = Mf::core.addHandler("video.newcontext",
			boost::bind(&Main::contextCreated));
	setupGL();
}

void Main::addedToCore()
{
	//Mf::Scalar coeff[] = {0.0, 1.0};
	//Mf::Lerp interp(coeff, 0.25);

	//Mf::LayerP gameLayer = GameLayer::alloc();
	//Mf::Transition<Mf::Lerp>::Ptr transition =
		//Mf::Transition<Mf::Lerp>::alloc(gameLayer, Mf::LayerP(), interp);
	//core.push(transition);
	//core.push(GameLayer::alloc());
	Mf::core.push(TitleLayer::alloc());
}


void Main::update(Mf::Scalar t, Mf::Scalar dt)
{
	if (Mf::core.getSize() == 1)
	{
		// this is the only layer left on the stack
		//Mf::core.push(TitleLayer::alloc());
		Mf::core.clear();
	}
}

void Main::draw(Mf::Scalar alpha) const
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

bool Main::handleEvent(const Mf::Event& event)
{
	switch (event.type)
	{
		case SDL_KEYUP:
			if (event.key.keysym.sym == SDLK_ESCAPE)
			{
				Mf::core.clear();
			}
			else if (event.key.keysym.sym == SDLK_f)
			{
				Mf::video->toggleFull();
			}
			else if (event.key.keysym.sym == SDLK_l)
			{
				Mf::video->toggleCursorGrab();
				Mf::video->toggleCursorVisible();
			}
			break;

		case SDL_VIDEORESIZE:
			glViewport(0, 0, event.resize.w, event.resize.h);
			break;

		case SDL_QUIT:
			Mf::core.clear();
			break;
	}

	return false;
}


std::string Main::getSearchPath()
{
	// Add search paths; they should be searched in this order:
	// 1. YOINK_DATADIR (environment)
	// 2. YOINK_DATADIR (configure)
	
	std::string path;

	char* dataDir = getenv("YOINK_DATADIR");
	if (dataDir)
	{
		path += dataDir;
		path += ":";
	}
	path += YOINK_DATADIR;

	return path;
}

std::string Main::getConfigPath()
{
	// Build the list of config files to search for, in this order:
	// 1. YOINK_DATADIR/yoinkrc
	// 2. /etc/yoinkrc (not for Windows)
	// 3. $HOME/.yoinkrc
	// 4. YOINKRC (environment)

	std::string path = Mf::Resource::getPath("yoinkrc");

#if !defined(_WIN32) && !defined(__WIN32__)
	path += ":/etc/yoinkrc";
#endif
	path += ":$HOME/.yoinkrc";

	char* configFile = getenv("YOINKRC");
	if (configFile)
	{
		path += ":";
		path += configFile;
	}

	return path;
}


void Main::setupGL()
{
	glEnable(GL_TEXTURE_2D);
	glEnable(GL_DEPTH_TEST);

	glEnable(GL_LINE_SMOOTH);
	glEnable(GL_POLYGON_SMOOTH);
	glShadeModel(GL_SMOOTH);

	//glEnable(GL_BLEND);
	//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_ALPHA_TEST);
	glAlphaFunc(GL_GREATER, 0.0);

	glClearColor(0.0, 0.0, 0.0, 1.0);

	//glMatrixMode(GL_PROJECTION);
	//glLoadIdentity();
	//Mf::Scalar ratio = Mf::core.getVideo()->getWidth() /
		//Mf::core.getVideo()->getHeight();
	//gluPerspective(60.0, ratio, 1.0, 250.0);

	//glMatrixMode(GL_MODELVIEW);
}

void Main::contextCreated()
{
	// whenever the context is destroyed and a new one created, it probably
	// won't contain our state so we need to set that up again
	setupGL();
}



void Main::printUsage()
{
	std::cout << "Usage: "
			  << PACKAGE" [-h|--help] [-i|--info] [OPTION=VALUE]..."
			  << std::endl
			  << "The alien-smashing action game." << std::endl
			  << std::endl
			  << "Options:" << std::endl
			  << "  -h, --help" << std::endl
			  << "      show this help and exit" << std::endl
			  << "  -i, --info" << std::endl
			  << "      show version and build information" << std::endl
			  << "  detail=1|2|3" << std::endl
			  << "      the level of detail of game scenes" << std::endl
			  << "  fullscreen=true|false" << std::endl
			  << "      if true, uses the entire display" << std::endl
			  << "  framerate=num" << std::endl
			  << "      number of frames to draw per second" << std::endl
			  << std::endl
			  << "See documentation for more options." << std::endl;
}

void Main::printInfo(int argc, char* argv[])
{
	std::string assets;
	std::string datadir;
	std::string config;

	assets.assign(YOINK_DATADIR);
	int accessible = access(assets.c_str(), R_OK);
	if (accessible != 0) assets += " (no access)";

	char* temp = getenv("YOINK_DATADIR");
	if (temp)
	{
		datadir = temp;
		accessible = access(temp, R_OK);
		if (accessible != 0) datadir += " (no access)";
	}

	temp = getenv("YOINKRC");
	if (temp)
	{
		config = temp;
		accessible = access(temp, R_OK);
		if (accessible != 0) config += " (no access)";
	}

	std::cout << "   Executable: " << argv[0] << std::endl
			  << "      Version: "VERSION << std::endl
			  << "        Built: " << COMPILE_TIME << std::endl
			  << "     Compiler: "COMPILER_STRING << std::endl
			  << "       Assets: " << assets << std::endl
			  << "Build options: "
#ifdef NDEBUG
			  << "-"
#endif
			  << "debug "
#ifndef USE_DOUBLE_PRECISION
			  << "-"
#endif
			  << "double-precision "
#ifndef USE_GTK
			  << "-"
#endif
			  << "gtk "
#ifndef PROFILING_ENABLED
			  << "-"
#endif
			  << "profile "
#ifndef USE_QT4
			  << "-"
#endif
			  << "qt4 "
#ifndef USE_THREADS
			  << "-"
#endif
			  << "threads" << std::endl
			  << "      YOINKRC: " << config << std::endl
			  << "YOINK_DATADIR: " << datadir << std::endl;
}


void hello()
{
	std::cout << std::endl << PACKAGE_STRING << std::endl
			  << "Compiled " << __TIME__ " " __DATE__ << std::endl
			  << "Send patches and bug reports to <"
			  PACKAGE_BUGREPORT << ">." << std::endl << std::endl;
}

void goodbye()
{
	std::cout << std::endl << "Goodbye..." << std::endl << std::endl;
}

int main(int argc, char* argv[])
{
	if (argc > 1)
	{
		std::string arg(argv[1]);
		if (arg == "-h" || arg == "--help")
		{
			Main::printUsage();
			return 0;
		}
		else if (arg == "-i" || arg == "--info")
		{
			Main::printInfo(argc, argv);
			return 0;
		}
	}

	hello();
	atexit(goodbye);

	Mf::Resource::addSearchPaths(Main::getSearchPath());

	Mf::settings.loadFromFiles(Main::getConfigPath());
	Mf::settings.parseArgs(argc, argv);

	Mf::Log::Level logLevel = Mf::Log::INFO;
	Mf::settings.get("loglevel", logLevel);
	Mf::Log::setLevel(logLevel);

	try
	{
		Mf::Video video(PACKAGE_STRING,
						Mf::Resource::getPath(PACKAGE".png"));
		MainP app = Main::alloc();
		Mf::core.push(app);
		Mf::core.run();
	}
	catch (const Mf::Error& error)
	{
		Mf::ModalDialog dialog;
		dialog.title = PACKAGE_STRING;
		dialog.text1 = "Unhandled Exception";
		dialog.text2 = getErrorString(error);
		dialog.type = Mf::ModalDialog::CRITICAL;
		dialog.run();

		return 1;
	}

	return 0;
}