/*         /\/\   __ _ _ __   __ _  ___ / _\ ___ _ __(_)_ __ | |_ 
 *        /    \ / _` | '_ \ / _` |/ _ \\ \ / __| '__| | '_ \| __|
 *       / /\/\ \ (_| | | | | (_| | (_) |\ \ (__| |  | | |_) | |_ 
 *       \/    \/\__,_|_| |_|\__, |\___/\__/\___|_|  |_| .__/ \__|
 *                           |___/                     |_|     
 *                        A WHOLE NEW WORLD
 *         MangoScript - Bringing a whole new world to MaNGOS
 *
 *      Lua_Database.cpp - Exports misc related functions to LUA
 *
 *      (c) Copyright 2006-2007 by the By the MangoScript Team <http://www.mangoscript.org>
 *
 *      This program 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.
 *  
 *      This program 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 this program; if not, write to the Free Software
 *      Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *      $Id: Lua_Database.cpp 129 2007-02-23 16:43:15Z andrejkw $
 */

#include "Lua_Database.h"
#include "Lua_uint64.h"
#include "Database/DatabaseEnv.h"
#include "Database/Database.h"
#include "Database/impl/MySQLDatabase.h"
/*#include "Database/impl/PostgreDatabase.h"*/


/* Functions for QueryResult */
lua_uint64 lb_QueryResult_GetRowCount_u64(QueryResult* qr)
{
	  return lua_uint64(qr->GetRowCount());
}

luabind::object lb_QueryResult_Fetch(lua_State* L, QueryResult* qr)
{
	Field* fields = qr->Fetch();
	luabind::object lua_fields = luabind::newtable(L);

	for (int x = 0; x < qr->GetFieldCount(); x++)
		lua_fields[x] = &fields[x];

	return lua_fields;
}

/* Functions for Field */
lua_uint64 lb_Field_GetUInt64(Field* f) { return lua_uint64(f->GetUInt64()); }

/* Functions for SpellEntry */
uint32 lb_SpellEntry_Totem(SpellEntry se, uint8 i) { return ((i <= 2) ? se.Totem[i] : 0); }
uint32 lb_SpellEntry_Reagent(SpellEntry se, uint8 i) { return ((i <= 8) ? se.Reagent[i] : 0); }
uint32 lb_SpellEntry_ReagentCount(SpellEntry se, uint8 i) { return ((i <= 8) ? se.ReagentCount[i] : 0); }
uint32 lb_SpellEntry_Effect(SpellEntry se, uint8 i) { return ((i <= 3) ? se.Effect[i] : 0); }
uint32 lb_SpellEntry_EffectImplicitTargetA(SpellEntry se, uint8 i) { return ((i <= 3) ? se.EffectImplicitTargetA[i] : 0); }
uint32 lb_SpellEntry_EffectImplicitTargetB(SpellEntry se, uint8 i) { return ((i <= 3) ? se.EffectImplicitTargetB[i] : 0); }

/* Functions for Database */
/*Database*__w64 lb_sDatabase() { return &sDatabase; }
Database*__w64 lb_loginDatabase() { return &loginDatabase; }*/
 Database* lb_sDatabase() { return &sDatabase; }
 Database* lb_loginDatabase() { return &loginDatabase; }
 


void lb_QueryResult_Free(QueryResult* res) { if (res) delete res; }

/*Database* lb_OpenMysqlConnection(const char* loginInformation)*/
MySQLDatabase* lb_OpenMysqlConnection(const char* Hostname, unsigned int port,
        const char* Username, const char* Password, const char* DatabaseName,
        uint32 ConnectionCount, uint32 BufferSize)
{
	MySQLDatabase* db = new MySQLDatabase();

	//if (!db->Initialize(loginInformation, DATABASE_TYPE_MYSQL))
	if (!db->Initialize(Hostname, port, Username, Password, DatabaseName, ConnectionCount, BufferSize))
		return NULL;
	else
		return db;
}

void lb_Database_Close(Database* db)
{
	if ((db) && (db != &sDatabase) && (db != &loginDatabase))
		delete db;
}

