/**************************************************************
 * 
 * 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.
 * 
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_tools.hxx"

#include <stdio.h>

#include <../../inc/tools/string.hxx>
#include <../../inc/tools/list.hxx>

class TextFilter
{
protected:
	FILE			*pIn, *pOut;
	virtual void	Filter();
public:
					TextFilter( ByteString aInFile = "stdin", 
						ByteString aOutFile = "stdout" );
	virtual			~TextFilter();

	virtual void	Execute();
};

TextFilter::TextFilter( ByteString aInFile, ByteString aOutFile )
{
	if ( aInFile == "stdin" )
		pIn = stdin;
	else
		if (( pIn = fopen( aInFile.GetBuffer(), "r" )) == NULL )
			printf( "Can't read %s\n", aInFile.GetBuffer() );

	if ( aOutFile == "stdout" )
		pOut = stdout;
	else
		if (( pOut = fopen( aOutFile.GetBuffer(), "w" )) == NULL )
			printf( "Can't write %s\n", aOutFile.GetBuffer() );
}

TextFilter::~TextFilter()
{
	fclose( pOut );
	fclose( pIn );
}

void TextFilter::Execute()
{
	Filter();
}

void TextFilter::Filter()
{
	int c;
	while ( (c = fgetc( pIn )) != EOF )
		fputc( c, pOut );
}

#define LINE_LEN 2048

class ByteStringList;

class MkLine
{
public:
	ByteString			aLine;
	ByteStringList*		pPrivateTnrLst;
	sal_Bool			bOut;
	sal_Bool			bHier;
		
					MkLine();
};

MkLine::MkLine()
{
	bOut = sal_False;
	bHier = sal_False;
	pPrivateTnrLst = NULL;
}

DECLARE_LIST( ByteStringList, MkLine * )

class MkFilter : public TextFilter
{
	static ByteString	aTnr;
	ByteStringList		*pLst;
	ByteStringList		*pTnrLst;
protected:
	virtual void	Filter();
public:
					MkFilter( ByteString aInFile = "stdin", ByteString aOutFile = "stdout");
					~MkFilter();
};

MkFilter::MkFilter( ByteString aInFile, ByteString aOutFile ) :
	TextFilter( aInFile, aOutFile )
{
	pLst = new ByteStringList;
	pTnrLst = new ByteStringList;
}

MkFilter::~MkFilter()
{
	delete pTnrLst;
	delete pLst;
}

ByteString MkFilter::aTnr="$(TNR)";

void MkFilter::Filter()
{
	char aLineBuf[LINE_LEN];
	int nState = 0;

	while(( fgets(aLineBuf, LINE_LEN, pIn)) != NULL )
	{
		ByteString aLine( aLineBuf );
		//fprintf(stderr, "aLine :%s\n", aLine.GetBuffer());
		if ( aLine.Search("mkfilter1" ) != STRING_NOTFOUND )
		{
			// Zeilen unterdruecken 
			fprintf( stderr, "mkfilter1\n" );
			nState = 0;
		}
		else if ( aLine.Search("unroll begin" ) != STRING_NOTFOUND )
		{
			// Zeilen raus schreiben mit ersetzen von $(TNR) nach int n
			fprintf( stderr, "\nunroll begin\n" );
			nState = 1;
		}
		;
		
		if ( nState == 0  )
		{
			fprintf( stderr, "." );
			MkLine *pMkLine = new MkLine();
			ByteString *pStr = new ByteString( aLineBuf );
			pMkLine->aLine = *pStr;
			pMkLine->bOut = sal_False;
		
			pLst->Insert( pMkLine, LIST_APPEND );
		}
		else if ( nState == 1 )
		{
			sal_Bool bInTnrList = sal_True;
			fprintf( stderr, ":" );
			MkLine *pMkLine = new MkLine();
			if ( aLine.Search("unroll end") != STRING_NOTFOUND )
			{
				fprintf( stderr, ";\nunroll end\n" );
				MkLine *p_MkLine = new MkLine();
				p_MkLine->bHier = sal_True;
				ByteString *pByteString = new ByteString("# do not delete this line === mkfilter3i\n");
				p_MkLine->aLine = *pByteString;
				p_MkLine->bOut = sal_False;
				p_MkLine->pPrivateTnrLst = pTnrLst;
				pTnrLst = new ByteStringList();
				pLst->Insert( p_MkLine, LIST_APPEND );
				nState = 0;
				bInTnrList = sal_False;
			}
			ByteString *pStr = new ByteString( aLineBuf );
			pMkLine->aLine = *pStr;
			pMkLine->bOut = sal_False;
		
			if ( bInTnrList )
				pTnrLst->Insert( pMkLine, LIST_APPEND );
		}
		else {
			/* Zeilen ignorieren */;
        }
	}	// End Of File
	fprintf( stderr, "\n" );
	
	// das File wieder ausgegeben
	sal_uIntPtr nLines = pLst->Count();
	for ( sal_uIntPtr j=0; j<nLines; j++ )
	{
		MkLine *pLine = pLst->GetObject( j );
		if ( pLine->bHier )
		{
			// die List n - Mal abarbeiten
			for ( sal_uInt16 n=1; n<11; n++)
			{
				sal_uIntPtr nCount = pLine->pPrivateTnrLst->Count();
				for ( sal_uIntPtr i=0; i<nCount; i++ )
				{
					MkLine *pMkLine = pLine->pPrivateTnrLst->GetObject(i);
					ByteString aLine = pMkLine->aLine;
					while( aLine.SearchAndReplace( aTnr, ByteString::CreateFromInt32( n )) != (sal_uInt16)-1 ) ;
					fputs( aLine.GetBuffer(), pOut );
					fprintf( stderr, "o" );
				}
			}
			if ( pLine->pPrivateTnrLst != NULL )
				delete pLine->pPrivateTnrLst;
			pLine->pPrivateTnrLst = NULL;
		}
		if ( pLine->bOut )
				fputs(pLine->aLine.GetBuffer(), pOut );			
	}
	fprintf( stderr, "\n" );
}

int main()
{
	int nRet = 0;

	TextFilter *pFlt = new MkFilter();
	pFlt->Execute();
	delete pFlt;

	return nRet;
}