/**************************************************************
 * 
 * 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 "tools/geninfo.hxx"
#include <stdio.h>

//
// class GenericInformation
//

/*****************************************************************************/
GenericInformation::GenericInformation( const ByteString &rKey,
						const ByteString &rValue,
						GenericInformationList *pParentList,
						GenericInformationList *pSubInfos )
/*****************************************************************************/
				: ByteString( rKey ),
				sValue( rValue ),
				pInfoList( pSubInfos ),
				pParent( pParentList )
{
	// if a ParentList exists, insert this object into it
	if ( pParent )
		pParent->InsertInfo( this );
	// make myself owner of pInfoList
	if ( pInfoList )
		pInfoList->SetOwner( this );
}

/*****************************************************************************/
GenericInformation::GenericInformation( const GenericInformation& rInf,
										sal_Bool bCopySubs)
/*****************************************************************************/
				: ByteString( rInf ),
				sValue( rInf.sValue ),
				pInfoList( 0L ),
				pParent(NULL)
{
	if(bCopySubs && rInf.pInfoList)
		pInfoList = new GenericInformationList(*rInf.pInfoList, this);
}

/*****************************************************************************/
GenericInformation::~GenericInformation()
/*****************************************************************************/
{
	// remove pInfoList and all childs out of memory
	delete pInfoList;
	pInfoList = 0;

	// remove this Info out of ParentList
	if ( pParent )
		pParent->RemoveInfo( this );
}

/*****************************************************************************/
sal_Bool GenericInformation::InsertSubInfo( GenericInformation *pInfo )
/*****************************************************************************/
{
	return ( pInfoList && pInfoList->InsertInfo( pInfo ));
}

/*****************************************************************************/
sal_Bool GenericInformation::InsertSubInfo( const ByteString &rPathKey,	const ByteString &rValue,
					sal_Bool bSearchByPath, sal_Bool bNewPath )
/*****************************************************************************/
{
  return (pInfoList && pInfoList->InsertInfo( rPathKey, rValue, bSearchByPath, bNewPath ));
}

/*****************************************************************************/
void GenericInformation::RemoveSubInfo( GenericInformation *pInfo,
							sal_Bool bDelete )
/*****************************************************************************/
{
	pInfoList->RemoveInfo( pInfo, bDelete );
}

/*****************************************************************************/
//void GenericInformation::RemoveSelf( sal_Bool bDelete )
/*****************************************************************************/
/*{
  if ( pParent )
    pParent->RemoveInfo( this, bDelete ); // loescht sich aus der Liste vom Parent und
  // bei Bedarf auch mit obiger Methode alle Sublisten

  // loescht sich bei Bedarf auch selbst
    if ( bDelete )
    delete this;
}
*/

/*****************************************************************************/
GenericInformation *GenericInformation::GetSubInfo( ByteString &rKey,
						sal_Bool bSearchByPath,
						    sal_Bool bCreatePath )
/*****************************************************************************/
{
  if ( !pInfoList && bCreatePath )
	pInfoList = new GenericInformationList( this );
  if ( pInfoList )
    return pInfoList->GetInfo( rKey, bSearchByPath, bCreatePath );
  return NULL;
}


//
// class GenericInformationList
//

/*****************************************************************************/
GenericInformationList::GenericInformationList( GenericInformation *pParent )
/*****************************************************************************/
				: pOwner( pParent )
{
}

/*****************************************************************************/
GenericInformationList::GenericInformationList(const GenericInformationList& rList,
							GenericInformation *pParent)
/*****************************************************************************/
    : GenericInformationList_Impl()
{
	sal_uInt16 i;
	GenericInformation* pTemp,*pWork;

	pOwner = pParent;

	for(i=0;i<rList.Count();i++)
	{
		pTemp = rList.GetObject(i);
		pWork = new GenericInformation(*pTemp,sal_True);

		Insert(pWork,LIST_APPEND);
	}
}

