/** 
 * @file llxmltree.h
 * @author Aaron Yonas, Richard Nelson
 * @brief LLXmlTree class definition
 *
 * $LicenseInfo:firstyear=2001&license=viewergpl$
 * 
 * Copyright (c) 2001-2010, Linden Research, Inc.
 * 
 * Second Life Viewer Source Code
 * The source code in this file ("Source Code") is provided by Linden Lab
 * to you under the terms of the GNU General Public License, version 2.0
 * ("GPL"), unless you have obtained a separate licensing agreement
 * ("Other License"), formally executed by you and Linden Lab.  Terms of
 * the GPL can be found in doc/GPL-license.txt in this distribution, or
 * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
 * 
 * There are special exceptions to the terms and conditions of the GPL as
 * it is applied to this Source Code. View the full text of the exception
 * in the file doc/FLOSS-exception.txt in this software distribution, or
 * online at
 * http://secondlifegrid.net/programs/open_source/licensing/flossexception
 * 
 * By copying, modifying or distributing this software, you acknowledge
 * that you have read and understood your obligations described above,
 * and agree to abide by those obligations.
 * 
 * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
 * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
 * COMPLETENESS OR PERFORMANCE.
 * $/LicenseInfo$
 */

#ifndef LL_LLXMLTREE_H
#define LL_LLXMLTREE_H

#include <map>
#include <list>
#include "llstring.h"
#include "llxmlparser.h"
#include "string_table.h"

class LLColor4;
class LLColor4U;
class LLQuaternion;
class LLUUID;
class LLVector3;
class LLVector3d;
class LLXmlTreeNode;
class LLXmlTreeParser;

//////////////////////////////////////////////////////////////
// LLXmlTree

class LLXmlTree
{
	friend class LLXmlTreeNode;
	
public:
	LLXmlTree();
	virtual ~LLXmlTree();
	void cleanup();

	virtual BOOL	parseFile(const std::string &path, BOOL keep_contents = TRUE);

	bool parseBufferStart(bool keep_contents = true);
	bool parseBuffer(const char *buf, int len);
	bool parseBufferFinalize();

	LLXmlTreeNode*	getRoot() { return mRoot; }

	void			dump();
	void			dumpNode( LLXmlTreeNode* node, const std::string& prefix );

	void write(std::string &buffer) const;
	void writeNode(LLXmlTreeNode *node, std::string &buffer, const std::string &indent) const;

	static LLStdStringHandle addAttributeString( const std::string& name)
	{
		return sAttributeKeys.addString( name );
	}
	
public:
	// global
	static LLStdStringTable sAttributeKeys;
	
protected:
	LLXmlTreeNode* mRoot;
	LLXmlTreeParser *mParser;

	// local
	LLStdStringTable mNodeNames;	
};

//////////////////////////////////////////////////////////////
// LLXmlTreeNode

class LLXmlTreeNode
{
	friend class LLXmlTree;
	friend class LLXmlTreeParser;

protected:
	// Protected since nodes are only created and destroyed by friend classes and other LLXmlTreeNodes
	LLXmlTreeNode( const std::string& name, LLXmlTreeNode* parent, LLXmlTree* tree );
	
public:
	virtual ~LLXmlTreeNode();

	const std::string&	getName()
	{
		return mName;
	}
	BOOL hasName( const std::string& name )
	{
		return mName == name;
	}

	BOOL hasAttribute( const std::string& name );

	// Fast versions use cannonical_name handlee to entru in LLXmlTree::sAttributeKeys string table
	BOOL			getFastAttributeBOOL(		LLStdStringHandle cannonical_name, BOOL& value );
	BOOL			getFastAttributeU8(			LLStdStringHandle cannonical_name, U8& value );
	BOOL			getFastAttributeS8(			LLStdStringHandle cannonical_name, S8& value );
	BOOL			getFastAttributeU16(		LLStdStringHandle cannonical_name, U16& value );
	BOOL			getFastAttributeS16(		LLStdStringHandle cannonical_name, S16& value );
	BOOL			getFastAttributeU32(		LLStdStringHandle cannonical_name, U32& value );
	BOOL			getFastAttributeS32(		LLStdStringHandle cannonical_name, S32& value );
	BOOL			getFastAttributeF32(		LLStdStringHandle cannonical_name, F32& value );
	BOOL			getFastAttributeF64(		LLStdStringHandle cannonical_name, F64& value );
	BOOL			getFastAttributeColor(		LLStdStringHandle cannonical_name, LLColor4& value );
	BOOL			getFastAttributeColor4(		LLStdStringHandle cannonical_name, LLColor4& value );
	BOOL			getFastAttributeColor4U(	LLStdStringHandle cannonical_name, LLColor4U& value );
	BOOL			getFastAttributeVector3(	LLStdStringHandle cannonical_name, LLVector3& value );
	BOOL			getFastAttributeVector3d(	LLStdStringHandle cannonical_name, LLVector3d& value );
	BOOL			getFastAttributeQuat(		LLStdStringHandle cannonical_name, LLQuaternion& value );
	BOOL			getFastAttributeUUID(		LLStdStringHandle cannonical_name, LLUUID& value );
	BOOL			getFastAttributeString(		LLStdStringHandle cannonical_name, std::string& value );

