#include "DataBoardRepository.h"

#include "RecordType.h"
#include "ArrayType.h"
#include "Constants.h"
#include "Component.h"
#include "IntegerType.h"
#include "DataType.h"
#include "StringType.h"
#include "DoubleType.h"
#include "LongType.h"
#include "ByteType.h"
#include "BooleanType.h"
#include "MapType.h"
#include "OptionalType.h"
#include "UnionType.h"
#include "VariantType.h"
#include "Range.h"
#include "Limit.h"

#include <iostream>
#include <sstream>

namespace Databoard {
	namespace Type {

		std::string strTypeDefinition::writeOut()
		{
			std::string r;
			
			r += "type " + name + " = ";

			r += dataBoard->writeOut();

			return r;
		}

		DataBoardRepository::DataBoardRepository()
		{
		}

		DataBoardRepository::~DataBoardRepository()
		{
			for(int i = 0; i < (int)dataBoards.size(); ++i)
			{
				delete dataBoards.at(i).dataBoard;
			}

			dataBoards.clear();
		}

		void DataBoardRepository::addDataBoard(char* name, DataType* dataBoard)
		{
			strTypeDefinition dataBoard_;

			dataBoard_.name = std::string(name);
			dataBoard_.dataBoard = dataBoard;

			dataBoards.push_back(dataBoard_);
		}

		int DataBoardRepository::count()
		{
			return (int)dataBoards.size();
		}

		strTypeDefinition DataBoardRepository::getDataBoard(int i)
		{
			return dataBoards.at(i);
		}

		DataType* DataBoardRepository::getDataBoard(std::string name)
		{
			for(int i = 0; i < (int)dataBoards.size(); ++i)
			{
				if(dataBoards.at(i).name == name)
				{
					return dataBoards.at(i).dataBoard;
				}
			}

			return NULL;
		}

		bool DataBoardRepository::open(std::string fileName)
		{
			pANTLR3_INPUT_STREAM input = antlr3AsciiFileStreamNew((pANTLR3_UINT8)fileName.c_str());

			if ( input == NULL )
			{
				ANTLR3_FPRINTF(stderr, "string: %s\n", fileName.c_str());

				return false;
			}

			pSimanticsDataLexer lexer = SimanticsDataLexerNew(input);

			if ( lexer == NULL )
			{
				ANTLR3_FPRINTF(stderr, "Unable to create the lexer due to malloc() failure1\n");
				//exit(ANTLR3_ERR_NOMEM);

				return false;
			}

			pANTLR3_COMMON_TOKEN_STREAM tstream = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lexer));//->pLexer->tokSource);

			if (tstream == NULL)
			{
				ANTLR3_FPRINTF(stderr, "Out of memory trying to allocate token stream\n");
				//exit(ANTLR3_ERR_NOMEM);

				return false;
			}

			pSimanticsDataParser parser = SimanticsDataParserNew(tstream); // CParserNew is generated by ANTLR3

			if (parser == NULL)
			{
				ANTLR3_FPRINTF(stderr, "Out of memory trying to allocate parser\n");
				//exit(ANTLR3_ERR_NOMEM);

				return false;
			}

			SimanticsDataParser_typeDefinitions_return astType = parser->typeDefinitions(parser);

			bool retValue = true;

			if(lexer->pLexer->rec->state->errorCount == 0)
			{
				temporaryname t(this);

				t.parse(astType.tree);
			
				//print(astType.tree);
			}
			else
			{
				retValue = false;
			}


			parser->free(parser);
			tstream->free(tstream);
			lexer->free(lexer);
			input->free(input);