/*****************************************************************************/
GenericInformationList::~GenericInformationList()
/*****************************************************************************/
{
	// delete all Informations stored in this List
	// ### GH: Hier werden dann wohl etwa die H�lfte der Eintr�ge gel�scht
/*	for ( sal_uIntPtr i = 0; i < Count(); i++ ) {
		GetObject( i )->ListDeleted();
		delete GetObject( i );
		Remove( i );*/
	// Neue Variante:
	while ( Count() ) {
		GetObject( 0 )->ListDeleted();
		delete GetObject( 0 );
		Remove( (sal_uIntPtr)0 );
	}
}

/*****************************************************************************/
GenericInformation *GenericInformationList::Search( sal_uIntPtr &rPos, ByteString sKey,
												   sal_uIntPtr nStart, sal_uIntPtr nEnd )
/*****************************************************************************/
{
	if ( Count() == 0 ) {
		rPos = 0;
		return NULL;
	}

	if ( nStart == nEnd ) {
		rPos = nStart;
		ByteString sCandidate = ByteString( *GetObject( nStart ));
		if ( sCandidate.ToUpperAscii() == sKey.ToUpperAscii()) {
			return GetObject( nStart ); // found !!!
		}
		else {
			// requested key not found
			return NULL;
		}
	}

	// search binary in existing list
	sal_uIntPtr nActPos = nStart + (( nEnd - nStart ) / 2 );
	rPos = nActPos;
	ByteString sCandidate = ByteString( *GetObject( nActPos ));

	if ( sCandidate.ToUpperAscii()  == sKey.ToUpperAscii())
		return GetObject( nActPos ); // found !!!

	// split the list at ActPos
	if ( sCandidate < sKey )
		return Search( rPos, sKey, nActPos + 1, nEnd );
	else
		return Search( rPos, sKey, nStart, nActPos );
}

/*****************************************************************************/
GenericInformation *GenericInformationList::GetInfo( ByteString &rKey,
						     sal_Bool bSearchByPath,
						     sal_Bool bCreatePath )
/*****************************************************************************/
{

	rKey.EraseLeadingChars( '/' );
	rKey.EraseTrailingChars( '/' );

	ByteString sKey;
	if ( bSearchByPath )
		sKey = rKey.GetToken( 0, '/' );
	else
		sKey = rKey;

	sal_uIntPtr nPos = 0;
	GenericInformation *pReturnInfo = Search( nPos, sKey, 0, Count() - 1 );
	/* wenn kein Searchpath gesetzt und kein Returninfo vorhanden,
	 *   gib NULL zurueck
	 * wenn Searchpath gesetzt und returninfo vorhanden,
	 *   suche weiter nach unten
	 * wenn searchpath gesetzt kein returninfo vorhanden und newpath gesetzt,
	 *   mache neues Verzeichniss
	 */
	sal_uInt16 nTokenCount = rKey.GetTokenCount('/');
	// search for next key of path in next level of tree
	if ( bSearchByPath && (nTokenCount > 1)) {
	  ByteString sPath = ByteString(rKey.Copy( sKey.Len() + 1 ));
	  if ( !pReturnInfo ) { // wenn kein Return, dann muss man es anlegen
	    if ( !bCreatePath ) // wenn aber kein Create, dann nicht anlegen
	      return NULL;
	    pReturnInfo = new GenericInformation( sKey, "", this, NULL);
	    pReturnInfo->SetSubList( new GenericInformationList( pReturnInfo ));
	  }
	  return pReturnInfo->GetSubInfo( sPath, sal_True, bCreatePath );
	}
	if ( !pReturnInfo && bCreatePath ) {
	  pReturnInfo = new GenericInformation ( sKey, "", this, NULL);
	}

	return pReturnInfo; // kann durchaus NULL sein.
}

/*****************************************************************************/
sal_uIntPtr GenericInformationList::InsertSorted( GenericInformation *pInfo,
										sal_Bool bOverwrite,
										sal_uIntPtr nStart, sal_uIntPtr nEnd )