	// Normal versions find 'name' in LLXmlTree::sAttributeKeys then call fast versions
	virtual BOOL		getAttributeBOOL(		const std::string& name, BOOL& value );
	virtual BOOL		getAttributeU8(			const std::string& name, U8& value );
	virtual BOOL		getAttributeS8(			const std::string& name, S8& value );
	virtual BOOL		getAttributeU16(		const std::string& name, U16& value );
	virtual BOOL		getAttributeS16(		const std::string& name, S16& value );
	virtual BOOL		getAttributeU32(		const std::string& name, U32& value );
	virtual BOOL		getAttributeS32(		const std::string& name, S32& value );
	virtual BOOL		getAttributeF32(		const std::string& name, F32& value );
	virtual BOOL		getAttributeF64(		const std::string& name, F64& value );
	virtual BOOL		getAttributeColor(		const std::string& name, LLColor4& value );
	virtual BOOL		getAttributeColor4(		const std::string& name, LLColor4& value );
	virtual BOOL		getAttributeColor4U(	const std::string& name, LLColor4U& value );
	virtual BOOL		getAttributeVector3(	const std::string& name, LLVector3& value );
	virtual BOOL		getAttributeVector3d(	const std::string& name, LLVector3d& value );
	virtual BOOL		getAttributeQuat(		const std::string& name, LLQuaternion& value );
	virtual BOOL		getAttributeUUID(		const std::string& name, LLUUID& value );
	virtual BOOL		getAttributeString(		const std::string& name, std::string& value );

	const std::string& getContents()
	{
		return mContents;
	}
	std::string getTextContents();

	LLXmlTreeNode*	getParent()							{ return mParent; }
	LLXmlTreeNode*	getFirstChild();
	LLXmlTreeNode*	getNextChild();
	S32				getChildCount()						{ return (S32)mChildList.size(); }
	LLXmlTreeNode*  getChildByName( const std::string& name );	// returns first child with name, NULL if none
	LLXmlTreeNode*  getNextNamedChild();				// returns next child with name, NULL if none

protected:
	const std::string* getAttribute( LLStdStringHandle name)
	{
		attribute_map_t::iterator iter = mAttributes.find(name);
		return (iter == mAttributes.end()) ? 0 : iter->second;
	}

private:
	void			addAttribute( const std::string& name, const std::string& value );
	void			appendContents( const std::string& str );
	void			addChild( LLXmlTreeNode* child );

	void			dump( const std::string& prefix );

	void writeNoChild(std::string &buffer, const std::string &indent) const;
	void writeStart(std::string &buffer, const std::string &indent) const;
	void writeEnd(std::string &buffer, const std::string &indent) const;
	void writeAttributes(std::string &buffer) const;

protected:
	typedef std::map<LLStdStringHandle, const std::string*> attribute_map_t;
	attribute_map_t						mAttributes;

private:
	std::string							mName;
	std::string							mContents;
	
	typedef std::list<class LLXmlTreeNode *> child_list_t;
	child_list_t						mChildList;
	child_list_t::iterator				mChildListIter;
	
	typedef std::multimap<LLStdStringHandle, LLXmlTreeNode *> child_map_t;
	child_map_t							mChildMap;		// for fast name lookups
	child_map_t::iterator				mChildMapIter;
	child_map_t::iterator				mChildMapEndIter;

	LLXmlTreeNode*						mParent;
	LLXmlTree*							mTree;
};

//////////////////////////////////////////////////////////////
// LLXmlTreeParser

class LLXmlTreeParser : public LLXmlParser
{
public:
	LLXmlTreeParser(LLXmlTree* tree);
	virtual ~LLXmlTreeParser();

	BOOL parseFile(const std::string &path, LLXmlTreeNode** root, BOOL keep_contents );

	void parseBufferStart(BOOL keep_contents);
	bool parseBuffer(const char *buf, int len);
	bool parseBufferFinalize(LLXmlTreeNode** root);

protected:
	const std::string& tabs();

	// Overrides from LLXmlParser
	virtual void	startElement(const char *name, const char **attributes); 
	virtual void	endElement(const char *name);
	virtual void	characterData(const char *s, int len);
	virtual void	processingInstruction(const char *target, const char *data);
	virtual void	comment(const char *data);
	virtual void	startCdataSection();
	virtual void	endCdataSection();
	virtual void	defaultData(const char *s, int len);
	virtual void	unparsedEntityDecl(
		const char* entity_name,
		const char* base,
		const char* system_id,
		const char* public_id,
		const char* notation_name);

	//template method pattern
	virtual LLXmlTreeNode* CreateXmlTreeNode(const std::string& name, LLXmlTreeNode* parent);

protected:
	LLXmlTree*		mTree;
	LLXmlTreeNode*	mRoot;
	LLXmlTreeNode*  mCurrent;
	BOOL			mDump;	// Dump parse tree to llinfos as it is read.
	BOOL			mKeepContents;
};

#endif  // LL_LLXMLTREE_H