/* Functions for DBCStorage */
DBCStorage <SpellEntry>* lb_sSpellStore() { return &sSpellStore; }
DBCStorage <SpellCastTimesEntry>* lb_sCastTimesStore() { return &sCastTimesStore; }

int lb_Export_Database(lua_State* L)
{
	using namespace luabind;

	/* Lua (Database) Global Functions */
	module(L)
	[
		def("sDatabase", &lb_sDatabase),
		def("loginDatabase", &lb_loginDatabase),

		def("sSpellStore", &lb_sSpellStore),
		def("sCastTimesStore", &lb_sCastTimesStore),

		def("OpenMysqlConnection", &lb_OpenMysqlConnection),

		def("GetDuration", &GetDuration),
		def("GetMaxDuration", &GetMaxDuration),
		/* def("IsRankSpellDueToSpell", &IsRankSpellDueToSpell),
		def("IsNoStackSpellDueToSpell", &IsNoStackSpellDueToSpell), */
		def("IsNoStackAuraDueToAura", &IsNoStackAuraDueToAura),
		def("CompareAuraRanks", &CompareAuraRanks),
		def("IsSpellSingleEffectPerCaster", &IsSpellSingleEffectPerCaster),
		def("IsPassiveSpell", &IsPassiveSpell),
		def("IsPositiveSpell", &IsPositiveSpell),
		def("IsPositiveEffect", &IsPositiveEffect),
		def("IsSingleTarget", &IsSingleTarget),
		def("CanUsedWhileStealthed", &CanUsedWhileStealthed)
	];

	/* From MySQLDatabase.h */
	module(L)
	[
		class_<MySQLDatabase>("MySQLDatabase")
			/*.def("Close", &lb_Database_Close)*/
			/*.def("PQuery", &MySQLDatabase::PQuery)*/
			/*.def("Query", &MySQLDatabase::Query)
			.def("Execute", &MySQLDatabase::Execute)*/
			/*.def("PExecute", &MySQLDatabase::PExecute)
			.def("BeginTransaction", &MySQLDatabase::StartTransaction)
			.def("CommitTransaction", &MySQLDatabase::CommitTransaction)
			.def("RollbackTransaction", &MySQLDatabase::RollbackTransaction)*/
			/*.def("escape_string", (void (MySQLDatabase::*)(std::string&))&MySQLDatabase::escape_string)*/
			/*.def("ThreadStart", &MySQLDatabase::ThreadStart)
			.def("ThreadEnd", &MySQLDatabase::ThreadEnd)*/
	];

		/* From Database.h */
	module(L)
	[
		class_<Database>("Database")
			/*.def("Close", &lb_Database_Close)*/
			/*.def("PQuery", &Database::PQuery)*/
			/*.def("Query", &Database::Query)
			.def("Execute", &Database::Execute)*/
			/*.def("PExecute", &Database::PExecute)
			.def("BeginTransaction", &Database::StartTransaction)
			.def("CommitTransaction", &Database::CommitTransaction)
			.def("RollbackTransaction", &Database::RollbackTransaction)*/
			.def("escape_string", (void (Database::*)(std::string&))&Database::escape_string)
			/*.def("ThreadStart", &Database::ThreadStart)
			.def("ThreadEnd", &Database::ThreadEnd)*/
	];

	/* From Field.h */
	module(L)
	[
		class_<Field>("Field")
			.def(constructor<>())
			.def(constructor<Field&>())
			.def(constructor<const char*, const char*, Field::DataTypes>())
			.def("GetName", &Field::GetName)
			.def("GetType", &Field::GetType)
			.def("GetString", &Field::GetString)
			.def("GetFloat", &Field::GetFloat)
			.def("GetInt32", &Field::GetInt32)
			.def("GetUInt8", &Field::GetUInt8)
			.def("GetUInt16", &Field::GetUInt16)
			.def("GetUInt32", &Field::GetUInt16)
			.def("GetUInt64", &lb_Field_GetUInt64)
			.def("SetName", &Field::SetName)
			.def("SetType", &Field::SetType)
			.def("SetValue", &Field::SetValue)
	];

	/* From QueryResult.h */
	module(L)
	[
		class_<QueryResult>("QueryResult")
			/*.def(constructor<uint64, uint32>)())*/
			.def("NextRow", &QueryResult::NextRow)
			.def("Free", &lb_QueryResult_Free)
			.def("Fetch", &lb_QueryResult_Fetch, raw(_1))
			.def("GetFieldCount", &QueryResult::GetFieldCount)
			.def("GetRowCount", (uint32 (QueryResult::*)(void))&QueryResult::GetRowCount)
			.def("GetRowCount_u64", &lb_QueryResult_GetRowCount_u64)
	];

	/* From DBCStructure.h */
	// TODO: need to export more information for SpellEntry
	// TODO: maybe (if possible) simplify the way DBCStorage is exported
	module(L)
	[
		class_<SpellEntry>("SpellEntry")
			.def_readonly("Id", &SpellEntry::Id)
			.def_readonly("School", &SpellEntry::School)
			.def_readonly("Category", &SpellEntry::Category)
			.def_readonly("Dispel", &SpellEntry::Dispel)
			.def_readonly("Mechanic", &SpellEntry::Mechanic)
			.def_readonly("Attributes", &SpellEntry::Attributes)
			//...
			.def_readonly("Stances", &SpellEntry::Stances)
			.def_readonly("Targets", &SpellEntry::Targets)
			.def_readonly("TargetCreatureType", &SpellEntry::TargetCreatureType)
			.def_readonly("RequiresSpellFocus", &SpellEntry::RequiresSpellFocus)
			.def_readonly("CasterAuraState", &SpellEntry::CasterAuraState)
			.def_readonly("CastingTimeIndex", &SpellEntry::CastingTimeIndex)
			.def_readonly("RecoveryTime", &SpellEntry::RecoveryTime)
			.def_readonly("CategoryRecoveryTime", &SpellEntry::CategoryRecoveryTime)
			.def_readonly("InterruptFlags", &SpellEntry::InterruptFlags)
			//...
			.def("Totem", &lb_SpellEntry_Totem)
			.def("Reagent", &lb_SpellEntry_Reagent)
			.def("ReagentCount", &lb_SpellEntry_ReagentCount)
			.def_readonly("EquippedItemClass", &SpellEntry::EquippedItemClass)
			.def_readonly("EquippedItemSubClassMask", &SpellEntry::EquippedItemSubClassMask)
			.def_readonly("EquippedItemInventoryTypeMask", &SpellEntry::EquippedItemInventoryTypeMask)
			.def("Effect", &lb_SpellEntry_Effect)
			//...
			.def("EffectImplicitTargetA", &lb_SpellEntry_EffectImplicitTargetA)
			.def("EffectImplicitTargetB", &lb_SpellEntry_EffectImplicitTargetB),

		// Export for DBCStorage with SpellEntry
		class_<DBCStorage<SpellEntry> >("DBCStorage")
			.def("LookupEntry", &DBCStorage<SpellEntry>::LookupEntry)
			.def("GetNumRows", &DBCStorage<SpellEntry>::GetNumRows)
			.def("Load", &DBCStorage<SpellEntry>::Load)
			.def("Clear", &DBCStorage<SpellEntry>::Clear)
	];

	module(L)
	[
		class_<SpellCastTimesEntry>("SpellCastTimesEntry")
			.def_readonly("ID", &SpellCastTimesEntry::ID)
			.def_readonly("CastTime", &SpellCastTimesEntry::CastTime),

		// Export for DBCStorage with SpellCastTimesEntry
		class_<DBCStorage<SpellCastTimesEntry> >("DBCStorage")
			.def("LookupEntry", &DBCStorage<SpellCastTimesEntry>::LookupEntry)
			.def("GetNumRows", &DBCStorage<SpellCastTimesEntry>::GetNumRows)
			.def("Load", &DBCStorage<SpellCastTimesEntry>::Load)
			.def("Clear", &DBCStorage<SpellCastTimesEntry>::Clear)
	];

	return 0;
}