/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

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 3 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, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "pyVault.h"
#include "pyEnum.h"
#include "pyAgeInfoStruct.h"
#include "pyVaultNode.h"
#include "pySDL.h"
#include "pyAgeLinkStruct.h"

#include "../plVault/plVault.h"
#include "../plMessage/plVaultNotifyMsg.h"
#include <python.h>

#ifndef BUILDING_PYPLASMA

// glue functions
PYTHON_CLASS_DEFINITION(ptVault, pyVault);

PYTHON_DEFAULT_NEW_DEFINITION(ptVault, pyVault)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptVault)

PYTHON_INIT_DEFINITION(ptVault, args, keywords)
{
	PYTHON_RETURN_INIT_OK;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getPlayerInfo)
{
	return self->fThis->GetPlayerInfo();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getKIUsage)
{
	return self->fThis->GetKIUsage();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getInbox)
{
	return self->fThis->GetInbox();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getAvatarOutfitFolder)
{
	return self->fThis->GetAvatarOutfitFolder();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getAvatarClosetFolder)
{
	return self->fThis->GetAvatarClosetFolder();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getChronicleFolder)
{
	return self->fThis->GetChronicleFolder();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getAgeJournalsFolder)
{
	return self->fThis->GetAgeJournalsFolder();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getIgnoreListFolder)
{
	return self->fThis->GetIgnoreListFolder();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getBuddyListFolder)
{
	return self->fThis->GetBuddyListFolder();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getPeopleIKnowAboutFolder)
{
	return self->fThis->GetPeopleIKnowAboutFolder();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getAgesICanVisitFolder)
{
	return self->fThis->GetAgesICanVisitFolder();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getAgesIOwnFolder)
{
	return self->fThis->GetAgesIOwnFolder();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getInviteFolder)
{
	return self->fThis->GetInviteFolder();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getLinkToMyNeighborhood)
{
	return self->fThis->GetLinkToMyNeighborhood();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getLinkToCity)
{
	return self->fThis->GetLinkToCity();
}

PYTHON_METHOD_DEFINITION(ptVault, getOwnedAgeLink, args)
{
	PyObject* ageInfoObj = NULL;
	if (!PyArg_ParseTuple(args, "O", &ageInfoObj))
	{
		PyErr_SetString(PyExc_TypeError, "getOwnedAgeLink expects a ptAgeInfoStruct");
		PYTHON_RETURN_ERROR;
	}
	if (!pyAgeInfoStruct::Check(ageInfoObj))
	{
		PyErr_SetString(PyExc_TypeError, "getOwnedAgeLink expects a ptAgeInfoStruct");
		PYTHON_RETURN_ERROR;
	}
	pyAgeInfoStruct* ageInfo = pyAgeInfoStruct::ConvertFrom(ageInfoObj);
	return self->fThis->GetOwnedAgeLink(*ageInfo);
}

PYTHON_METHOD_DEFINITION(ptVault, getVisitAgeLink, args)
{
	PyObject* ageInfoObj = NULL;
	if (!PyArg_ParseTuple(args, "O", &ageInfoObj))
	{
		PyErr_SetString(PyExc_TypeError, "getVisitAgeLink expects a ptAgeInfoStruct");
		PYTHON_RETURN_ERROR;
	}
	if (!pyAgeInfoStruct::Check(ageInfoObj))
	{
		PyErr_SetString(PyExc_TypeError, "getVisitAgeLink expects a ptAgeInfoStruct");
		PYTHON_RETURN_ERROR;
	}
	pyAgeInfoStruct* ageInfo = pyAgeInfoStruct::ConvertFrom(ageInfoObj);
	return self->fThis->GetVisitAgeLink(*ageInfo);
}

PYTHON_METHOD_DEFINITION(ptVault, findChronicleEntry, args)
{
	char* entryName;
	if (!PyArg_ParseTuple(args, "s", &entryName))
	{
		PyErr_SetString(PyExc_TypeError, "findChronicleEntry expects a string");
		PYTHON_RETURN_ERROR;
	}
	return self->fThis->FindChronicleEntry(entryName);
}