			return retValue;
		}

		void DataBoardRepository::print(pANTLR3_BASE_TREE tree, int indent)
		{
			for(int i=0;i<indent;++i)
				std::cout << "  ";

			std::cout << tree->getText(tree)->chars << " " << 
				tree->getType(tree) << std::endl;

			for(int i=0;i<(int)tree->getChildCount(tree);++i)
			{
				print((pANTLR3_BASE_TREE)tree->getChild(tree, i), indent + 1);
			}
		}

		const strTypeDefinition* DataBoardRepository::get(std::string name)
		{
			for(int i = 0; i < (int)dataBoards.size(); ++i)
			{
				const strTypeDefinition& dataBoard = dataBoards.at(i); // for debug purposes

				if(dataBoard.name == name)
				{
					return &dataBoard;
				}
			}

			return NULL;
		}

		///////////////////////////////////////////////

		temporaryname::temporaryname(DataBoardRepository* dataBoardRepository)
		{
			this->dataBoardRepository = dataBoardRepository;
		}

		temporaryname::~temporaryname()
		{
		}

		DataType* temporaryname::parse(pANTLR3_BASE_TREE tree, DataType* parent, int indent)
		//DataType* DataBoardRepository::parse(pANTLR3_BASE_TREE tree, DataType* parent, int indent)
		//DataType* parse(pANTLR3_BASE_TREE tree, DataType* parent, int indent)
		{
			switch(tree->getType(tree)) {
				case TYPE_DEFINITIONS:
					{
						for(int i=0;i<(int)tree->getChildCount(tree);++i)
						{
							parse((pANTLR3_BASE_TREE)tree->getChild(tree, i), parent, indent + 1);
						}
					}
					break;
				case TYPE_DEFINITION:
					{
						if(tree->getChildCount(tree) == 2)
						{
							pANTLR3_BASE_TREE id = (pANTLR3_BASE_TREE)tree->getChild(tree, 0);
							pANTLR3_BASE_TREE type = (pANTLR3_BASE_TREE)tree->getChild(tree, 1);

							DataType* dataBoard = parse(type, parent, indent+1);

							if(dataBoard != NULL)
							{
								dataBoard->setNotBuiltIn();

								if(dataBoardRepository != NULL)
								{
									dataBoardRepository->addDataBoard((char*)id->getText(id)->chars, dataBoard);
								}
							}
						}
					}
					break;
				case TUPLE_TYPE:
					{
						RecordType* record = new RecordType();

						for(int i=0;i<(int)tree->getChildCount(tree);++i)
						{
							DataType* childType = parse((pANTLR3_BASE_TREE)tree->getChild(tree, i), record, indent + 1);

							if(childType != NULL)
							{
								std::stringstream ss;

								ss << i;

								std::string tupleId;

								ss >> tupleId;

								addToChildren(record, (char*)tupleId.c_str(), childType);
							}
						}

						return record;
					}

					break;

				case RECORD_TYPE:
					{
						RecordType* record = new RecordType();

						for(int i=0;i<(int)tree->getChildCount(tree);++i)
						{
							DataType* childType = parse((pANTLR3_BASE_TREE)tree->getChild(tree, i), record, indent + 1);
						}

						return record;
					}

					break;
				case ARRAY_TYPE:
					{
						ArrayType* arrayType = new ArrayType();

						int childCount = tree->getChildCount(tree);

						if(childCount >= 1)
						{
							DataType* dataType = parse((pANTLR3_BASE_TREE)tree->getChild(tree, 0), parent);

							arrayType->setComponentType(dataType);
							
							if(childCount >= 2)
							{
								Range* range = parseRange(tree, 1, childCount);

								arrayType->setLength(range);
							}
						}

						return arrayType;
					}

					break;

				case UNION_TYPE:
					{
						UnionType* unionType = new UnionType();

						int childCount = tree->getChildCount(tree);

						for(int i=0;i<(int)tree->getChildCount(tree);++i)
						{
							pANTLR3_BASE_TREE p = (pANTLR3_BASE_TREE)tree->getChild(tree, i);

							if(p->getChildCount(p) == 1)
							{
								pANTLR3_BASE_TREE t = (pANTLR3_BASE_TREE)p->getChild(p, 0);
								
								std::string dataTypeName((char*)t->getText(t)->chars);

								DataType* dataType = NULL;

								if(dataBoardRepository != NULL)
								{
									dataType = dataBoardRepository->getDataBoard(dataTypeName);
								}

								unionType->addComponent(dataTypeName, dataType);
							}
						}

						return unionType;
					}
					break;

				case TYPE_COMPONENT:
					{
						pANTLR3_BASE_TREE parameter = NULL;
						pANTLR3_BASE_TREE type = NULL;
						
						if(tree->getChildCount(tree) == 2)
						{
							parameter = (pANTLR3_BASE_TREE)tree->getChild(tree, 0);
							type = (pANTLR3_BASE_TREE)tree->getChild(tree, 1);
						}

						DataType* returnType = NULL;

						if(type != NULL)
						{
							if(type->getType(type) == TYPE_REFERENCE)
							{
								returnType = parse(type, parent, indent + 1);
							}
							else if(type->getType(type) == RECORD_TYPE)
							{
								returnType = parse(type, parent, indent + 1);
							}
							else if(type->getType(type) == TUPLE_TYPE)
							{
								returnType = parse(type, parent, indent + 1);
							}
							else if(type->getType(type) == ARRAY_TYPE)
							{
								returnType = parse(type, parent, indent + 1);
							}
							else
							{
								//std::cout << "!!" << std::endl;
								//std::cout << parameter->getText(parameter)->chars << std::endl;
								//std::cout << parameter->getType(parameter) << std::endl;

								//std::cout << type->getText(type)->chars << std::endl;
								//std::cout << type->getType(type) << std::endl;
							}
						}

						if(parameter != NULL && returnType != NULL)
						{
							addToChildren(parent, (char*)parameter->getText(parameter)->chars, returnType);
						}

						return returnType;

						break;
					}
				case TYPE_REFERENCE:
					if(tree->getChildCount(tree) >= 1)
					{
						pANTLR3_BASE_TREE id = (pANTLR3_BASE_TREE)tree->getChild(tree, 0);

						const char* typeName = (char*)id->getText(id)->chars;

						bool errFound = false;

						DataType* returnType = NULL;

						if(id->getType(id) == ID)
						{
							if(strEquals(typeName, STR_BOOLEAN) == true)
							{
								returnType = new BooleanType();
							}
							else if(strEquals(typeName, STR_INTEGER) == true)
							{
								returnType = new IntegerType();
							}
							else if(strEquals(typeName, STR_DOUBLE) == true)
							{
								returnType = new DoubleType();
							}
							else if(strEquals(typeName, STR_BYTE) == true)
							{
								returnType = new ByteType();
							}
							else if(strEquals(typeName, STR_LONG) == true)
							{
								returnType = new LongType();
							}
							else if(strEquals(typeName, STR_FLOAT) == true)
							{
								// double=>float contradiction on purpose
								returnType = new DoubleType();
							}
							else if(strEquals(typeName, STR_STRING) == true)
							{
								returnType = new StringType();
							}
							else if(strEquals(typeName, STR_MAP) == true)
							{
								returnType = new MapType();
							}
							else if(strEquals(typeName, STR_OPTIONAL) == true)
							{
								returnType = new OptionalType();
							}
							else if(strEquals(typeName, STR_VARIANT) == true)
							{
								returnType = new VariantType();
							}
							else
							{
								if(dataBoardRepository != NULL)
								{
									returnType = dataBoardRepository->getDataBoard(typeName);
								}
							}
						}

						parseParameters(tree, returnType);

						//if(errFound == true)
						//{
						//	std::cout << "!-" << std::endl;
						//	std::cout << "unknown: " << typeName << std::endl << std::endl;

						//	std::cout << parameter->getText(parameter)->chars << std::endl;
						//	std::cout << parameter->getType(parameter) << std::endl;

						//	std::cout << "-!" << std::endl;
						//}

						return returnType;
					}
					break;
				case TYPE_ANNOTATION:
					if(tree->getChildCount(tree) == 2)
					{
						pANTLR3_BASE_TREE id = (pANTLR3_BASE_TREE)tree->getChild(tree, 0);
						pANTLR3_BASE_TREE parameterValue = (pANTLR3_BASE_TREE)tree->getChild(tree, 1);

						const char* idName = (char*)id->getText(id)->chars;

						if(strEquals(idName, STR_UNIT) == true)
						{
							std::string strValue((char*)parameterValue->getText(parameterValue)->chars);

							NumberType* numberType = dynamic_cast<NumberType*>(parent);

							if(numberType != NULL)
							{
								numberType->setUnit(strValue);
							}
						}
						//else if(strEquals(typeName, STR_RANGE) == true)
						//{
						//}
						else if(strEquals(idName, STR_PATTERN) == true)
						{
							std::string strValue((char*)parameterValue->getText(parameterValue)->chars);

							StringType* stringType = dynamic_cast<StringType*>(parent);

							if(stringType != NULL)
							{
								stringType->setPattern(strValue);
							}
						}
						else if(strEquals(idName, STR_MIMETYPE) == true)
						{
							std::string strValue((char*)parameterValue->getText(parameterValue)->chars);

							StringType* stringType = dynamic_cast<StringType*>(parent);

							if(stringType != NULL)
							{
								stringType->setMimeType(strValue);
							}
						}
						//else if(strEquals(idName, STR_LENGTH) == true) // range
						//{
						//	std::string strValue((char*)parameterValue->getText(parameterValue)->chars);

						//	StringType* stringType = dynamic_cast<StringType*>(parent);

						//	if(stringType != NULL)
						//	{
						//		stringType->setLength(strValue);
						//	}
						//}
					}

					break;
				case ID:
					parent = parent;
					break;

				default:
					break;
			}

			return NULL;
		}

		Range* temporaryname::parseRange(pANTLR3_BASE_TREE tree, int minPos, int maxPos)
		//Range* DataBoardRepository::parseRange(pANTLR3_BASE_TREE tree, int minPos, int maxPos)
		//Range* parseRange(pANTLR3_BASE_TREE tree, int minPos, int maxPos)
		{
			Range* range = new Range();

			bool rangeLower = true;

			bool inclusiveLower = true;
			bool inclusiveUpper = true;

			for(int i = minPos;i < maxPos; ++i)
			{
				pANTLR3_BASE_TREE rangechild = (pANTLR3_BASE_TREE)tree->getChild(tree, i);

				std::string rangeString((char*)rangechild->getText(rangechild)->chars);

				if(i == minPos && rangeString == STR_BRACEOPEN)
				{
					inclusiveLower = false;
				}
				else if(i == minPos && rangeString == STR_BRACKETOPEN)
				{
					inclusiveLower = true;
				}
				else if(i == (maxPos-1) && rangeString == STR_BRACECLOSE)
				{
					inclusiveUpper = false;
				}
				else if(i == (maxPos-1) && rangeString == STR_BRACKETCLOSE)
				{
					inclusiveUpper = true;
				}
				else if(rangeString == STR_RANGESPLIT)
				{
					rangeLower = false;
				}
				else
				{
					if(rangeLower == true)
					{
						range->setLower(rangeString);
					}
					else
					{
						range->setUpper(rangeString);
					}
				}
			}

			if(inclusiveLower == true)
			{
				range->getLower()->setInclusive();
			}
			if(inclusiveUpper == true)
			{
				range->getUpper()->setInclusive();
			}

			// split not received => upper = lower
			if(rangeLower == true)
			{
				range->setUpper(range->getLower()->getValue());
			}

			return range;
		}

		bool temporaryname::addToChildren(DataType* parent, char* name, DataType* children)
		//bool DataBoardRepository::addToChildren(DataType* parent, char* name, DataType* children)
		//bool addToChildren(DataType* parent, char* name, DataType* children)
		{
			//TypeRoot* typeRoot = dynamic_cast<TypeRoot*>(parent);

			//if(typeRoot != NULL)
			//{
			//	typeRoot->addDataBoard(name, children);

			//	return true;
			//}

			RecordType* recordType = dynamic_cast<RecordType*>(parent);

			if(recordType != NULL)
			{
				recordType->addComponent(name, children);

				return true;
			}

			return false;
		}

		void temporaryname::parseParameters(pANTLR3_BASE_TREE tree, DataType* type)
		//void DataBoardRepository::parseParameters(pANTLR3_BASE_TREE tree, DataType* type)
		//void parseParameters(pANTLR3_BASE_TREE tree, DataType* type)
		{
			if((int)tree->getChildCount(tree) >= 2)
			{
				if(dynamic_cast<NumberType*>(type) != NULL)
				{
					NumberType* numberType = (NumberType*)type;

					int annotationCount = (int)tree->getChildCount(tree);

					if(annotationCount >= 1)
					{
						for(int i = 1; i < annotationCount; ++i)
						{
							pANTLR3_BASE_TREE annotation = (pANTLR3_BASE_TREE)tree->getChild(tree, i);

							pANTLR3_BASE_TREE unit = (pANTLR3_BASE_TREE)annotation->getChild(annotation, 0);

							const char* unitName = (char*)unit->getText(unit)->chars;

							if(strEquals(unitName, STR_UNIT) == true)
							{
								if((int)annotation->getChildCount(annotation) == 2)
								{
									pANTLR3_BASE_TREE value = (pANTLR3_BASE_TREE)annotation->getChild(annotation, 1);

									std::string strValue((char*)value->getText(value)->chars);

									strValue = removeQuotes(strValue);

									NumberType* numberType = dynamic_cast<NumberType*>(type);

									if(numberType != NULL)
									{
										numberType->setUnit(strValue);
									}
								}
							}
							else if(strEquals(unitName, STR_RANGE) == true)
							{
								int c = (int)annotation->getChildCount(annotation);
								// possibilities:
								// 5: range;[;n;..;]
								// 5: range;[;..;m;]
								// 6: range;[;n;..;m;]
								if(c >= 5)
								{
									//pANTLR3_BASE_TREE openBracket = (pANTLR3_BASE_TREE)annotation->getChild(annotation, 0);
									//pANTLR3_BASE_TREE closeBracket = (pANTLR3_BASE_TREE)annotation->getChild(annotation, c-1);

									//if((char)(openBracket->getText(openBracket)->chars) != '[' &&
									//	(char)(closeBracket->getText(closeBracket)->chars) != ']')
									//{
										Range* range = parseRange(annotation, 1, c);

										numberType->setRange(range);
									//}
								}
							}
						}
					}
				}
				else if(dynamic_cast<StringType*>(type) != NULL)
				{
					StringType* stringType = (StringType*)type;

					for(int i = 1; i < (int)tree->getChildCount(tree); ++i)
					{
						pANTLR3_BASE_TREE annotation = (pANTLR3_BASE_TREE)tree->getChild(tree, i);

						pANTLR3_BASE_TREE unit = (pANTLR3_BASE_TREE)annotation->getChild(annotation, 0);
						pANTLR3_BASE_TREE value = (pANTLR3_BASE_TREE)annotation->getChild(annotation, 1);

						const char* unitName = (char*)unit->getText(unit)->chars;

						if(strEquals(unitName, STR_PATTERN) == true)
						{
							std::string strValue((char*)value->getText(value)->chars);

							strValue = removeQuotes(strValue);

							StringType* stringType = dynamic_cast<StringType*>(type);

							if(stringType != NULL)
							{
								stringType->setPattern(strValue);
							}
						}
						else if(strEquals(unitName, STR_MIMETYPE) == true)
						{
							std::string strValue((char*)value->getText(value)->chars);

							strValue = removeQuotes(strValue);

							StringType* stringType = dynamic_cast<StringType*>(type);

							if(stringType != NULL)
							{
								stringType->setMimeType(strValue);
							}
						}
						//else if(strEquals(idName, STR_LENGTH) == true) // range
						//{
						//	std::string strValue((char*)parameterValue->getText(parameterValue)->chars);

						//	StringType* stringType = dynamic_cast<StringType*>(parent);

						//	if(stringType != NULL)
						//	{
						//		stringType->setLength(strValue);
						//	}
						//}
					}
				}
				else if(dynamic_cast<MapType*>(type) != NULL)
				{
					MapType* mapType = (MapType*)type;

					if((int)tree->getChildCount(tree) == 3)
					{
						pANTLR3_BASE_TREE key = (pANTLR3_BASE_TREE)tree->getChild(tree, 1);
						pANTLR3_BASE_TREE value = (pANTLR3_BASE_TREE)tree->getChild(tree, 2);

						DataType* typeKey = parse(key, mapType);
						DataType* typeValue = parse(value, mapType);

						mapType->setKeyType(typeKey);
						mapType->setValueType(typeValue);
					}
				}
				else if(dynamic_cast<OptionalType*>(type) != NULL)
				{
					OptionalType* optionalType = (OptionalType*)type;

					if((int)tree->getChildCount(tree) == 2)
					{
						pANTLR3_BASE_TREE typeRef = (pANTLR3_BASE_TREE)tree->getChild(tree, 1);

						DataType* dataType = parse(typeRef, optionalType);

						if(dataType != NULL)
						{
							optionalType->setComponentType(dataType);
						}
					}
				}
			}

			//for(int i = 1; i < (int)tree->getChildCount(tree); ++i)
			//{
			//	pANTLR3_BASE_TREE parameter = (pANTLR3_BASE_TREE)tree->getChild(tree, i);

			//	parse(parameter, returnType, indent + 1);
			//}
		}
	}
}