/*
This file is part of GtkRadiant.

GtkRadiant is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

GtkRadiant is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "ufoai_level.h"
#include "ufoai_filters.h"

#include "ibrush.h"
#include "ientity.h"
#include "iscenegraph.h"

#include "string/string.h"
#include <list>

class Level;

/**
 * @brief find entities by class
 * @note from radiant/map.cpp
 */
class EntityFindByClassname : public scene::Graph::Walker
{
	const char* m_name;
	Entity*& m_entity;
public:
	EntityFindByClassname(const char* name, Entity*& entity) : m_name(name), m_entity(entity)
	{
		m_entity = 0;
	}
	bool pre(const scene::Path& path, scene::Instance& instance) const
	{
		if(m_entity == 0)
		{
			Entity* entity = Node_getEntity(path.top());
			if(entity != 0 && string_equal(m_name, entity->getKeyValue("classname")))
			{
				m_entity = entity;
			}
		}
		return true;
	}
};

/**
 * @brief
 */
Entity* Scene_FindEntityByClass(const char* name)
{
	Entity* entity = NULL;
	GlobalSceneGraph().traverse(EntityFindByClassname(name, entity));
	return entity;
}

/**
 * @brief finds start positions
 */
class EntityFindFlags : public scene::Graph::Walker
{
	const char *m_classname;
	const char *m_flag;
	int *m_count;

	public:
		EntityFindFlags(const char *classname, const char *flag, int *count) : m_classname(classname), m_flag(flag), m_count(count)
		{
		}
		bool pre(const scene::Path& path, scene::Instance& instance) const
		{
			const char *str;
			Entity* entity = Node_getEntity(path.top());
			if(entity != 0 && string_equal(m_classname, entity->getKeyValue("classname")))
			{
				str = entity->getKeyValue(m_flag);
				if (string_empty(str))
				{
					(*m_count)++;
				}
			}
			return true;
		}
};


/**
 * @brief finds start positions
 */
class EntityFindTeams : public scene::Graph::Walker
{
	const char *m_classname;
	int *m_count;
	int *m_team;

public:
	EntityFindTeams(const char *classname, int *count, int *team) : m_classname(classname), m_count(count), m_team(team)
	{
	}
	bool pre(const scene::Path& path, scene::Instance& instance) const
	{
		const char *str;
		Entity* entity = Node_getEntity(path.top());
		if(entity != 0 && string_equal(m_classname, entity->getKeyValue("classname")))
		{
			if (m_count)
				(*m_count)++;
			// now get the highest teamnum
			if (m_team)
			{
				str = entity->getKeyValue("team");
				if (!string_empty(str))
				{
					if (atoi(str) > *m_team)
						(*m_team) = atoi(str);
				}
			}
		}
		return true;
	}
};

/**
 * @brief
 */
void get_team_count (const char *classname, int *count, int *team)
{
	GlobalSceneGraph().traverse(EntityFindTeams(classname, count, team));
	globalOutputStream() << "UFO:AI: classname: " << classname << ": #" << (*count) << "\n";
}

/**
 * @brief Some default values to worldspawn like maxlevel and so on
 */
void assign_default_values_to_worldspawn (bool override, char **returnMsg)
{
	static char message[1024];
	Entity* worldspawn;
	int teams = 0;
	int count = 0;
	char str[64];

	worldspawn = Scene_FindEntityByClass("worldspawn");
	if (!worldspawn)
	{
		globalOutputStream() << "UFO:AI: Could not find worldspawn.\n";
		*returnMsg = "Could not find worldspawn";
		return;
	}

	*message = '\0';
	*str = '\0';

	if (override || string_empty(worldspawn->getKeyValue("maxlevel")))
	{
		// TODO: Get highest brush - a level has 64 units
		worldspawn->setKeyValue("maxlevel", "5");
		snprintf(&message[strlen(message)], sizeof(message) - 1 - strlen(message), "Set maxlevel to: %s", worldspawn->getKeyValue("maxlevel"));
	}

	if (override || string_empty(worldspawn->getKeyValue("maxteams")))
	{
		get_team_count("info_player_start", &count, &teams);
		if (teams)
		{
			snprintf(str, sizeof(str) - 1, "%i", teams);
			worldspawn->setKeyValue("maxteams", str);
			snprintf(&message[strlen(message)], sizeof(message) - 1 - strlen(message), "Set maxteams to: %s", worldspawn->getKeyValue("maxteams"));
		}
		if (count < 16)
		{
			snprintf(&message[strlen(message)], sizeof(message) - 1 - strlen(message), "You should at least place 16 info_player_start");
		}
	}

	// no errors - no warnings
	if (!strlen(message))
		return;

	*returnMsg = message;
}

