// ---------------------------------------------------------------------------
//  Includes for all the program files to see
// ---------------------------------------------------------------------------
#include <string.h>
#include <stdlib.h>
#include <iostream>
//#include <ext/algorithm>

using namespace std;
#include <xercesc/util/PlatformUtils.hpp>

// ---------------------------------------------------------------------------
//  Includes
// ---------------------------------------------------------------------------

#include <xercesc/framework/StdInInputSource.hpp>
#include <xercesc/parsers/SAXParser.hpp>
#include <xercesc/util/OutOfMemoryException.hpp>

// ---------------------------------------------------------------------------
//  Includes
// ---------------------------------------------------------------------------

#include <xercesc/sax/AttributeList.hpp>
#include <xercesc/sax/SAXParseException.hpp>
#include <xercesc/sax/SAXException.hpp>

#include "ObjectsParser.h"

#include "ObjectsParserXerces.h"
#include "Mesh.h"
#include "ViewCellsManager.h"
#include "GzFileInputSource.h"
#include "BvHierarchy.h"


namespace GtpVisibilityPreprocessor {


// ---------------------------------------------------------------------------
//  Local data
//
//  doNamespaces
//      Indicates whether namespace processing should be enabled or not.
//      The default is no, but -n overrides that.
//
//  doSchema
//      Indicates whether schema processing should be enabled or not.
//      The default is no, but -s overrides that.
//
//  schemaFullChecking
//      Indicates whether full schema constraint checking should be enabled or not.
//      The default is no, but -s overrides that.
//
//  valScheme
//      Indicates what validation scheme to use. It defaults to 'auto', but
//      can be set via the -v= command.
// ---------------------------------------------------------------------------

static bool     doNamespaces       = false;
static bool     doSchema           = false;
static bool     schemaFullChecking = false;
static SAXParser::ValSchemes    valScheme       = SAXParser::Val_Auto;


inline static bool ilt(Intersectable *obj1, Intersectable *obj2)
{
	return obj1->mId < obj2->mId;
}


// ---------------------------------------------------------------------------
//  StdInParseHandlers: Constructors and Destructor
// ---------------------------------------------------------------------------

ObjectsParseHandlers::ObjectsParseHandlers(ObjectContainer &pvsObjects, 
										   const ObjectContainer &preprocessorObjects
										   ):
  mElementCount(0)
  , mAttrCount(0)
  , mCharacterCount(0)
  , mSpaceCount(0)
  , mPvsObjects(pvsObjects)
  , mPreprocessorObjects(preprocessorObjects)
  , mIsObjectSpaceHierarchy(false)
{
}


ObjectsParseHandlers::~ObjectsParseHandlers()
{
}


// ---------------------------------------------------------------------------
//  StdInParseHandlers: Implementation of the SAX DocumentHandler interface
// ---------------------------------------------------------------------------


void ObjectsParseHandlers::endElement(const XMLCh* const name)
{
	StrX lname(name);
	string element(lname.LocalForm());

	if (element == "ObjectSpaceHierarchy")
	{
		EndObjectSpaceHierarchy();
	}
}


void ObjectsParseHandlers::EndObjectSpaceHierarchy()
{
	mIsObjectSpaceHierarchy = false;
}


inline static bool vlt(ViewCell *v1, ViewCell *v2)
{
	return v1->mId < v2->mId;
}


void ObjectsParseHandlers::StartBvhElement(string element,
										   AttributeList& attributes)
{
	if (element == "Leaf") 
	{
		StartBvhLeaf(attributes);
	}
}


void ObjectsParseHandlers::StartObjectSpaceHierarchyElement(const std::string &element,
															AttributeList& attributes)
{
	//-- use cell type according to the chosen method
	StartBvhElement(element, attributes);
}


void ObjectsParseHandlers::startElement(const XMLCh* const name,
										AttributeList& attributes)
{
	StrX lname(name);
	string element(lname.LocalForm());

	// decides about the view cell hierarchy
	if (element == "ObjectSpaceHierarchy")
	{
		cout << "\nparsing object space hierarchy" << endl;
		Debug << "\nparsing object space hierarchy" << endl;

		mIsObjectSpaceHierarchy = true;
	}
	
	// parse view space hierarchy
	if (mIsObjectSpaceHierarchy)
	{
		StartObjectSpaceHierarchyElement(element, attributes);
	}

	++ mElementCount;
	mAttrCount += attributes.getLength();
}



void ObjectsParseHandlers::characters(const XMLCh* const chars,
										const unsigned int length)
{
	mCharacterCount += length;
}


void ObjectsParseHandlers::ignorableWhitespace(const XMLCh* const chars,
												 const unsigned int length)
{
	mSpaceCount += length;
}


void ObjectsParseHandlers::resetDocument()
{
	mAttrCount = 0;
	mCharacterCount = 0;
	mElementCount = 0;
	mSpaceCount = 0;
}


void ObjectsParseHandlers::StartBvhLeaf(AttributeList& attributes)
{
	const int len = attributes.getLength();
	Vector3 minBox, maxBox;

	ObjectContainer objects;

	for (int i = 0; i < len; ++ i) 
	{
		string attrName(StrX(attributes.getName(i)).LocalForm());
		StrX attrValue(attributes.getValue(i));
		const char *ptr = attrValue.LocalForm();

		if (attrName == "min") 
		{
			sscanf(ptr, "%f %f %f", &minBox.x, &minBox.y, &minBox.z);
		}
		if (attrName == "max") 
		{
			sscanf(ptr, "%f %f %f", &maxBox.x, &maxBox.y, &maxBox.z);
		}
		if (attrName == "objects")
		{
			StartBvhLeafObjects(objects, ptr);
		}
	}

	AxisAlignedBox3 box = AxisAlignedBox3(minBox, maxBox);

	BvhLeaf *leaf = new BvhLeaf(box, NULL, (int)objects.size());

	leaf->mObjects = objects;
	BvHierarchy::AssociateObjectsWithLeaf(leaf);

	// new pvs object
	mPvsObjects.push_back(leaf);
}


void ObjectsParseHandlers::StartBvhLeafObjects(ObjectContainer &objects,
											   const char *ptr)
{
	vector<int> objIndices;
	char *endptr;
			
	while (1)
	{
		const int index = strtol(ptr, &endptr, 10);
		if (ptr == endptr) break;

		objIndices.push_back(index);
		ptr = endptr;
	}

	MeshInstance dummyInst(NULL);

	vector<int>::const_iterator it, it_end = objIndices.end();

	for (it = objIndices.begin(); it != it_end; ++ it)
	{
		const int objId = *it;	

#if 0
		// assume there is is no id missing
		objects.push_back(mPreprocessorObjects[objId]);
#else
		dummyInst.SetId(objId);

		ObjectContainer::const_iterator oit =
			lower_bound(mPreprocessorObjects.begin(), 
						mPreprocessorObjects.end(), 
						(Intersectable *)&dummyInst, 
						ilt);	
							
		if ((oit != mPreprocessorObjects.end()) && ((*oit)->GetId() == objId))
		{
			objects.push_back(*oit);
		}
#endif
	}
}



// ---------------------------------------------------------------------------
//  StdInParseHandlers: Overrides of the SAX ErrorHandler interface
// ---------------------------------------------------------------------------


void
ObjectsParseHandlers::error(const SAXParseException& e)
{
  XERCES_STD_QUALIFIER cerr << "\nError at (file " << StrX(e.getSystemId())
			    << ", line " << e.getLineNumber()
			    << ", char " << e.getColumnNumber()
			    << "): " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}

void
ObjectsParseHandlers::fatalError(const SAXParseException& e)
{
  XERCES_STD_QUALIFIER cerr << "\nFatal Error at (file " << StrX(e.getSystemId())
			    << ", line " << e.getLineNumber()
			    << ", char " << e.getColumnNumber()
			    << "): " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}

void
ObjectsParseHandlers::warning(const SAXParseException& e)
{
  XERCES_STD_QUALIFIER cerr << "\nWarning at (file " << StrX(e.getSystemId())
			    << ", line " << e.getLineNumber()
			    << ", char " << e.getColumnNumber()
			    << "): " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}


bool ObjectsParser::ParseObjects(const string &filename, 
								 ObjectContainer &pvsObjects,
								 const ObjectContainer &preprocessorObjects)
{
	// Initialize the XML4C system
	try {
		XMLPlatformUtils::Initialize();
	}

	catch (const XMLException& toCatch)
	{
		XERCES_STD_QUALIFIER cerr << "Error during initialization! Message:\n"
			<< StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
		return false;
	}

	//  cout<<"parsing started"<<endl<<flush;

	//
	//  Create a SAX parser object. Then, according to what we were told on
	//  the command line, set the options.
	//
	SAXParser* parser = new SAXParser;
	parser->setValidationScheme(valScheme);
	parser->setDoNamespaces(doNamespaces);
	parser->setDoSchema(doSchema);
	parser->setValidationSchemaFullChecking(schemaFullChecking);


	//
	//  Create our SAX handler object and install it on the parser, as the
	//  document and error handler. We are responsible for cleaning them
	//  up, but since its just stack based here, there's nothing special
	//  to do.
	//
	ObjectsParseHandlers handler(pvsObjects, preprocessorObjects);
	parser->setDocumentHandler(&handler);
	parser->setErrorHandler(&handler);

	unsigned long duration;
	int errorCount = 0;
	// create a faux scope so that 'src' destructor is called before
	// XMLPlatformUtils::Terminate
	{
		//
		//  Kick off the parse and catch any exceptions. Create a standard
		//  input input source and tell the parser to parse from that.
		//
		//    StdInInputSource src;
		try
		{
			const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();

#if USE_GZLIB
			XMLCh *myFilePath = XMLString::transcode(filename.c_str());

			GzFileInputSource isource(myFilePath);
			parser->parse(isource);
#else
			parser->parse(filename.c_str());

#endif

			const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
			duration = endMillis - startMillis;
			errorCount = parser->getErrorCount();
		}
		catch (const OutOfMemoryException&)
		{
			XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
			errorCount = 2;
			return false;
		}
		catch (const XMLException& e)
		{
			XERCES_STD_QUALIFIER cerr << "\nError during parsing: \n"
				<< StrX(e.getMessage())
				<< "\n" << XERCES_STD_QUALIFIER endl;
			errorCount = 1;
			return false;
		}


		// Print out the stats that we collected and time taken
		if (!errorCount) 
		{
			XERCES_STD_QUALIFIER cerr << filename << ": " << duration << " ms ("
				<< handler.GetElementCount() << " elems, "
				<< handler.GetAttrCount() << " attrs, "
				<< handler.GetSpaceCount() << " spaces, "
				<< handler.GetCharacterCount() << " chars)" << XERCES_STD_QUALIFIER endl;
		}
	}

	cout << "parsed - will delete the parser" << endl << flush;
	//
	//  Delete the parser itself.  Must be done prior to calling Terminate, below.
	//
	delete parser;

	XMLPlatformUtils::Terminate();

	//-- assign new view cells manager
	//*viewCells = handler.mViewCellsManager;

	if (errorCount > 0)
		return false;
	else
		return true;
}

}