/**************************************************************
 * 
 * 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_sc.hxx"
#include "XMLChangeTrackingImportHelper.hxx"
#include "XMLConverter.hxx"
#include "cell.hxx"
#include "document.hxx"
#include "chgviset.hxx"
#include "rangeutl.hxx"
#include <tools/debug.hxx>
#include <tools/datetime.hxx>
#include <svl/zforlist.hxx>
#include <xmloff/xmluconv.hxx>

#define SC_CHANGE_ID_PREFIX "ct"

ScMyCellInfo::ScMyCellInfo()
	: pCell(NULL),
	sFormulaAddress(),
	sFormula(),
	sInputString(),
	fValue(0.0),
	nMatrixCols(0),
	nMatrixRows(0),
    eGrammar( formula::FormulaGrammar::GRAM_STORAGE_DEFAULT),
	nType(NUMBERFORMAT_ALL),
	nMatrixFlag(MM_NONE)
{
}

ScMyCellInfo::ScMyCellInfo(ScBaseCell* pTempCell, const rtl::OUString& rFormulaAddress, const rtl::OUString& rFormula,
            const formula::FormulaGrammar::Grammar eTempGrammar, const rtl::OUString& rInputString,
			const double& rValue, const sal_uInt16 nTempType, const sal_uInt8 nTempMatrixFlag, const sal_Int32 nTempMatrixCols,
			const sal_Int32 nTempMatrixRows)
	: pCell(pTempCell),
	sFormulaAddress(rFormulaAddress),
	sFormula(rFormula),
    sInputString(rInputString),
	fValue(rValue),
	nMatrixCols(nTempMatrixCols),
	nMatrixRows(nTempMatrixRows),
    eGrammar( eTempGrammar),
	nType(nTempType),
	nMatrixFlag(nTempMatrixFlag)
{
}

ScMyCellInfo::~ScMyCellInfo()
{
	if (pCell)
		pCell->Delete();
}

ScBaseCell* ScMyCellInfo::CreateCell(ScDocument* pDoc)
{
	if (pDoc)
	{
		if (!pCell && sFormula.getLength() && sFormulaAddress.getLength())
		{
			ScAddress aPos;
			sal_Int32 nOffset(0);
			ScRangeStringConverter::GetAddressFromString(aPos, sFormulaAddress, pDoc, ::formula::FormulaGrammar::CONV_OOO, nOffset);
			pCell = new ScFormulaCell(pDoc, aPos, sFormula, eGrammar, nMatrixFlag);
			static_cast<ScFormulaCell*>(pCell)->SetMatColsRows(static_cast<SCCOL>(nMatrixCols), static_cast<SCROW>(nMatrixRows));
		}

		if ((nType == NUMBERFORMAT_DATE || nType == NUMBERFORMAT_TIME) && sInputString.Len() == 0)
		{
            sal_uInt32 nFormat(0);
            if (nType == NUMBERFORMAT_DATE)
				nFormat = pDoc->GetFormatTable()->GetStandardFormat( NUMBERFORMAT_DATE, ScGlobal::eLnge );
			else if (nType == NUMBERFORMAT_TIME)
				nFormat = pDoc->GetFormatTable()->GetStandardFormat( NUMBERFORMAT_TIME, ScGlobal::eLnge );
            pDoc->GetFormatTable()->GetInputLineString(fValue, nFormat, sInputString);
		}
	}

    return pCell ? pCell->CloneWithoutNote( *pDoc ) : 0;
}

ScMyDeleted::ScMyDeleted()
	: pCellInfo(NULL)
{
}

ScMyDeleted::~ScMyDeleted()
{
	if (pCellInfo)
		delete pCellInfo;
}

ScMyGenerated::ScMyGenerated(ScMyCellInfo* pTempCellInfo, const ScBigRange& aTempBigRange)
	: aBigRange(aTempBigRange),
	nID(0),
	pCellInfo(pTempCellInfo)
{
}

ScMyGenerated::~ScMyGenerated()
{
	if (pCellInfo)
		delete pCellInfo;
}

ScMyBaseAction::ScMyBaseAction(const ScChangeActionType nTempActionType)
	: aDependencies(),
	aDeletedList(),
	nActionNumber(0),
	nRejectingNumber(0),
	nPreviousAction(0),
	nActionType(nTempActionType),
	nActionState(SC_CAS_VIRGIN)
{
}

ScMyBaseAction::~ScMyBaseAction()
{
}

ScMyInsAction::ScMyInsAction(const ScChangeActionType nActionTypeP)
    : ScMyBaseAction(nActionTypeP)
{
}

ScMyInsAction::~ScMyInsAction()
{
}

ScMyDelAction::ScMyDelAction(const ScChangeActionType nActionTypeP)
    : ScMyBaseAction(nActionTypeP),
	aGeneratedList(),
	pInsCutOff(NULL),
	aMoveCutOffs(),
	nD(0)
{
}

ScMyDelAction::~ScMyDelAction()
{
	if (pInsCutOff)
		delete pInsCutOff;
}

ScMyMoveAction::ScMyMoveAction()
	: ScMyBaseAction(SC_CAT_MOVE),
	aGeneratedList(),
	pMoveRanges(NULL)
{
}

ScMyMoveAction::~ScMyMoveAction()
{
	if (pMoveRanges)
		delete pMoveRanges;
}


ScMyContentAction::ScMyContentAction()
	: ScMyBaseAction(SC_CAT_CONTENT),
	pCellInfo(NULL)
{
}

ScMyContentAction::~ScMyContentAction()
{
	if (pCellInfo)
		delete pCellInfo;
}

ScMyRejAction::ScMyRejAction()
	: ScMyBaseAction(SC_CAT_REJECT)
{
}

ScMyRejAction::~ScMyRejAction()
{
}

ScXMLChangeTrackingImportHelper::ScXMLChangeTrackingImportHelper()
    : aUsers(),
	aActions(),
	pDoc(NULL),
	pTrack(NULL),
	pCurrentAction(NULL),
    sIDPrefix(RTL_CONSTASCII_USTRINGPARAM(SC_CHANGE_ID_PREFIX)),
	nMultiSpanned(0),
	nMultiSpannedSlaveCount(0),
	bChangeTrack(sal_False)
{
	nPrefixLength = sIDPrefix.getLength();
}

ScXMLChangeTrackingImportHelper::~ScXMLChangeTrackingImportHelper()
{
}

void ScXMLChangeTrackingImportHelper::StartChangeAction(const ScChangeActionType nActionType)
{
	DBG_ASSERT(!pCurrentAction, "a not inserted action");
	switch (nActionType)
	{
		case SC_CAT_INSERT_COLS:
		case SC_CAT_INSERT_ROWS:
		case SC_CAT_INSERT_TABS:
		{
			pCurrentAction = new ScMyInsAction(nActionType);
		}
		break;
		case SC_CAT_DELETE_COLS:
		case SC_CAT_DELETE_ROWS:
		case SC_CAT_DELETE_TABS:
		{
			pCurrentAction = new ScMyDelAction(nActionType);
		}
		break;
		case SC_CAT_MOVE:
		{
			pCurrentAction = new ScMyMoveAction();
		}
		break;
		case SC_CAT_CONTENT:
		{
			pCurrentAction = new ScMyContentAction();
		}
		break;
		case SC_CAT_REJECT:
		{
			pCurrentAction = new ScMyRejAction();
		}
		break;
        default:
        {
            // added to avoid warnings
        }
	}
}

sal_uInt32 ScXMLChangeTrackingImportHelper::GetIDFromString(const rtl::OUString& sID)
{
	sal_uInt32 nResult(0);
	sal_uInt32 nLength(sID.getLength());
	if (nLength)
	{
		if (sID.compareTo(sIDPrefix, nPrefixLength) == 0)
		{
			rtl::OUString sValue(sID.copy(nPrefixLength, nLength - nPrefixLength));
			sal_Int32 nValue;
			SvXMLUnitConverter::convertNumber(nValue, sValue);
			DBG_ASSERT(nValue > 0, "wrong change action ID");
			nResult = nValue;
		}
		else
		{
			DBG_ERROR("wrong change action ID");
		}
	}
	return nResult;
}

void ScXMLChangeTrackingImportHelper::SetActionInfo(const ScMyActionInfo& aInfo)
{
	pCurrentAction->aInfo = aInfo;
	String aUser(aInfo.sUser);
	StrData* pStrData = new StrData( aUser );
	if ( !aUsers.Insert( pStrData ) )
		delete pStrData;
}

void ScXMLChangeTrackingImportHelper::SetPreviousChange(const sal_uInt32 nPreviousAction,
							ScMyCellInfo* pCellInfo)
{
	DBG_ASSERT(pCurrentAction->nActionType == SC_CAT_CONTENT, "wrong action type");
	ScMyContentAction* pAction = static_cast<ScMyContentAction*>(pCurrentAction);
	pAction->nPreviousAction = nPreviousAction;
	pAction->pCellInfo = pCellInfo;
}

void ScXMLChangeTrackingImportHelper::SetPosition(const sal_Int32 nPosition, const sal_Int32 nCount, const sal_Int32 nTable)
{
	DBG_ASSERT(((pCurrentAction->nActionType != SC_CAT_MOVE) &&
				(pCurrentAction->nActionType != SC_CAT_CONTENT) &&
				(pCurrentAction->nActionType != SC_CAT_REJECT)), "wrong action type");
	DBG_ASSERT(nCount > 0, "wrong count");
	switch(pCurrentAction->nActionType)
	{
		case SC_CAT_INSERT_COLS:
		case SC_CAT_DELETE_COLS:
		{
			pCurrentAction->aBigRange.Set(nPosition, nInt32Min, nTable,
										nPosition + nCount - 1, nInt32Max, nTable);
		}
		break;
		case SC_CAT_INSERT_ROWS:
		case SC_CAT_DELETE_ROWS:
		{
			pCurrentAction->aBigRange.Set(nInt32Min, nPosition, nTable,
										nInt32Max, nPosition + nCount - 1, nTable);
		}
		break;
		case SC_CAT_INSERT_TABS:
		case SC_CAT_DELETE_TABS:
		{
			pCurrentAction->aBigRange.Set(nInt32Min, nInt32Min, nPosition,
										nInt32Max, nInt32Max, nPosition + nCount - 1);
		}
		break;
        default:
        {
            // added to avoid warnings
        }
	}
}

void ScXMLChangeTrackingImportHelper::AddDeleted(const sal_uInt32 nID)
{
	ScMyDeleted* pDeleted = new ScMyDeleted();
	pDeleted->nID = nID;
	pCurrentAction->aDeletedList.push_front(pDeleted);
}

void ScXMLChangeTrackingImportHelper::AddDeleted(const sal_uInt32 nID, ScMyCellInfo* pCellInfo)
{
	ScMyDeleted* pDeleted = new ScMyDeleted();
	pDeleted->nID = nID;
	pDeleted->pCellInfo = pCellInfo;
	pCurrentAction->aDeletedList.push_front(pDeleted);
}

void ScXMLChangeTrackingImportHelper::SetMultiSpanned(const sal_Int16 nTempMultiSpanned)
{
	if (nTempMultiSpanned)
	{
		DBG_ASSERT(((pCurrentAction->nActionType == SC_CAT_DELETE_COLS) ||
					(pCurrentAction->nActionType == SC_CAT_DELETE_ROWS)), "wrong action type");
		nMultiSpanned = nTempMultiSpanned;
		nMultiSpannedSlaveCount = 0;
	}
}

void ScXMLChangeTrackingImportHelper::SetInsertionCutOff(const sal_uInt32 nID, const sal_Int32 nPosition)
{
	if ((pCurrentAction->nActionType == SC_CAT_DELETE_COLS) ||
		(pCurrentAction->nActionType == SC_CAT_DELETE_ROWS))
	{
		static_cast<ScMyDelAction*>(pCurrentAction)->pInsCutOff = new ScMyInsertionCutOff(nID, nPosition);
	}
	else
	{
		DBG_ERROR("wrong action type");
	}
}

void ScXMLChangeTrackingImportHelper::AddMoveCutOff(const sal_uInt32 nID, const sal_Int32 nStartPosition, const sal_Int32 nEndPosition)
{
	if ((pCurrentAction->nActionType == SC_CAT_DELETE_COLS) ||
		(pCurrentAction->nActionType == SC_CAT_DELETE_ROWS))
	{
		static_cast<ScMyDelAction*>(pCurrentAction)->aMoveCutOffs.push_front(ScMyMoveCutOff(nID, nStartPosition, nEndPosition));
	}
	else
	{
		DBG_ERROR("wrong action type");
	}
}

void ScXMLChangeTrackingImportHelper::SetMoveRanges(const ScBigRange& aSourceRange, const ScBigRange& aTargetRange)
{
	if (pCurrentAction->nActionType == SC_CAT_MOVE)
	{
 		static_cast<ScMyMoveAction*>(pCurrentAction)->pMoveRanges = new ScMyMoveRanges(aSourceRange, aTargetRange);
	}
	else
	{
		DBG_ERROR("wrong action type");
	}
}

void ScXMLChangeTrackingImportHelper::GetMultiSpannedRange()
{
	if ((pCurrentAction->nActionType == SC_CAT_DELETE_COLS) ||
		(pCurrentAction->nActionType == SC_CAT_DELETE_ROWS))
	{
		if (nMultiSpannedSlaveCount)
		{
			static_cast<ScMyDelAction*>(pCurrentAction)->nD = nMultiSpannedSlaveCount;
		}
		++nMultiSpannedSlaveCount;
		if (nMultiSpannedSlaveCount >= nMultiSpanned)
		{
			nMultiSpanned = 0;
			nMultiSpannedSlaveCount = 0;
		}
	}
	else
	{
		DBG_ERROR("wrong action type");
	}
}

void ScXMLChangeTrackingImportHelper::AddGenerated(ScMyCellInfo* pCellInfo, const ScBigRange& aBigRange)
{
	ScMyGenerated* pGenerated = new ScMyGenerated(pCellInfo, aBigRange);
	if (pCurrentAction->nActionType == SC_CAT_MOVE)
	{
		static_cast<ScMyMoveAction*>(pCurrentAction)->aGeneratedList.push_back(pGenerated);
	}
	else if ((pCurrentAction->nActionType == SC_CAT_DELETE_COLS) ||
		(pCurrentAction->nActionType == SC_CAT_DELETE_ROWS))
	{
		static_cast<ScMyDelAction*>(pCurrentAction)->aGeneratedList.push_back(pGenerated);
	}
	else
	{
		DBG_ERROR("try to insert a generated action to a wrong action");
	}
}

void ScXMLChangeTrackingImportHelper::EndChangeAction()
{
	if ((pCurrentAction->nActionType == SC_CAT_DELETE_COLS) ||
		(pCurrentAction->nActionType == SC_CAT_DELETE_ROWS))
		GetMultiSpannedRange();
	if (pCurrentAction && pCurrentAction->nActionNumber > 0)
		aActions.push_back(pCurrentAction);
	else
	{
		DBG_ERROR("no current action");
	}
	pCurrentAction = NULL;
}

void ScXMLChangeTrackingImportHelper::ConvertInfo(const ScMyActionInfo& aInfo, String& rUser, DateTime& aDateTime)
{
	Date aDate(aInfo.aDateTime.Day, aInfo.aDateTime.Month, aInfo.aDateTime.Year);
	Time aTime(aInfo.aDateTime.Hours, aInfo.aDateTime.Minutes, aInfo.aDateTime.Seconds, aInfo.aDateTime.HundredthSeconds);
    aDateTime.SetDate( aDate.GetDate() );
    aDateTime.SetTime( aTime.GetTime() );

    // #97286# old files didn't store 100th seconds, enable again
    if ( aInfo.aDateTime.HundredthSeconds )
        pTrack->SetTime100thSeconds( sal_True );

    StrData aStrData( aInfo.sUser );
    sal_uInt16 nPos;
    if ( pTrack->GetUserCollection().Search( &aStrData, nPos ) )
    {
        const StrData* pUser = static_cast<const StrData*>( pTrack->GetUserCollection().At( nPos ) );
        if ( pUser )
            rUser = pUser->GetString();
        else
            rUser = aInfo.sUser;    // shouldn't happen
    }
    else
        rUser = aInfo.sUser;    // shouldn't happen
}

ScChangeAction*	ScXMLChangeTrackingImportHelper::CreateInsertAction(ScMyInsAction* pAction)
{
    DateTime aDateTime( Date(0), Time(0) );
    String aUser;
    ConvertInfo(pAction->aInfo, aUser, aDateTime);

	String sComment (pAction->aInfo.sComment);

	ScChangeAction* pNewAction = new ScChangeActionIns(pAction->nActionNumber, pAction->nActionState, pAction->nRejectingNumber,
		pAction->aBigRange, aUser, aDateTime, sComment, pAction->nActionType);
	return pNewAction;
}

ScChangeAction*	ScXMLChangeTrackingImportHelper::CreateDeleteAction(ScMyDelAction* pAction)
{
    DateTime aDateTime( Date(0), Time(0) );
    String aUser;
    ConvertInfo(pAction->aInfo, aUser, aDateTime);

	String sComment (pAction->aInfo.sComment);

	ScChangeAction* pNewAction = new ScChangeActionDel(pAction->nActionNumber, pAction->nActionState, pAction->nRejectingNumber,
		pAction->aBigRange, aUser, aDateTime, sComment, pAction->nActionType, pAction->nD, pTrack);
	return pNewAction;
}

ScChangeAction*	ScXMLChangeTrackingImportHelper::CreateMoveAction(ScMyMoveAction* pAction)
{
	DBG_ASSERT(pAction->pMoveRanges, "no move ranges");
	if (pAction->pMoveRanges)
	{
        DateTime aDateTime( Date(0), Time(0) );
        String aUser;
        ConvertInfo(pAction->aInfo, aUser, aDateTime);

		String sComment (pAction->aInfo.sComment);

		ScChangeAction* pNewAction = new ScChangeActionMove(pAction->nActionNumber, pAction->nActionState, pAction->nRejectingNumber,
			pAction->pMoveRanges->aTargetRange, aUser, aDateTime, sComment, pAction->pMoveRanges->aSourceRange , pTrack);
		return pNewAction;
	}
	return NULL;
}

ScChangeAction*	ScXMLChangeTrackingImportHelper::CreateRejectionAction(ScMyRejAction* pAction)
{
    DateTime aDateTime( Date(0), Time(0) );
    String aUser;
    ConvertInfo(pAction->aInfo, aUser, aDateTime);

	String sComment (pAction->aInfo.sComment);

	ScChangeAction* pNewAction = new ScChangeActionReject(pAction->nActionNumber, pAction->nActionState, pAction->nRejectingNumber,
		pAction->aBigRange, aUser, aDateTime, sComment);
	return pNewAction;
}

ScChangeAction*	ScXMLChangeTrackingImportHelper::CreateContentAction(ScMyContentAction* pAction)
{
	ScBaseCell* pCell = NULL;
	if (pAction->pCellInfo)
		 pCell = pAction->pCellInfo->CreateCell(pDoc);

    DateTime aDateTime( Date(0), Time(0) );
    String aUser;
    ConvertInfo(pAction->aInfo, aUser, aDateTime);

	String sComment (pAction->aInfo.sComment);

	ScChangeAction* pNewAction = new ScChangeActionContent(pAction->nActionNumber, pAction->nActionState, pAction->nRejectingNumber,
		pAction->aBigRange, aUser, aDateTime, sComment, pCell, pDoc, pAction->pCellInfo->sInputString);
	return pNewAction;
}

void ScXMLChangeTrackingImportHelper::CreateGeneratedActions(ScMyGeneratedList& rList)
{
	if (!rList.empty())
	{
		ScMyGeneratedList::iterator aItr(rList.begin());
		ScMyGeneratedList::iterator aEndItr(rList.end());
		while (aItr != aEndItr)
		{
			if( (*aItr)->nID == 0)
			{
				ScBaseCell* pCell = NULL;
				if ((*aItr)->pCellInfo)
					pCell = (*aItr)->pCellInfo->CreateCell(pDoc);

				if (pCell)
				{
					(*aItr)->nID = pTrack->AddLoadedGenerated(pCell, (*aItr)->aBigRange, (*aItr)->pCellInfo->sInputString );
					DBG_ASSERT((*aItr)->nID, "could not insert generated action");
				}
			}
			++aItr;
		}
	}
}

void ScXMLChangeTrackingImportHelper::SetDeletionDependencies(ScMyDelAction* pAction, ScChangeActionDel* pDelAct)
{
	if (!pAction->aGeneratedList.empty())
	{
		DBG_ASSERT(((pAction->nActionType == SC_CAT_DELETE_COLS) ||
			(pAction->nActionType == SC_CAT_DELETE_ROWS) ||
			(pAction->nActionType == SC_CAT_DELETE_TABS)), "wrong action type");
		if (pDelAct)
		{
			ScMyGeneratedList::iterator aItr(pAction->aGeneratedList.begin());
			ScMyGeneratedList::iterator aEndItr(pAction->aGeneratedList.end());
			while (aItr != aEndItr)
			{
				DBG_ASSERT((*aItr)->nID, "a not inserted generated action");
				pDelAct->SetDeletedInThis((*aItr)->nID, pTrack);
				if (*aItr)
					delete *aItr;
				aItr = pAction->aGeneratedList.erase(aItr);
			}
		}
	}
	if (pAction->pInsCutOff)
	{
		DBG_ASSERT(((pAction->nActionType == SC_CAT_DELETE_COLS) ||
			(pAction->nActionType == SC_CAT_DELETE_ROWS) ||
			(pAction->nActionType == SC_CAT_DELETE_TABS)), "wrong action type");
		ScChangeAction* pChangeAction = pTrack->GetAction(pAction->pInsCutOff->nID);
		if (pChangeAction && pChangeAction->IsInsertType())
		{
			ScChangeActionIns* pInsAction = static_cast<ScChangeActionIns*>(pChangeAction);
			if (pInsAction && pDelAct)
				pDelAct->SetCutOffInsert(pInsAction, static_cast<sal_Int16>(pAction->pInsCutOff->nPosition));
		}
		else
		{
			DBG_ERROR("no cut off insert action");
		}
	}
	if (!pAction->aMoveCutOffs.empty())
	{
		DBG_ASSERT(((pAction->nActionType == SC_CAT_DELETE_COLS) ||
			(pAction->nActionType == SC_CAT_DELETE_ROWS) ||
			(pAction->nActionType == SC_CAT_DELETE_TABS)), "wrong action type");
		ScMyMoveCutOffs::iterator aItr(pAction->aMoveCutOffs.begin());
		ScMyMoveCutOffs::iterator aEndItr(pAction->aMoveCutOffs.end());
		while(aItr != aEndItr)
		{
			ScChangeAction* pChangeAction = pTrack->GetAction(aItr->nID);
			if (pChangeAction && (pChangeAction->GetType() == SC_CAT_MOVE))
			{
				ScChangeActionMove* pMoveAction = static_cast<ScChangeActionMove*>(pChangeAction);
				if (pMoveAction && pDelAct)
					pDelAct->AddCutOffMove(pMoveAction, static_cast<sal_Int16>(aItr->nStartPosition),
										static_cast<sal_Int16>(aItr->nEndPosition));
			}
			else
			{
				DBG_ERROR("no cut off move action");
			}
			aItr = pAction->aMoveCutOffs.erase(aItr);
		}
	}
}

void ScXMLChangeTrackingImportHelper::SetMovementDependencies(ScMyMoveAction* pAction, ScChangeActionMove* pMoveAct)
{
	if (!pAction->aGeneratedList.empty())
	{
		if (pAction->nActionType == SC_CAT_MOVE)
		{
			if (pMoveAct)
			{
				ScMyGeneratedList::iterator aItr(pAction->aGeneratedList.begin());
				ScMyGeneratedList::iterator aEndItr(pAction->aGeneratedList.end());
				while (aItr != aEndItr)
				{
					DBG_ASSERT((*aItr)->nID, "a not inserted generated action");
					pMoveAct->SetDeletedInThis((*aItr)->nID, pTrack);
					if (*aItr)
						delete *aItr;
					aItr = pAction->aGeneratedList.erase(aItr);
				}
			}
		}
	}
}

void ScXMLChangeTrackingImportHelper::SetContentDependencies(ScMyContentAction* pAction, ScChangeActionContent* pActContent)
{
	if (pAction->nPreviousAction)
	{
		DBG_ASSERT(pAction->nActionType == SC_CAT_CONTENT, "wrong action type");
		ScChangeAction* pPrevAct = pTrack->GetAction(pAction->nPreviousAction);
		if (pPrevAct)
		{
			ScChangeActionContent* pPrevActContent = static_cast<ScChangeActionContent*>(pPrevAct);
			if (pPrevActContent && pActContent)
			{
				pActContent->SetPrevContent(pPrevActContent);
				pPrevActContent->SetNextContent(pActContent);
				const ScBaseCell* pOldCell = pActContent->GetOldCell();
				if (pOldCell)
				{
                    ScBaseCell* pNewCell = pOldCell->CloneWithoutNote( *pDoc );
					if (pNewCell)
                    {
						pPrevActContent->SetNewCell(pNewCell, pDoc, EMPTY_STRING);
                        pPrevActContent->SetNewValue(pActContent->GetOldCell(), pDoc);
                    }
				}
			}
		}
	}
}

void ScXMLChangeTrackingImportHelper::SetDependencies(ScMyBaseAction* pAction)
{
	ScChangeAction* pAct = pTrack->GetAction(pAction->nActionNumber);
	if (pAct)
	{
		if (!pAction->aDependencies.empty())
		{
			ScMyDependencies::iterator aItr(pAction->aDependencies.begin());
			ScMyDependencies::iterator aEndItr(pAction->aDependencies.end());
			while(aItr != aEndItr)
			{
				pAct->AddDependent(*aItr, pTrack);
				aItr = pAction->aDependencies.erase(aItr);
			}
		}
		if (!pAction->aDeletedList.empty())
		{
			ScMyDeletedList::iterator aItr(pAction->aDeletedList.begin());
			ScMyDeletedList::iterator aEndItr(pAction->aDeletedList.end());
			while(aItr != aEndItr)
			{
				pAct->SetDeletedInThis((*aItr)->nID, pTrack);
				ScChangeAction* pDeletedAct = pTrack->GetAction((*aItr)->nID);
				if ((pDeletedAct->GetType() == SC_CAT_CONTENT) && (*aItr)->pCellInfo)
				{
					ScChangeActionContent* pContentAct = static_cast<ScChangeActionContent*>(pDeletedAct);
					if (pContentAct && (*aItr)->pCellInfo)
					{
						ScBaseCell* pCell = (*aItr)->pCellInfo->CreateCell(pDoc);
						if (!ScBaseCell::CellEqual(pCell, pContentAct->GetNewCell()))
                        {
                            // #i40704# Don't overwrite SetNewCell result by calling SetNewValue,
                            // instead pass the input string to SetNewCell.
                            pContentAct->SetNewCell(pCell, pDoc, (*aItr)->pCellInfo->sInputString);
                        }
					}
				}
				if (*aItr)
					delete *aItr;
				aItr = pAction->aDeletedList.erase(aItr);
			}
		}
		if ((pAction->nActionType == SC_CAT_DELETE_COLS) ||
			(pAction->nActionType == SC_CAT_DELETE_ROWS))
			SetDeletionDependencies(static_cast<ScMyDelAction*>(pAction), static_cast<ScChangeActionDel*>(pAct));
		else if (pAction->nActionType == SC_CAT_MOVE)
			SetMovementDependencies(static_cast<ScMyMoveAction*>(pAction), static_cast<ScChangeActionMove*>(pAct));
		else if (pAction->nActionType == SC_CAT_CONTENT)
			SetContentDependencies(static_cast<ScMyContentAction*>(pAction), static_cast<ScChangeActionContent*>(pAct));
	}
	else
	{
		DBG_ERROR("could not find the action");
	}
}

void ScXMLChangeTrackingImportHelper::SetNewCell(ScMyContentAction* pAction)
{
	ScChangeAction* pChangeAction = pTrack->GetAction(pAction->nActionNumber);
	if (pChangeAction)
	{
		ScChangeActionContent* pChangeActionContent = static_cast<ScChangeActionContent*>(pChangeAction);
		if (pChangeActionContent)
		{
			if (pChangeActionContent->IsTopContent() && !pChangeActionContent->IsDeletedIn())
			{
				sal_Int32 nCol, nRow, nTab, nCol2, nRow2, nTab2;
				pAction->aBigRange.GetVars(nCol, nRow, nTab, nCol2, nRow2, nTab2);
				if ((nCol >= 0) && (nCol <= MAXCOL) &&
					(nRow >= 0) && (nRow <= MAXROW) &&
					(nTab >= 0) && (nTab <= MAXTAB))
				{
					ScAddress aAddress (static_cast<SCCOL>(nCol),
										static_cast<SCROW>(nRow),
										static_cast<SCTAB>(nTab));
					ScBaseCell* pCell = pDoc->GetCell(aAddress);
					if (pCell)
					{
						ScBaseCell* pNewCell = NULL;
						if (pCell->GetCellType() != CELLTYPE_FORMULA)
                            pNewCell = pCell->CloneWithoutNote( *pDoc );
						else
						{
							sal_uInt8 nMatrixFlag = static_cast<ScFormulaCell*>(pCell)->GetMatrixFlag();
							String sFormula;
                            // With GRAM_ODFF reference detection is faster on compilation.
                            /* FIXME: new cell should be created with a clone
                             * of the token array instead. Any reason why this
                             * wasn't done? */
							static_cast<ScFormulaCell*>(pCell)->GetFormula(sFormula,formula::FormulaGrammar::GRAM_ODFF);
							rtl::OUString sOUFormula(sFormula);

                            // #i87826# [Collaboration] Rejected move destroys formulas
                            // FIXME: adjust ScFormulaCell::GetFormula(), so that the right formula string
                            //        is returned and no further string handling is necessary
                            rtl::OUString sOUFormula2;
                            if ( nMatrixFlag != MM_NONE )
                            {
                                sOUFormula2 = sOUFormula.copy( 2, sOUFormula.getLength() - 3 );
                            }
                            else
                            {
                                sOUFormula2 = sOUFormula.copy( 1, sOUFormula.getLength() - 1 );
                            }

							String sFormula2(sOUFormula2);
							pNewCell = new ScFormulaCell(pDoc, aAddress, sFormula2,formula::FormulaGrammar::GRAM_ODFF, nMatrixFlag);
							if (pNewCell)
							{
								if (nMatrixFlag == MM_FORMULA)
								{
									SCCOL nCols;
									SCROW nRows;
									static_cast<ScFormulaCell*>(pCell)->GetMatColsRows(nCols, nRows);
									static_cast<ScFormulaCell*>(pNewCell)->SetMatColsRows(nCols, nRows);
								}
								static_cast<ScFormulaCell*>(pNewCell)->SetInChangeTrack(sal_True);
							}
						}
                        pChangeActionContent->SetNewCell(pNewCell, pDoc, EMPTY_STRING);
                        // #i40704# don't overwrite the formula string from above with pCell's content
                        if (pCell->GetCellType() != CELLTYPE_FORMULA)
                            pChangeActionContent->SetNewValue(pCell, pDoc);
					}
				}
				else
				{
					DBG_ERROR("wrong cell position");
				}
			}
		}
	}
}