/**
 * @brief
 */
int check_entity_flags (const char *classname, const char *flag)
{
	int count;

	/* init this with 0 every time we browse the tree */
	count = 0;

	GlobalSceneGraph().traverse(EntityFindFlags(classname, flag, &count));
	return count;
}

/**
 * @brief Will check e.g. the map entities for valid values
 * @todo: check for maxlevel
 */
void check_map_values (char **returnMsg)
{
	static char message[1024];
	int count = 0;
	int teams = 0;
	int ent_flags;
	Entity* worldspawn;
	char str[64];

	worldspawn = Scene_FindEntityByClass("worldspawn");
	if (!worldspawn)
	{
		globalOutputStream() << "UFO:AI: Could not find worldspawn.\n";
		*returnMsg = "Could not find worldspawn";
		return;
	}

	*message = '\0';
	*str = '\0';

	// multiplayer start positions
	get_team_count("info_player_start", &count, &teams);
	if (!count)
		strncat(message, "No multiplayer start positions (info_player_start)\n", sizeof(message) - 1);

	// singleplayer map?
	count = 0;
	get_team_count("info_human_start", &count, NULL);
	if (!count)
		strncat(message, "No singleplayer start positions (info_human_start)\n", sizeof(message) - 1);

	// singleplayer map?
	count = 0;
	get_team_count("info_2x2_start", &count, NULL);
	if (!count)
		strncat(message, "No singleplayer start positions for 2x2 units (info_2x2_start)\n", sizeof(message) - 1);

	// search for civilians
	count = 0;
	get_team_count("info_civilian_start", &count, NULL);
	if (!count)
		strncat(message, "No civilian start positions (info_civilian_start)\n", sizeof(message) - 1);

	// check maxlevel
	if (string_empty(worldspawn->getKeyValue("maxlevel")))
		strncat(message, "Worldspawn: No maxlevel defined\n", sizeof(message) - 1);
	else if (atoi(worldspawn->getKeyValue("maxlevel")) > 8)
	{
		strncat(message, "Worldspawn: Highest maxlevel is 8\n", sizeof(message) - 1);
		worldspawn->setKeyValue("maxlevel", "8");
	}

	ent_flags = check_entity_flags("func_door", "spawnflags");
	if (ent_flags)
		snprintf(&message[strlen(message)], sizeof(message) - 1 - strlen(message), "Found %i func_door with no spawnflags\n", ent_flags);
	ent_flags = check_entity_flags("func_breakable", "spawnflags");
	if (ent_flags)
		snprintf(&message[strlen(message)], sizeof(message) - 1 - strlen(message), "Found %i func_breakable with no spawnflags\n", ent_flags);
	ent_flags = check_entity_flags("misc_sound", "spawnflags");
	if (ent_flags)
		snprintf(&message[strlen(message)], sizeof(message) - 1 - strlen(message), "Found %i misc_sound with no spawnflags\n", ent_flags);
	ent_flags = check_entity_flags("misc_model", "spawnflags");
	if (ent_flags)
		snprintf(&message[strlen(message)], sizeof(message) - 1 - strlen(message), "Found %i misc_model with no spawnflags\n", ent_flags);
	ent_flags = check_entity_flags("misc_particle", "spawnflags");
	if (ent_flags)
		snprintf(&message[strlen(message)], sizeof(message) - 1 - strlen(message), "Found %i misc_particle with no spawnflags\n", ent_flags);
	ent_flags = check_entity_flags("info_player_start", "team");
	if (ent_flags)
		snprintf(&message[strlen(message)], sizeof(message) - 1 - strlen(message), "Found %i info_player_start with no team assigned\n!!Teamcount may change after you've fixed this\n", ent_flags);
	ent_flags = check_entity_flags("light", "color");
	ent_flags = check_entity_flags("light", "_color");
	if (ent_flags)
		snprintf(&message[strlen(message)], sizeof(message) - 1 - strlen(message), "Found %i lights with no color value\n", ent_flags);

	// no errors found
	if (!strlen(message)) {
		snprintf(message, sizeof(message) - 1, "No errors found - you are ready to compile the map now\n");
	}

	*returnMsg = message;
}
