#include "QuickDirtyXMLParser.h"
#include <stdio.h>
QuickDirtyXMLParser::QuickDirtyXMLParser() {

}
string trim(const string & str) {
	string out();
	int size = str.size();
	int eindex = size;
	int sindex = 0;
	for (int i = size-1 ; i >= 0; i-- ) {
		if (str[i] == ' ' || str[i] == '\t' || str[i] == '\n' || str[i]=='\r') {
			eindex--;
		} else {
			break;
		}
	}
	for (int i = 0; i < size; i++ ) {
		if (str[i] == ' ' || str[i] == '\t' || str[i] == '\n' || str[i]=='\r') {
			sindex++; // = i;	
		} else {
			break;
		}
	
	}
	if (eindex==sindex || eindex < sindex) {
		return "";
	}
	return str.substr(sindex,eindex-(sindex));
}
bool matches(string & tag,string & in, int start,int tagsize,int insize) {
	if (start+tagsize > insize) {
		return false;
	}
	for (int i = 0; i < tagsize ; i++ ) {
		if (!(in[start + i] == tag[i])) {
			return false;
		}
	}
	return true;
}

//Also have to deal with Upper Level Stuff
//<COMPOUND><COMPOUND/><COMPOUND/><SCALAR></COMPOUND>
//Alg:
//	first name we find quickly find next occurance. Parse inbetween, set
//	value or recurse. Then back to top level add to childlist carry on to
//	next and do the same thing

void parseXML(TreeNode * parentNode,string & xml, int current, int end) {
	bool hasXML = false;
	for (int i = current; i < end; i++) { //if current >  end then we will have a scalar
		if (xml[i] == '<' || xml[i] == '>') {
			hasXML = true;
			break;
		}
	}
	if (!hasXML) { // SCALAR
		int size = end - current;
		if (size < 0) { 
			parentNode->value = "";
		} else {
			parentNode->value = trim(xml.substr(current,end-current)); //It's SCALAR we are done!
		}
		return;
	}
	vector<TreeNode *> * children = new vector<TreeNode*>();
	string ttag = ""; //We don't quite moving til we reach the other tag end
	bool readingTag = false; //Are we inside < >
	bool parent     = false;
	bool startTag   = false; //Are we reading a startTag?
	bool endTag     = false;
	int tagStart = 0;
	int tagEnd = 0;
	int contentStart = 0;
	int contentEnd = 0;
	for (int i = current ; i < end; i++) {
		switch (xml[i]) {
			case '<': {
				readingTag = true; //start reading tag
				contentEnd = i-1;
				break;
			};
			case '>': {
				readingTag = false; //we're done reading the tag
				if (startTag) {
					tagEnd = i - 1;
					contentStart = i + 1; //this spot is start of content
					ttag = xml.substr(tagStart,tagEnd-tagStart+1); //remember the tag;
					parent = true;	//we are now in parent mode
					startTag = false;
				} else if (endTag) {
					tagEnd = i - 1;
					if (ttag == xml.substr(tagStart,tagEnd-tagStart+1)) {
						parent = false;
						//Now everything between contentStart
						//and contentEnd is stuff we want to
						//parse
						TreeNode * node = new TreeNode(ttag,"");
						parseXML(node,xml,contentStart,contentEnd+1);
						children->push_back(node);
						endTag = false;
					} else {
						endTag = false;
						//it was inside
					}
				} else {
					//intermediate tag, just ignore
				}
				break;
			};
			case '/':  {
				if (readingTag) { //</
					if (startTag) {
						tagEnd = i-1;
						startTag = false;
						parent = false;
						children->push_back(new TreeNode(xml.substr(tagStart,tagEnd-tagStart+1),""));
						//singleton! <stuff/>
					} else {
						tagStart = i+1;
						endTag  = true;
						//we'ved started to read an end tag  "stuff</_"
					}
				}
				break;
			}; 
			default: {
				if (readingTag && !parent) {
					parent = true;
					startTag = true;
					tagStart = i;
				}
			};
		}
	}
	if (parentNode->children!=NULL) {
		parentNode->clearChildren();
		delete parentNode->children;
	}
	parentNode->children = children;
}
TreeNode * QuickDirtyXMLParser::parseString(string & xml) {
	TreeNode * root = new TreeNode("root","");
	parseXML(root,xml,0,xml.size());
	return root;
}
/*
 *	<top>
 *		<inner1><inner12>inner12</inner12></inner1>
 *		<inner2><inner22/></inner2>
 *		<inner3>
 *			<inner32/>
 *			<inner33>
 *				<inner34>inner34</inner34>
 *			</inner33>
 *		</inner3>
 *	</top>
 *	Should get
 *	(top,"")
 *		(inner1,"")
 *			(inner12,"inner12")
 *		(inner2,"")
 *			(inner22,"")
 *		(inner3,"")
 *			(inner32,"") (inner33,"")
 *					(inner34,"inner34")
 * */

string * traverseTree(TreeNode * node) {
	if (node == NULL) {
		return new string("");
	}
	string * work = new string(node->getValue());
	vector<TreeNode*> * children = node->getChildren();
	if (children!=NULL) {
		vector<TreeNode*>::iterator iter;
		for (iter = children->begin(); iter < children->end(); iter++) {
			string * result = traverseTree(*iter);
			(*work) += (*result);
			delete result; //is this the right place to do it?
		}
	}
	return work;
}
int mainTest() {
	string xml []  = {string("<top> <inner1><inner12>inner12 </inner12></inner1> <inner2><inner22/></inner2> <inner3> <inner32/> <inner33> <inner34>inner34</inner34> </inner33> </inner3> </top>"),
	string("<top> <inner1>  <inner12>  inner12 </inner12></inner1> <inner2><inner22/></inner2> <inner3> <inner32/> <inner33> <inner34>   inner34   </inner34> </inner33> </inner3> </top>"),
	string("<top> <inner1>  <inner12>inner12</inner12></inner1> <inner2><inner22/></inner2> <inner3> <inner32/> <inner33> <inner34>inner34</inner34> </inner33> </inner3> <inner4></inner4><inner5/></top>")
	};
	string expect = "inner12inner34";
	string work = "";
	QuickDirtyXMLParser p = QuickDirtyXMLParser();
	for (int i = 0 ; i < 3; i++) {
		TreeNode * node = p.parseString(xml[i]);
		work = *traverseTree(node);
		if (expect == work) {
			cout << "Excellent Test "<< (1+i) <<" Worked Fine\n";	
		} else {
			cout << "Test Failed! expected[" << expect << "] received [" << work << "]\n";
		}
		try {
			string value = node->getChild("top")->getChild("inner1")->getChild("inner12")->getValue();
			if (value == "inner12") {
				cout << "Test Succeeded!\n";
			} else {
				cout << "Test Failed inner12 != " << value << " !\n";
			}
		} catch (string * err) {
			cout << "Test Failed! top inner1 inner12 not found!\n";
		}
		try {
			string value = node->getChild("top")->getChild("inner1")->getChild("inner13")->getValue();
			cout << "Test Failed inner13 found!\n";
		} catch (string * err) {
			cout << "Test Succeeded! inner13 not found [this is good]!\n";
		}
	}
	return 0;
}