void ScXMLChangeTrackingImportHelper::CreateChangeTrack(ScDocument* pTempDoc)
{
	pDoc = pTempDoc;
	if (pDoc)
	{
		pTrack = new ScChangeTrack(pDoc, aUsers);
        // #97286# old files didn't store 100th seconds, disable until encountered
        pTrack->SetTime100thSeconds( sal_False );

		ScMyActions::iterator aItr(aActions.begin());
		ScMyActions::iterator aEndItr(aActions.end());
		while (aItr != aEndItr)
		{
			ScChangeAction* pAction = NULL;

			switch ((*aItr)->nActionType)
			{
				case SC_CAT_INSERT_COLS:
				case SC_CAT_INSERT_ROWS:
				case SC_CAT_INSERT_TABS:
				{
					pAction = CreateInsertAction(static_cast<ScMyInsAction*>(*aItr));
				}
				break;
				case SC_CAT_DELETE_COLS:
				case SC_CAT_DELETE_ROWS:
				case SC_CAT_DELETE_TABS:
				{
					ScMyDelAction* pDelAct = static_cast<ScMyDelAction*>(*aItr);
					pAction = CreateDeleteAction(pDelAct);
					CreateGeneratedActions(pDelAct->aGeneratedList);
				}
				break;
				case SC_CAT_MOVE:
				{
					ScMyMoveAction* pMovAct = static_cast<ScMyMoveAction*>(*aItr);
					pAction = CreateMoveAction(pMovAct);
					CreateGeneratedActions(pMovAct->aGeneratedList);
				}
				break;
				case SC_CAT_CONTENT:
				{
					pAction = CreateContentAction(static_cast<ScMyContentAction*>(*aItr));
				}
				break;
				case SC_CAT_REJECT:
				{
					pAction = CreateRejectionAction(static_cast<ScMyRejAction*>(*aItr));
				}
				break;
                default:
                {
                    // added to avoid warnings
                }
			}

			if (pAction)
				pTrack->AppendLoaded(pAction);
			else
			{
				DBG_ERROR("no action");
			}

			++aItr;
		}
		if (pTrack->GetLast())
			pTrack->SetActionMax(pTrack->GetLast()->GetActionNumber());

        aItr = aActions.begin();
        aEndItr = aActions.end();
		while (aItr != aEndItr)
		{
			SetDependencies(*aItr);

			if ((*aItr)->nActionType == SC_CAT_CONTENT)
				++aItr;
			else
			{
				if (*aItr)
					delete (*aItr);
				aItr = aActions.erase(aItr);
			}
		}

		aItr = aActions.begin();
        aEndItr = aActions.end();
		while (aItr != aEndItr)
		{
			DBG_ASSERT((*aItr)->nActionType == SC_CAT_CONTENT, "wrong action type");
			SetNewCell(static_cast<ScMyContentAction*>(*aItr));
			if (*aItr)
				delete (*aItr);
			aItr = aActions.erase(aItr);
		}
		if (aProtect.getLength())
			pTrack->SetProtection(aProtect);
        else if (pDoc->GetChangeTrack() && pDoc->GetChangeTrack()->IsProtected())
            pTrack->SetProtection(pDoc->GetChangeTrack()->GetProtection());

	    if ( pTrack->GetLast() )
		    pTrack->SetLastSavedActionNumber(pTrack->GetLast()->GetActionNumber());

		pDoc->SetChangeTrack(pTrack);
	}
}