/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


#include <parse.hxx>

#include <string.h>
#include <iostream>
#include <xmlelem.hxx>

#if (_MSC_VER >=1400)
#pragma warning(disable:4365)
#endif

#ifdef UNX
#define strnicmp strncasecmp
#endif


// NOT FULLY DEFINED SERVICES


#define AssertionOf(x)	\
	{if (!(x)) {std::cerr << "Assertion failed: " << #x << __FILE__ << __LINE__ << std::endl; exit(3); }}


X2CParser::X2CParser( XmlElement & o_rDocumentData )
	:	// sFileName,
		nFileLine(0),
		pDocumentData(&o_rDocumentData),
        // sWord,
		text(0)
{
}

X2CParser::~X2CParser()
{
}


bool
X2CParser::LoadFile( const char * i_sFilename )
{
	sFileName = i_sFilename;
	nFileLine = 1;

	// Load file:
	if ( ! LoadXmlFile( aFile, i_sFilename ) )
		return false;

	// Test correct end:
	const char * pLastTag = strrchr(aFile.operator const char *(),'<');
	if (pLastTag == 0)
		return false;
	if ( strnicmp(pLastTag+2, pDocumentData->Name().str(), pDocumentData->Name().l()) != 0
		 || strnicmp(pLastTag, "</", 2) != 0 )
		return false;
	if (strchr(pLastTag,'>') == 0)
		return false;
	return true;
}

void
X2CParser::Parse()
{
	// Parse:
	text = aFile.operator const char *();

	Parse_XmlDeclaration();
	Parse_Doctype();

    // skip XML comment
    Goto('<');
    if ( IsText("<!--") )
        Goto_And_Pass('>');

	pDocumentData->Parse(*this);
}

bool
X2CParser::Parse( const char * i_sFilename )
{
	bool ret = LoadFile(i_sFilename);
	if (ret)
		Parse();
	return ret;
}

void
X2CParser::Parse_XmlDeclaration()
{
	Goto('<');
	if ( IsText("<?xml") )
	{
		Goto_And_Pass('>');
	}
}

void
X2CParser::Parse_Doctype()
{
	Goto('<');
	if ( IsText("<!DOCTYPE") )
		Goto_And_Pass('>');
}

void
X2CParser::Parse_Sequence( DynamicList<XmlElement> & o_rElements,
						   const Simstr &			 i_sElementName  )
{
	CheckAndPassBeginTag(i_sElementName.str());

	unsigned int i_max = o_rElements.size();
	for (unsigned i = 0; i < i_max; ++i)
	{
		o_rElements[i]->Parse(*this);
	}  // end for

	CheckAndPassEndTag(i_sElementName.str());
}

void
X2CParser::Parse_FreeChoice( DynamicList<XmlElement> & o_rElements )
{
	unsigned     	nSize = o_rElements.size();

	for ( bool bBreak = false;  !bBreak; )
	{
		bBreak = true;
		for ( unsigned i = 0; i < nSize; ++i )
		{
			Goto('<');
			if ( IsBeginTag(o_rElements[i]->Name().str()) )
			{
				o_rElements[i]->Parse(*this);
				bBreak = false;
				break;
			}
		}  	// end for i
	} 	// end for !bBreak
}

void
X2CParser::Parse_List( ListElement &  o_rListElem )
{

	for ( Goto('<'); IsBeginTag(o_rListElem.Name().str()); Goto('<') )
	{
		XmlElement * pNew = o_rListElem.Create_and_Add_NewElement();
		pNew->Parse(*this);
	}
}

void
X2CParser::Parse_Text( Simstr &			o_sText,
					   const Simstr &	i_sElementName,
					   bool				i_bReverseName )
{

	if ( ! CheckAndPassBeginTag(i_sElementName.str()) )
        return;

	// Add new Element
	GetTextTill( o_sText, '<', i_bReverseName );
	o_sText.remove_trailing_blanks();

	CheckAndPassEndTag(i_sElementName.str());
}

void
X2CParser::Parse_MultipleText( List<Simstr> &	o_rTexts,
							   const Simstr &	i_sElementName,
							   bool				i_bReverseName )
{
	for ( Goto('<'); IsBeginTag(i_sElementName.str()); Goto('<') )
	{
        Simstr sNew;
		Parse_Text(sNew, i_sElementName, i_bReverseName);
        if (sNew.l() > 0)
    		o_rTexts.push_back(sNew);
	}
}

void
X2CParser::Parse_SglAttr( Simstr &			o_sAttrValue,
						  const Simstr &	i_sElementName,
						  const Simstr &	i_sAttrName )
{
	Goto('<');
	if ( !IsBeginTag(i_sElementName.str()) )
		SyntaxError("unexpected element");
	Move( i_sElementName.l() + 1 );

	Pass_White();
	if (*text == '>')
		SyntaxError("no attribute found, where one was expected");
	Simstr sAttrName;
	Get_Attribute(o_sAttrValue, sAttrName);
	if (sAttrName != i_sAttrName)
		SyntaxError("unknown attribute found");
	Pass_White();
	if (strncmp(text,"/>",2) != 0)
		SyntaxError("missing \"/>\" at end of empty element");
	Move(2);
}

void
X2CParser::Parse_MultipleAttr( List<Simstr> &		o_rAttrValues,
							   const Simstr &		i_sElementName,
							   const List<Simstr> &	i_rAttrNames )
{
	Goto('<');
	if ( !IsBeginTag(i_sElementName.str()) )
		SyntaxError("unexpected element");
	Move( i_sElementName.l() + 1 );
	Simstr sAttrName;
	Simstr sAttrValue;
	unsigned nSize = i_rAttrNames.size();
	unsigned i;

	for ( Pass_White(); *text != '/'; Pass_White() )
	{

		Get_Attribute(sAttrValue, sAttrName);

		for ( i = 0; i < nSize; ++i )
		{
			if ( i_rAttrNames[i] == sAttrName )
            {
				o_rAttrValues[i] = sAttrValue;
				break;
			}
		}
		if (i == nSize)
			SyntaxError("unknown attribute found");
	}
	Move(2);
}


void
X2CParser::Get_Attribute( Simstr & o_rAttrValue,
						  Simstr & o_rAttrName )
{
	GetTextTill( o_rAttrName, '=');

	while (*(++text) != '"')
	{
		if (*text == '\0')
			SyntaxError("unexpected end of file");
	}

	++text;
	GetTextTill( o_rAttrValue, '"');
	++text;
}

bool
X2CParser::IsText( const char *	i_sComparedText )
{
	return strnicmp( text, i_sComparedText, strlen(i_sComparedText) ) == 0;
}

bool
X2CParser::IsBeginTag( const char *	i_sTagName )
{
	return strnicmp( text+1, i_sTagName, strlen(i_sTagName) ) == 0
		   && *text == '<';
}

bool
X2CParser::IsEndTag( const char * i_sTagName )
{
	return strnicmp( text+2, i_sTagName, strlen(i_sTagName) ) == 0
		   && strnicmp( text, "</", 2 ) == 0;
}

void
X2CParser::Goto( char i_cNext )
{
	while (*text != i_cNext)
	{
		TestCurChar();
		++text;
	}
}

void
X2CParser::Goto_And_Pass( char i_cNext )
{
	Goto(i_cNext);
	++text;
}

void
X2CParser::Move( int i_nForward )
{
	text += i_nForward;
}

void
X2CParser::Pass_White()
{
	while (*text <= 32)
	{
		TestCurChar();
		++text;
	}
}

void
X2CParser::GetTextTill( Simstr & o_rText,
						char     i_cEnd,
						bool     i_bReverseName )
{
	char * pResult = &sWord[0];
	char * pSet;

	for ( pSet = pResult;
		  *text != i_cEnd;
		  ++text )
	{
		TestCurChar();
		*pSet++ = *text;
	}

	while ( *pResult < 33 && *pResult > 0 )
		++pResult;
	while ( pSet > pResult ? *(pSet-1) < 33 : false )
		pSet--;
	*pSet = '\0';


	if (i_bReverseName)
	{
        const unsigned int nMaxLen = 1000;
        if (strlen(pResult) < nMaxLen)
        {
    		char * sBreak = strrchr(pResult,'.');
	    	if (sBreak != 0)
		    {
			    static char sScope[nMaxLen+10];
    			static char sName[nMaxLen+10];

        		unsigned nScopeLen = sBreak - pResult;
		    	strncpy ( sScope, pResult, nScopeLen ); // STRNCPY SAFE HERE
			    sScope[nScopeLen] = '\0';
			    strcpy( sName, sBreak + 1 );            // STRCPY SAFE HERE
			    strcat( sName, " in " );                // STRCAT SAFE HERE
			    strcat( sName, sScope );                // STRCAT SAFE HERE

			    o_rText = sName;
			    return;
		    }
        }
	}   // endif (i_bReverseName)

	o_rText = &sWord[0];
}

bool
X2CParser::CheckAndPassBeginTag( const char * i_sElementName )
{
    bool ret = true;
	Goto('<');
	if ( ! IsBeginTag(i_sElementName) )
		SyntaxError( "unexpected element");
    if (IsAbsoluteEmpty())
        ret = false;
	Goto_And_Pass('>');
    if (ret)
	    Pass_White();
    return ret;
}

void
X2CParser::CheckAndPassEndTag( const char *	i_sElementName )
{
	Pass_White();
	if ( !IsEndTag(i_sElementName) )
		SyntaxError("missing or not matching end tag");
	Goto_And_Pass('>');
}

bool
X2CParser::IsAbsoluteEmpty() const
{
	const char * pEnd = strchr(text+1, '>');
    if (pEnd != 0)
    {
        if ( *(pEnd-1) == '/' )
        {
            const char * pAttr = strchr(text+1, '"');
         	if (pAttr == 0)
                return true;
            else if ( (pAttr-text) > (pEnd-text) )
                return true;
        }
    }
    return false;
}

void
X2CParser::SyntaxError( const char * i_sText )
{
	std::cerr
         << "Syntax error "
		 << i_sText
		 << " in file: "
		 << sFileName.str()
		 << " in line "
		 << nFileLine
		 << "."
		 << std::endl;

	 exit(3);
}

void
X2CParser::TestCurChar()
{
//	if (*text == '\0')
//		SyntaxError("unexpected end of file");
//	else

	if (*text == '\n')
		nFileLine++;
}