/*
   core/gameinterface.cc
   This file is part of the Osirion project and is distributed under
   the terms of the GNU General Public License version 2
*/

#include <cstdlib>
#include <iostream>
#include <iomanip>

#include "auxiliary/functions.h"
#include "core/application.h"
#include "core/cvar.h"
#include "core/func.h"
#include "core/info.h"
#include "core/gameinterface.h"
#include "core/player.h"
#include "core/zone.h"
#include "model/material.h"
#include "model/model.h"
#include "sys/sys.h"

namespace core
{

void func_list_players(std::string const &args)
{

	if (args.size())
	{
		Player *player = game()->find_player(args);
		if (!player)
		{
			con_print << "^BPlayer '" + args + "^B' not found";
			return;
		} else {
			player->print();
		}
	} else {
		game()->list_players();
	}
}

Player GameInterface::game_localplayer(0);

EntityControlable *localcontrol()
{
	if (game()->localplayer())
	{
		return game()->localplayer()->control();
	} else {
		return 0;
	}

}
Player *localplayer()
{
	return game()->localplayer();
}

GameInterface::GameInterface()
{
	clear();

	game_localplayer.clear();
	if (Cvar::sv_dedicated->value())
	{
		game_localplayer.player_name.assign("Console");
	} else {
		game_localplayer.player_name.assign("Player");
		game_localplayer.update_info();
	}

	Func *func = Func::add("list_players", func_list_players);
	func->set_info("get the local list of connected players");

	// TODO this should be moved back into render
	size_t mb = (size_t) Cvar::mem_vertex->value();
	if (mb < 4 * sizeof(float))
		mb = 4 * sizeof(float);
	if (mb > 512)
		mb = 512;
	(*Cvar::mem_vertex) = (float) mb;
	game_vertexarray = new model::VertexArray(mb);
	
	model::Material::init();
	
	game_timestamp = 0;
	game_running = false;
	game_interactive = false;
}

GameInterface::~GameInterface()
{
	Func::remove("list_players");

	game_localplayer.clear();

	clear();

	// delete vertex array
	if (game_vertexarray)
	{
		delete game_vertexarray;
		game_vertexarray = 0;
	}
}

// clear all game related objects
void GameInterface::clear()
{
	// remove all entities
	Entity::clear();

	// remove all zones
	Zone::clear();

	// remove info records
	Info::clear();

	// remove models
	model::Model::clear();
	
	// remove materials
	model::Material::clear();

	// clear player list
	for (Players::iterator it = game_players.begin(); it != game_players.end(); it++)
	{
		Player *player = (*it);
		if (player != localplayer())
		{
			delete player;
		}
	}
	game_players.clear();
	game_playerlist_timestamp = 0;

	// remove all game functions
	for (Func::Registry::iterator it = Func::registry().begin(); it != Func::registry().end();)
	{
		if (((*it).second->flags() & Func::Game) == Func::Game)
		{
			delete(*it).second;
			Func::registry().erase(it++);
		} else {
			++it;
		}
	}

	// remove all game cvars
	for (Cvar::Registry::iterator it = Cvar::registry().begin(); it != Cvar::registry().end();)
	{
		if (((*it).second->flags() & Cvar::Game) == Cvar::Game)
		{
			delete(*it).second;
			Cvar::registry().erase(it++);
		} else {
			++it;
		}
	}
	
	game_running = false;
	game_interactive = true;
}

void GameInterface::set_running(const bool running)
{
	game_running = running;
}

void GameInterface::set_interactive(const bool interactive)
{
	game_interactive = interactive;
}

void GameInterface::set_timestamp(const unsigned long timestamp)
{
	game_timestamp = timestamp;
}

void GameInterface::set_playerlist_timestamp(const unsigned long timestamp)
{
	game_playerlist_timestamp = ( timestamp > 0 ? timestamp : 1);
}

void GameInterface::abort()
{
	game_running = false;
}

Player *GameInterface::find_player(const int playerid)
{
	if (playerid == 0)
	{
		return 0;
	}
	
	for (Players::iterator it = game_players.begin(); it != game_players.end(); it++)
	{
		if ((*it)->id() == playerid)
		{
			return (*it);
		}
	}
	return 0;
}

Player *GameInterface::find_player(const Player *player)
{
	if (player)
	{
		for (Players::iterator it = game_players.begin(); it != game_players.end(); it++)
		{
			if ((*it) == player)
			{
				return (*it);
			}
		}
	}
	return 0;
}

Player *GameInterface::find_player(const std::string &search)
{
	std::istringstream searchstr(search);
	int id = 0;
	if (searchstr >> id) {
		for (Players:: iterator it = game_players.begin(); it != game_players.end(); it++)
		{
			if ((*it)->id() == id)
			{
				return (*it);
			}
		}
	}

	if (search.size() < 3)
	{
		return 0;
	}

	for (Players:: iterator it = game_players.begin(); it != game_players.end(); it++)
	{
		if (aux::text_strip_lowercase((*it)->name()).find(aux::lowercase(search)) != std::string::npos)
			return (*it);
	}

	return 0;
}

void GameInterface::list_players()
{
	int count = 0;

	for (Players::const_iterator it = game_players.begin(); it != game_players.end(); it++)
	{
		const Player *player = (*it);
		con_print << "  " << std::setfill(' ')
			<< aux::pad_left(player->name(), 24) << "^N "
			<< "id^B" << std::setw(4) << player->id() << " "
			<< "ping^B" << std::setw(4) << player->ping() << "^N "
			<< "level^B" << std::setw(4) << player->level() << "^N";

		if (player->zone())
			con_print << aux::pad_left(player->zone()->name(), 24) << "^N";

		con_print << std::endl;
		count++;
	}

	con_print << count << " connected " << aux::plural("player", count) << std::endl;
}

} // namespace core