/*****************************************************************************/
{
    if ( Count() == 0 ) {
		// empty list, so insert at first pos
		Insert( pInfo, LIST_APPEND );
		return 0;
	}

	ByteString sKey( pInfo->GetBuffer());
    sKey.ToUpperAscii();

    // Check to sppeed up reading a (partially) sorted list
    if ( nStart == 0 && Count()-1 == nEnd )
    {
		ByteString sCandidate( *GetObject( nEnd ));
		if ( sCandidate.ToUpperAscii() < sKey )
        {
			Insert( pInfo, LIST_APPEND );
			return nEnd+1;
        }
    }

// ### GH: dieser Block schein �berfl�ssig zu sein
	if ( Count() == 1 ) {
		ByteString sCandidate( *GetObject( 0 ));
		if ( sCandidate.ToUpperAscii() == sKey ) {
			// key allready exists in list
			if ( bOverwrite )
				Replace( pInfo, sal_uIntPtr(0));	// ### Laut NF scheint hier ein Memory Leak zu sein
			return 0;
		}
		else if ( sCandidate > sKey ) {
			Insert( pInfo, sal_uIntPtr(0));
			return 0;
		}
		else {
			Insert( pInfo, LIST_APPEND );
			return 1;
		}
	}
// ### GH: /ENDE/ dieser Block schein �berfl�ssig zu sein

	sal_uIntPtr nActPos = nStart + (( nEnd - nStart ) / 2 );
	ByteString sCandidate = ByteString( *GetObject( nActPos ));

	if ( sCandidate.ToUpperAscii() == sKey ) {
		// key allready exists in list
		if ( bOverwrite )
			Replace( pInfo, nActPos );	// ### Laut NF scheint hier ein Memory Leak zu sein
		return nActPos;
	}

	if ( nStart == nEnd ) {
		// now more ways to search for key -> insert here
		if ( sCandidate > sKey ) {
			Insert( pInfo, nStart );
			return nStart;
		}
		else {
			Insert( pInfo, nStart + 1 );
			return ( nStart + 1 );
		}
	}

	if ( nActPos == Count() - 1 ) {
		// reached end of list -> insert here
		Insert( pInfo, LIST_APPEND );
		return ( nActPos + 1 );
	}

	ByteString sSecondCand = ByteString( *GetObject( nActPos + 1 ));
	if (( sCandidate < sKey ) && ( sSecondCand.ToUpperAscii() > sKey )) {
		// optimal position to insert object
		Insert( pInfo, nActPos + 1 );
		return ( nActPos + 1 );
	}

	if ( sCandidate < sKey )
		return InsertSorted( pInfo, bOverwrite, nActPos + 1, nEnd );
	else
		return InsertSorted( pInfo, bOverwrite, nStart, nActPos );
}

/*****************************************************************************/
sal_Bool GenericInformationList::InsertInfo( GenericInformation *pInfo,
								sal_Bool bOverwrite )
/*****************************************************************************/
{
	if ( !pInfo->Len())
		return sal_False;

	InsertSorted( pInfo, bOverwrite, 0, Count() - 1 );
	return sal_True;
}


/*****************************************************************************/
sal_Bool GenericInformationList::InsertInfo( const ByteString &rPathKey, const ByteString &rValue,
					 sal_Bool bSearchByPath, sal_Bool bNewPath )
/*****************************************************************************/
{
  GenericInformation *pInfo;
  ByteString sPathKey ( rPathKey );
  sPathKey.EraseLeadingChars( '/' );
  sPathKey.EraseTrailingChars( '/' );

  pInfo = GetInfo( sPathKey, bSearchByPath, bNewPath );

  if ( pInfo ) {
    pInfo->SetValue( rValue );
    return sal_True;
  }
  return sal_False;
}

/*****************************************************************************/
void GenericInformationList::RemoveInfo( GenericInformation *pInfo,
								sal_Bool bDelete )
/*****************************************************************************/
{
	Remove( pInfo );
	if ( bDelete )
		delete pInfo;
/*	if ( Count() == 0 && pOwner )	// Leere Listen entfernen;
	{
		SetOwner( NULL );
		delete this;
	} Rausgepatched by GH */
}

GenericInformation* GenericInformationList::SetOwner( GenericInformation *pNewOwner )
{
	GenericInformation *pOldOwner = pOwner;
	if ( pOwner )	// bei parent austragen;
		pOwner->SetSubList( NULL );
	if ( pNewOwner )
		pNewOwner->SetSubList( this );
	pOwner = pNewOwner;
	return pOldOwner;
}