PYTHON_METHOD_DEFINITION(ptVault, addChronicleEntry, args)
{
	char* entryName;
	unsigned long entryType;
	char* entryValue;
	if (!PyArg_ParseTuple(args, "sls", &entryName, &entryType, &entryValue))
	{
		PyErr_SetString(PyExc_TypeError, "addChronicleEntry expects a string, an unsigned long, and a string");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->AddChronicleEntry(entryName, entryType, entryValue);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getGlobalInbox)
{
	return self->fThis->GetGlobalInbox();
}

#ifdef GlobalInboxTestCode
PYTHON_BASIC_METHOD_DEFINITION(ptVault, createGlobalInbox, CreateGlobalInbox)
#endif

PYTHON_METHOD_DEFINITION(ptVault, findNode, args)
{
	PyObject* templateNodeObj = NULL;
	if (!PyArg_ParseTuple(args, "O", &templateNodeObj))
	{
		PyErr_SetString(PyExc_TypeError, "findNode expects a ptVaultNode");
		PYTHON_RETURN_ERROR;
	}
	if (!pyVaultNode::Check(templateNodeObj))
	{
		PyErr_SetString(PyExc_TypeError, "findNode expects a ptVaultNode");
		PYTHON_RETURN_ERROR;
	}
	pyVaultNode* templateNode = pyVaultNode::ConvertFrom(templateNodeObj);
	return self->fThis->FindNode(templateNode);
}

PYTHON_METHOD_DEFINITION(ptVault, sendToDevice, args)
{
	PyObject* nodeObj = NULL;
	char* deviceName;
	if (!PyArg_ParseTuple(args, "Os", &nodeObj, &deviceName))
	{
		PyErr_SetString(PyExc_TypeError, "sendToDevice expects a ptVaultNode and a string");
		PYTHON_RETURN_ERROR;
	}
	if (!pyVaultNode::Check(nodeObj))
	{
		PyErr_SetString(PyExc_TypeError, "sendToDevice expects a ptVaultNode and a string");
		PYTHON_RETURN_ERROR;
	}
	pyVaultNode* node = pyVaultNode::ConvertFrom(nodeObj);
	self->fThis->SendToDevice(*node, deviceName);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getPsnlAgeSDL)
{
	return self->fThis->GetPsnlAgeSDL();
}

PYTHON_METHOD_DEFINITION(ptVault, updatePsnlAgeSDL, args)
{
	PyObject* pyrecObj = NULL;
	if (!PyArg_ParseTuple(args, "O", &pyrecObj))
	{
		PyErr_SetString(PyExc_TypeError, "updatePsnlAgeSDL expects a ptSDLStateDataRecord");
		PYTHON_RETURN_ERROR;
	}
	if (!pySDLStateDataRecord::Check(pyrecObj))
	{
		PyErr_SetString(PyExc_TypeError, "updatePsnlAgeSDL expects a ptSDLStateDataRecord");
		PYTHON_RETURN_ERROR;
	}
	pySDLStateDataRecord* pyrec = pySDLStateDataRecord::ConvertFrom(pyrecObj);
	self->fThis->UpdatePsnlAgeSDL(*pyrec);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, inMyPersonalAge)
{
	PYTHON_RETURN_BOOL(self->fThis->InMyPersonalAge());
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, inMyNeighborhoodAge)
{
	PYTHON_RETURN_BOOL(self->fThis->InMyNeighborhoodAge());
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, amOwnerOfCurrentAge)
{
	PYTHON_RETURN_BOOL(self->fThis->AmOwnerOfCurrentAge());
}

PYTHON_METHOD_DEFINITION_NOARGS(ptVault, amCzarOfCurrentAge)
{
	PYTHON_RETURN_BOOL(self->fThis->AmCzarOfCurrentAge());
}

PYTHON_METHOD_DEFINITION(ptVault, amAgeOwner, args)
{
	PyObject* ageInfoObj = NULL;
	if (!PyArg_ParseTuple(args, "O", &ageInfoObj))
	{
		PyErr_SetString(PyExc_TypeError, "amAgeOwner expects a ptAgeInfoStruct");
		PYTHON_RETURN_ERROR;
	}
	if (!pyAgeInfoStruct::Check(ageInfoObj))
	{
		PyErr_SetString(PyExc_TypeError, "amAgeOwner expects a ptAgeInfoStruct");
		PYTHON_RETURN_ERROR;
	}
	pyAgeInfoStruct* ageInfo = pyAgeInfoStruct::ConvertFrom(ageInfoObj);
	PYTHON_RETURN_BOOL(self->fThis->AmAgeOwner(ageInfo));
}

PYTHON_METHOD_DEFINITION(ptVault, amAgeCzar, args)
{
	PyObject* ageInfoObj = NULL;
	if (!PyArg_ParseTuple(args, "O", &ageInfoObj))
	{
		PyErr_SetString(PyExc_TypeError, "amAgeCzar expects a ptAgeInfoStruct");
		PYTHON_RETURN_ERROR;
	}
	if (!pyAgeInfoStruct::Check(ageInfoObj))
	{
		PyErr_SetString(PyExc_TypeError, "amAgeCzar expects a ptAgeInfoStruct");
		PYTHON_RETURN_ERROR;
	}
	pyAgeInfoStruct* ageInfo = pyAgeInfoStruct::ConvertFrom(ageInfoObj);
	PYTHON_RETURN_BOOL(self->fThis->AmAgeCzar(ageInfo));
}

PYTHON_METHOD_DEFINITION(ptVault, registerMTStation, args)
{
	char* stationName;
	char* mtSpawnPoint;
	if (!PyArg_ParseTuple(args, "ss", &stationName, &mtSpawnPoint))
	{
		PyErr_SetString(PyExc_TypeError, "registerMTStation expects two strings");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->RegisterMTStation(stationName, mtSpawnPoint);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptVault, registerOwnedAge, args)
{
	PyObject* ageLinkObj = NULL;
	if (!PyArg_ParseTuple(args, "O", &ageLinkObj))
	{
		PyErr_SetString(PyExc_TypeError, "registerOwnedAge expects a ptAgeLinkStruct");
		PYTHON_RETURN_ERROR;
	}
	if (!pyAgeLinkStruct::Check(ageLinkObj))
	{
		PyErr_SetString(PyExc_TypeError, "registerOwnedAge expects a ptAgeLinkStruct");
		PYTHON_RETURN_ERROR;
	}
	pyAgeLinkStruct* ageLink = pyAgeLinkStruct::ConvertFrom(ageLinkObj);
	self->fThis->RegisterOwnedAge(*ageLink);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptVault, unRegisterOwnedAge, args)
{
	char* ageFilename;
	if (!PyArg_ParseTuple(args, "s", &ageFilename))
	{
		PyErr_SetString(PyExc_TypeError, "unRegisterOwnedAge expects a string");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->UnRegisterOwnedAge(ageFilename);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptVault, registerVisitAge, args)
{
	PyObject* ageLinkObj = NULL;
	if (!PyArg_ParseTuple(args, "O", &ageLinkObj))
	{
		PyErr_SetString(PyExc_TypeError, "registerVisitAge expects a ptAgeLinkStruct");
		PYTHON_RETURN_ERROR;
	}
	if (!pyAgeLinkStruct::Check(ageLinkObj))
	{
		PyErr_SetString(PyExc_TypeError, "registerVisitAge expects a ptAgeLinkStruct");
		PYTHON_RETURN_ERROR;
	}
	pyAgeLinkStruct* ageLink = pyAgeLinkStruct::ConvertFrom(ageLinkObj);
	self->fThis->RegisterVisitAge(*ageLink);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptVault, unRegisterVisitAge, args)
{
	char* guid;
	if (!PyArg_ParseTuple(args, "s", &guid))
	{
		PyErr_SetString(PyExc_TypeError, "unRegisterVisitAge expects a string");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->UnRegisterVisitAge(guid);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptVault, invitePlayerToAge, args)
{
	PyObject* ageLinkObj = NULL;
	unsigned long playerID;
	if (!PyArg_ParseTuple(args, "Ol", &ageLinkObj, &playerID))
	{
		PyErr_SetString(PyExc_TypeError, "invitePlayerToAge expects a ptAgeLinkStruct and an unsigned long");
		PYTHON_RETURN_ERROR;
	}
	if (!pyAgeLinkStruct::Check(ageLinkObj))
	{
		PyErr_SetString(PyExc_TypeError, "invitePlayerToAge expects a ptAgeLinkStruct and an unsigned long");
		PYTHON_RETURN_ERROR;
	}
	pyAgeLinkStruct* ageLink = pyAgeLinkStruct::ConvertFrom(ageLinkObj);
	self->fThis->InvitePlayerToAge(*ageLink, playerID);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptVault, unInvitePlayerToAge, args)
{
	char* guid;
	unsigned long playerID;
	if (!PyArg_ParseTuple(args, "sl", &guid, &playerID))
	{
		PyErr_SetString(PyExc_TypeError, "unInvitePlayerToAge expects a string and an unsigned long");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->UnInvitePlayerToAge(guid, playerID);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptVault, offerLinkToPlayer, args)
{
	PyObject* ageLinkObj = NULL;
	unsigned long playerID;
	if (!PyArg_ParseTuple(args, "Ol", &ageLinkObj, &playerID))
	{
		PyErr_SetString(PyExc_TypeError, "offerLinkToPlayer expects a ptAgeLinkStruct and an unsigned long");
		PYTHON_RETURN_ERROR;
	}
	if (!pyAgeLinkStruct::Check(ageLinkObj))
	{
		PyErr_SetString(PyExc_TypeError, "offerLinkToPlayer expects a ptAgeLinkStruct and an unsigned long");
		PYTHON_RETURN_ERROR;
	}
	pyAgeLinkStruct* ageLink = pyAgeLinkStruct::ConvertFrom(ageLinkObj);
	self->fThis->OfferLinkToPlayer(*ageLink, playerID);
	PYTHON_RETURN_NONE;
}

PYTHON_BASIC_METHOD_DEFINITION(ptVault, createNeighborhood, CreateNeighborhood)

PYTHON_METHOD_DEFINITION(ptVault, setAgePublic, args)
{
	PyObject* ageInfoObj = NULL;
	char makePublic;
	if (!PyArg_ParseTuple(args, "Ob", &ageInfoObj, &makePublic))
	{
		PyErr_SetString(PyExc_TypeError, "setAgePublic expects a ptAgeInfoStruct and a boolean");
		PYTHON_RETURN_ERROR;
	}
	if (!pyAgeInfoStruct::Check(ageInfoObj))
	{
		PyErr_SetString(PyExc_TypeError, "setAgePublic expects a ptAgeInfoStruct and a boolean");
		PYTHON_RETURN_ERROR;
	}
	pyAgeInfoStruct* ageInfo = pyAgeInfoStruct::ConvertFrom(ageInfoObj);
	PYTHON_RETURN_BOOL(self->fThis->SetAgePublic(ageInfo, makePublic != 0));
}

PYTHON_START_METHODS_TABLE(ptVault)
	PYTHON_METHOD_NOARGS(ptVault, getPlayerInfo, "Returns a ptVaultNode of type kNodeTypePlayerInfo of the current player"),
	PYTHON_METHOD_NOARGS(ptVault, getKIUsage, "Returns a tuple with usage statistics of the KI (# of pics, # of text notes, # of marker games)"),
	PYTHON_METHOD_NOARGS(ptVault, getInbox, "Returns a ptVaultFolderNode of the current player's inbox folder."),
	PYTHON_METHOD_NOARGS(ptVault, getAvatarOutfitFolder, "Do not use.\n"
				"Returns a ptVaultFolderNode of the avatars outfit."),
	PYTHON_METHOD_NOARGS(ptVault, getAvatarClosetFolder, "Do not use.\n"
				"Returns a ptVaultFolderNode of the avatars outfit in their closet."),
	PYTHON_METHOD_NOARGS(ptVault, getChronicleFolder, "Returns a ptVaultFolderNode of the current player's chronicle folder."),
	PYTHON_METHOD_NOARGS(ptVault, getAgeJournalsFolder, "Returns a ptVaultFolderNode of the current player's age journals folder."),
	PYTHON_METHOD_NOARGS(ptVault, getIgnoreListFolder, "Returns a ptVaultPlayerInfoListNode of the current player's ignore list folder."),
	PYTHON_METHOD_NOARGS(ptVault, getBuddyListFolder, "Returns a ptVaultPlayerInfoListNode of the current player's buddy list folder."),
	PYTHON_METHOD_NOARGS(ptVault, getPeopleIKnowAboutFolder, "Returns a ptVaultPlayerInfoListNode of the current player's people I know about (Recent) list folder."),
	PYTHON_METHOD_NOARGS(ptVault, getAgesICanVisitFolder, "Returns a ptVaultFolderNode of ages I can visit"),
	PYTHON_METHOD_NOARGS(ptVault, getAgesIOwnFolder, "Returns a ptVaultFolderNode of ages that I own"),
	PYTHON_METHOD_NOARGS(ptVault, getInviteFolder, "Returns a ptVaultFolderNode of invites"),
	PYTHON_METHOD_NOARGS(ptVault, getLinkToMyNeighborhood, "Returns a ptVaultAgeLinkNode that will go to my neighborhood"),
	PYTHON_METHOD_NOARGS(ptVault, getLinkToCity, "Returns a ptVaultAgeLinkNode that will go to the city"),
	PYTHON_METHOD(ptVault, getOwnedAgeLink, "Params: ageInfo\nReturns a ptVaultAgeLinkNode to my owned age(ageInfo)"),
	PYTHON_METHOD(ptVault, getVisitAgeLink, "Params: ageInfo\nReturns a ptVaultAgeLinkNode for a visitor to age(ageInfo)"),
	PYTHON_METHOD(ptVault, findChronicleEntry, "Params: entryName\nReturns a ptVaultNode of type kNodeTypeChronicle of the current player's chronicle entry by entryName."),
	PYTHON_METHOD(ptVault, addChronicleEntry, "Params: entryName,type,string\nAdds an entry to the player's chronicle with a value of 'string'."),
	PYTHON_METHOD_NOARGS(ptVault, getGlobalInbox, "Returns a ptVaultFolderNode of the global inbox folder."),
#ifdef GlobalInboxTestCode
	PYTHON_BASIC_METHOD(ptVault, createGlobalInbox, "Creates the global inbox folder."),
#endif
	PYTHON_METHOD(ptVault, findNode, "Params: templateNode\nFind the node matching the template"),
	PYTHON_METHOD(ptVault, sendToDevice, "Params: node,deviceName\nSends a ptVaultNode object to an Age's device by deviceName."),
	PYTHON_METHOD_NOARGS(ptVault, getPsnlAgeSDL, "Returns the personal age SDL"),
	PYTHON_METHOD(ptVault, updatePsnlAgeSDL, "Params: pyrec\nUpdates the personal age SDL to the specified data"),
	PYTHON_METHOD_NOARGS(ptVault, inMyPersonalAge, "Are we in the player's personal age?"),
	PYTHON_METHOD_NOARGS(ptVault, inMyNeighborhoodAge, "Are we in the player's neighborhood age?"),
	PYTHON_METHOD_NOARGS(ptVault, amOwnerOfCurrentAge, "Are we the owner of the current age?"),
	PYTHON_METHOD_NOARGS(ptVault, amCzarOfCurrentAge, "Are we the czar (WTH is this?) of the current age?"),
	PYTHON_METHOD(ptVault, amAgeOwner, "Params: ageInfo\nAre we the owner of the specified age?"),
	PYTHON_METHOD(ptVault, amAgeCzar, "Params: ageInfo\nAre we the czar (WTH is this?) of the specified age?"),
	PYTHON_METHOD(ptVault, registerMTStation, "Params: stationName,mtSpawnPoint\nRegisters this player at the specified mass-transit point"),
	PYTHON_METHOD(ptVault, registerOwnedAge, "Params: link\nRegisters the specified age as owned by the player"),
	PYTHON_METHOD(ptVault, unRegisterOwnedAge, "Params: ageFilename\nUnregisters the specified age so it's no longer owned by this player"),
	PYTHON_METHOD(ptVault, registerVisitAge, "Params: link\nRegister this age as visitable by this player"),
	PYTHON_METHOD(ptVault, unRegisterVisitAge, "Params: guid\nUnregisters the specified age so it can no longer be visited by this player"),
	PYTHON_METHOD(ptVault, invitePlayerToAge, "Params: link,playerID\nSends an invitation to visit the age to the specified player"),
	PYTHON_METHOD(ptVault, unInvitePlayerToAge, "Params: guid,playerID\nRevokes the invitation to visit the age"),
	PYTHON_METHOD(ptVault, offerLinkToPlayer, "Params: link,playerID\nOffer a one-time link to the specified player"),
	PYTHON_BASIC_METHOD(ptVault, createNeighborhood, "Creates a new neighborhood"),
	PYTHON_METHOD(ptVault, setAgePublic, "Params: ageInfo,makePublic\nMakes the specified age public or private"),
PYTHON_END_METHODS_TABLE;

// Type structure definition
PLASMA_DEFAULT_TYPE(ptVault, "Accessor class to the player's vault");

// required functions for PyObject interoperability
PYTHON_CLASS_NEW_IMPL(ptVault, pyVault)

PYTHON_CLASS_CHECK_IMPL(ptVault, pyVault)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptVault, pyVault)

///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaClasses - the python module definitions
//
void pyVault::AddPlasmaClasses(PyObject *m)
{
	PYTHON_CLASS_IMPORT_START(m);
	PYTHON_CLASS_IMPORT(m, ptVault);
	PYTHON_CLASS_IMPORT_END(m);
}

#endif // BUILDING_PYPLASMA

void pyVault::AddPlasmaConstantsClasses(PyObject *m)
{
	PYTHON_ENUM_START(PtVaultNodeTypes);
	PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kInvalidNode,				plVault::kNodeType_Invalid);
	PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kVNodeMgrPlayerNode,		plVault::kNodeType_VNodeMgrPlayer);
	PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kVNodeMgrAgeNode,			plVault::kNodeType_VNodeMgrAge);
	PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kFolderNode,				plVault::kNodeType_Folder);
	PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kPlayerInfoNode,			plVault::kNodeType_PlayerInfo);
	PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kImageNode,				plVault::kNodeType_Image);
	PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kTextNoteNode,			plVault::kNodeType_TextNote);
	PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kSDLNode,					plVault::kNodeType_SDL);
	PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kAgeLinkNode,				plVault::kNodeType_AgeLink);
	PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kChronicleNode,			plVault::kNodeType_Chronicle);
	PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kPlayerInfoListNode,		plVault::kNodeType_PlayerInfoList);
	PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kAgeInfoNode,				plVault::kNodeType_AgeInfo);
	PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kAgeInfoListNode,			plVault::kNodeType_AgeInfoList);
	PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kMarkerGameNode,			plVault::kNodeType_MarkerGame);
	PYTHON_ENUM_END(m, PtVaultNodeTypes);

	PYTHON_ENUM_START(PtVaultStandardNodes);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kUserDefinedNode,				plVault::kUserDefinedNode);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kInboxFolder,					plVault::kInboxFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kBuddyListFolder,				plVault::kBuddyListFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kIgnoreListFolder,			plVault::kIgnoreListFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kPeopleIKnowAboutFolder,		plVault::kPeopleIKnowAboutFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kChronicleFolder,				plVault::kChronicleFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAvatarOutfitFolder,			plVault::kAvatarOutfitFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAgeTypeJournalFolder,		plVault::kAgeTypeJournalFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kSubAgesFolder,				plVault::kSubAgesFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kHoodMembersFolder,			plVault::kHoodMembersFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAllPlayersFolder,			plVault::kAllPlayersFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAllAgeGlobalSDLNodesFolder,	plVault::kAllAgeGlobalSDLNodesFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAgeMembersFolder,			plVault::kAgeMembersFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAgeJournalsFolder,			plVault::kAgeJournalsFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAgeInstanceSDLNode,			plVault::kAgeInstanceSDLNode);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kCanVisitFolder,				plVault::kCanVisitFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAgeOwnersFolder,				plVault::kAgeOwnersFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kPlayerInfoNode,				plVault::kPlayerInfoNode);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kPublicAgesFolder,			plVault::kPublicAgesFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAgesIOwnFolder,				plVault::kAgesIOwnFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAgesICanVisitFolder,			plVault::kAgesICanVisitFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAvatarClosetFolder,			plVault::kAvatarClosetFolder);
	PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kGlobalInboxFolder,			plVault::kGlobalInboxFolder);
	PYTHON_ENUM_END(m, PtVaultStandardNodes);

	PYTHON_ENUM_START(PtVaultTextNoteTypes);
	PYTHON_ENUM_ELEMENT(PtVaultTextNoteTypes, kGeneric,		plVault::kNoteType_Generic);
	PYTHON_ENUM_ELEMENT(PtVaultTextNoteTypes, kCCRPetition,	plVault::kNoteType_CCRPetition);
	PYTHON_ENUM_END(m, PtVaultTextNoteTypes);
	
	PYTHON_ENUM_START(PtVaultTextNoteSubTypes);
	PYTHON_ENUM_ELEMENT(PtVaultTextNoteSubTypes, kGeneric, plVault::kNoteSubType_Generic);
	PYTHON_ENUM_END(m, PtVaultTextNoteSubTypes);

	PYTHON_ENUM_START(PtVaultCallbackTypes);
	PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultConnected,			pyVault::kVaultConnected);
	PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultNodeSaved,			pyVault::kVaultNodeSaved);
	PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultNodeRefAdded,		pyVault::kVaultNodeRefAdded);
	PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultRemovingNodeRef,	pyVault::kVaultRemovingNodeRef);
	PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultNodeRefRemoved,		pyVault::kVaultNodeRefRemoved);
	PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultNodeInitialized,	pyVault::kVaultNodeInitialized);
	PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultOperationFailed,	pyVault::kVaultOperationFailed);
	PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultNodeAdded,			pyVault::kVaultNodeAdded);
	PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultDisconnected,		pyVault::kVaultDisconnected);
	PYTHON_ENUM_END(m, PtVaultCallbackTypes);

	PYTHON_ENUM_START(PtVaultNotifyTypes);
	PYTHON_ENUM_ELEMENT(PtVaultNotifyTypes, kRegisteredOwnedAge, plVaultNotifyMsg::kRegisteredOwnedAge);
	PYTHON_ENUM_ELEMENT(PtVaultNotifyTypes, kRegisteredVisitAge, plVaultNotifyMsg::kRegisteredVisitAge);
	PYTHON_ENUM_ELEMENT(PtVaultNotifyTypes, kUnRegisteredOwnedAge, plVaultNotifyMsg::kUnRegisteredOwnedAge);
	PYTHON_ENUM_ELEMENT(PtVaultNotifyTypes, kUnRegisteredVisitAge, plVaultNotifyMsg::kUnRegisteredVisitAge);
	PYTHON_ENUM_ELEMENT(PtVaultNotifyTypes, kPublicAgeCreated, plVaultNotifyMsg::kPublicAgeCreated);
	PYTHON_ENUM_ELEMENT(PtVaultNotifyTypes, kPublicAgeRemoved, plVaultNotifyMsg::kPublicAgeRemoved);
	PYTHON_ENUM_END(m, PtVaultNotifyTypes);
}