/*]  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 "../config.h"

#include <cstdlib>		// atexit
#include <exception>
#include <functional>
#include <iostream>
#include <string>

#include <stlplus/portability/file_system.hpp>
#include <stlplus/portability/subprocesses.hpp>

#include <moof/log.hh>
#include <moof/modal_dialog.hh>
#include <moof/opengl.hh>
#include <moof/resource.hh>
#include <moof/settings.hh>
#include <moof/video.hh>

#include "GameLayer.hh"
#include "Main.hh"
#include "TitleLayer.hh"
#include "version.h"


Main::Main(moof::settings& settings, moof::video& video) :
	moof::view(settings, video)
{
	moof::dispatcher& dispatcher = moof::dispatcher::global();
	mNewContextDispatch = dispatcher.add_target("video.newcontext",
											 boost::bind(&Main::setupGL));
	setupGL();
}


void Main::update(moof::scalar t, moof::scalar dt)
{
	if (children().size() == 0)
	{
		//moof::log_warning("main view has no children");
		//stop();
		//return;
		add_child(TitleLayer::alloc());
	}

	moof::view::update(t, dt);
}

void Main::draw(moof::scalar alpha) const
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	moof::view::draw(alpha);
}

bool Main::handle_event(const moof::event& event)
{
	if (moof::view::handle_event(event)) return true;

	switch (event.type)
	{
		case SDL_KEYUP:
			if (event.key.keysym.sym == SDLK_f)
			{
				video().toggle_fullscreen();
			}
			else if (event.key.keysym.sym == SDLK_l)
			{
				video().toggle_cursor_captured();
				video().toggle_cursor_visible();
			}
			break;

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

		case SDL_QUIT:
			stop();
			return true;
	}

	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;
	stlplus::env_vector	environment;

	std::string datadir = environment["YOINK_DATADIR"];
	if (!datadir.empty())
	{
		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("yoinkrc");
	moof::resource::find(path);

	stlplus::env_vector environment;

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

	std::string rc_file = environment["YOINKRC"];
	if (!rc_file.empty())
	{
		path += ":";
		path += rc_file;
	}

	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();
	//moof::scalar ratio = moof::core.getVideo()->width() /
		//moof::core.getVideo()->height();
	//gluPerspective(60.0, ratio, 1.0, 250.0);

	//glMatrixMode(GL_MODELVIEW);
}


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[])
{
	stlplus::env_vector environment;

	std::string assets;
	assets.assign(YOINK_DATADIR);
	if (!stlplus::file_readable(assets)) assets += " (no access)";

	std::string datadir = environment["YOINK_DATADIR"];
	if (!datadir.empty())
	{
		if (!stlplus::folder_readable(datadir)) datadir += " (no access)";
	}

	std::string rc_file = environment["YOINKRC"];
	if (!rc_file.empty())
	{
		if (!stlplus::file_readable(rc_file)) rc_file += " (no access)";
	}

	std::cout << "   Executable: " << argv[0] << std::endl
#ifdef YOINK_GITHEAD
			  << "       Commit: "YOINK_GITHEAD << std::endl
#endif
			  << "      Version: "VERSION << std::endl
			  << "        Built: " << COMPILE_TIME << std::endl
			  << "     Compiler: "COMPILER_STRING << std::endl
			  << "       Assets: " << assets << std::endl
			  << "Build options: "
#ifndef HAVE_CLOCK_GETTIME
			  << "-"
#endif
			  << "clock_gettime "
#ifdef NDEBUG
			  << "-"
#endif
			  << "debug "
#ifndef USE_DOUBLE_PRECISION
			  << "-"
#endif
			  << "double-precision "
#ifndef USE_GTK
			  << "-"
#endif
			  << "gtk "
#ifndef USE_HOTLOADING
			  << "-"
#endif
			  << "hotloading "
#ifndef PROFILING_ENABLED
			  << "-"
#endif
			  << "profile "
#ifndef USE_QT4
			  << "-"
#endif
			  << "qt4 "
#ifndef USE_THREADS
			  << "-"
#endif
			  << "threads" << std::endl
			  << "      YOINKRC: " << rc_file << 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;
}


#include <moof/socket.hh>

#include <fstream>

class MyAsset
{
public:
	MyAsset(const std::string& path)
	{
		moof::log_info("MyAsset loading:", path);

		char buffer[1024];

		std::ifstream stream(path.c_str());
		stream.getline(buffer, sizeof(buffer));
		str = buffer;
		stream.close();

		cool();
	}

	void cool()
	{
		moof::log_info("MyAsset COOL:", str);
	}

	void groovy()
	{
		moof::log_info("MyAsset GROOVY!!!!", str);
	}

	std::string str;
};

typedef moof::resource_handle<MyAsset> MyAsset_handle;

class AnotherAsset
{
public:
	AnotherAsset(const std::string& path, double d = 5.0)
	{
		moof::log_info("AnotherAsset loading:", path);
		dude = d;
	}


	void cool()
	{
		moof::log_info("AnotherAsset cool", dude);
	}

	void groovy()
	{
		moof::log_info("AnotherAsset GROOVY!!!!", dude);
	}

	double dude;
};


int main(int argc, char* argv[])
{
	moof::resource::register_type<MyAsset>("mine");
	
	//moof::resource::add_type<AnotherAsset>("k");
	
	//{
	//moof::resource_ptr myAsset = moof::resource::load(assetName,
			//"prefix", "mine");

	//MyAsset_handle aCopy = myAsset;

	//MyAsset_handle copy2 = moof::resource::load(assetName, "asdfas", "mine");

	////if (myAsset->check<MyAsset>()) myAsset->get<AnotherAsset>()->cool();
	//myAsset->get<MyAsset>()->cool();
	////myAsset->get<AnotherAsset>()->groovy();
	
	//aCopy.get()->cool();
	//copy2.get()->cool();

	//log_info("rsrc ptr:", moof::resource::load(assetName, "", "mine"));
	//}
	//log_info("rsrc ptr:", moof::resource::load(assetName, "", "k"));
	//moof::resource::load(assetName, "", "mine")->get<MyAsset>()->cool();

	////if (myAsset) myAsset.get()->cool();
	////else moof::log_error("asset not obtained...");
	
	MyAsset_handle myAsset = moof::resource::load("/home/chaz/meh.mine");
	MyAsset* asset = myAsset.get();
	if (asset) asset->cool();
	else moof::log_warning("no asset obtained!!");

	//moof::timer reloadTimer(
			//boost::bind(&moof::resource::reload_as_needed),
			//SCALAR(2.0),
			//moof::timer::repeat);

	for (;;)
	{
		if (myAsset) myAsset.get()->cool();
		moof::resource::reload_as_needed();
		sleep(1);
	}
	

	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);

	moof::resource::add_search_paths(Main::getSearchPath());

	moof::settings settings(argc, argv, Main::getConfigPath());

	enum moof::log::level logLevel = moof::log::info;
	settings.get("loglevel", logLevel);
	moof::log::level(logLevel);

	try
	{
		std::string iconPath(PACKAGE".png");
		moof::resource::find(iconPath);
		moof::image icon(iconPath);
		icon.set_as_icon();

		class moof::video::attributes attributes(settings);
		moof::video video(PACKAGE_STRING, attributes);
		Main		mainView(settings, video);

		mainView.run();
		return 0;
	}
	catch (const std::exception& e)
	{
		moof::modal_dialog dialog(moof::modal_dialog::error,
								  PACKAGE_STRING, "Unhandled Exception",
								  e.what());

		dialog.run();
		return 1;
	}
}