/*
 * (c) Copyright Ascensio System SIA 2010-2024
 *
 * This program is a free software product. You can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License (AGPL)
 * version 3 as published by the Free Software Foundation. In accordance with
 * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
 * that Ascensio System SIA expressly excludes the warranty of non-infringement
 * of any third-party rights.
 *
 * This program is distributed WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
 * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
 *
 * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
 * street, Riga, Latvia, EU, LV-1050.
 *
 * The  interactive user interfaces in modified source and object code versions
 * of the Program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU AGPL version 3.
 *
 * Pursuant to Section 7(b) of the License you must retain the original Product
 * logo when distributing the program. Pursuant to Section 7(e) we decline to
 * grant you any rights under trademark law for use of our trademarks.
 *
 * All the Product's GUI elements, including illustrations and icon sets, as
 * well as technical writing content are licensed under the terms of the
 * Creative Commons Attribution-ShareAlike 4.0 International. See the License
 * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
 *
 */

"use strict";

(function(window)
{
	let elementToCheck = {};
	function checkElementInRevision(element)
	{
		if (!element)
			return;
		
		let logicDocument = element.GetLogicDocument();
		if (!element.GetLogicDocument())
		{
			elementToCheck[element.GetId()] = element;
			return;
		}
		
		if (!logicDocument || !logicDocument.IsDocumentEditor())
			return;
		
		logicDocument.GetTrackRevisionsManager().CheckElement(element);
	}
	function haveElementToCheck()
	{
		for (let id in elementToCheck)
		{
			return true;
		}
		
		return false;
	}
	function flushElementToCheck()
	{
		for (let id in elementToCheck)
		{
			let element = elementToCheck[id];
			let logicDocument = element.GetLogicDocument();
			if (!logicDocument || !logicDocument.IsDocumentEditor())
				continue;
			
			logicDocument.GetTrackRevisionsManager().CheckElement(elementToCheck[id]);
		}
		
		elementToCheck = {};
	}
	
	// ВАЖНО: CheckArray - специальный массив-дублер для мапа CheckMap, для более быстрого выполнения функции
	//        ContinueTrackRevisions. Заметим, что на функции CompleteTrackChangesForElements мы не выкидываем
	//        элемент из CheckArray, но выкидываем из CheckMap. Это не страшно, т.к. при последующей проверке по
	//        массиву CheckArray элемент в CheckMap просто не найдется, а из CheckArray мы его выкинем, и, тем самым,
	//        CheckArray и CheckMap синхронизуются.

	/**
	 * Класс для отслеживания изменений в режиме рецензирования
	 * @param {AscWord.CDocument} oLogicDocument
	 * @constructor
	 */
	function CTrackRevisionsManager(oLogicDocument)
	{
		this.LogicDocument = oLogicDocument;

		this.CheckMap   = {};   // Элементы, которые нужно проверить
		this.CheckArray = [];   // Дублирующий массив элементов, которые мы проверяем в ContinueTrackRevisions

		this.Changes        = {};   // Объект с ключом - Id параграфа, в котором лежит массив изменений
		this.ChangesOutline = [];   // Упорядоченный массив с объектами, в которых есть изменения в рецензировании
		this.CurChange      = null; // Текущее изменение
		this.CurElement     = null; // Элемент с текущим изменением

		this.SelectedChanges     = [];    // Список изменений, попавших в выделение
		this.PrevSelectedChanges = [];
		this.PrevShowChanges     = true;

		this.MoveId      = 1;
		this.MoveMarks   = {};
		this.ProcessMove = null;

		this.SkipPreDeleteMoveMarks = false;
	}

	/**
	 * Отправляем элемент на проверку на наличие рецензирования
	 * @param oElement {AscWord.Paragraph | AscWord.CTable}
	 */
	CTrackRevisionsManager.prototype.CheckElement = function(oElement)
	{
		if (!(oElement instanceof AscWord.Paragraph) && !(oElement instanceof AscWord.CTable))
			return;

		let Id = oElement.GetId();
		if (!this.CheckMap[Id])
		{
			this.CheckMap[Id] = oElement;
			this.CheckArray.push(oElement);
		}
	};
	/**
	 * Добавляем изменение в рецензировании по Id элемента
	 * @param sId {string}
	 * @param oChange {CRevisionsChange}
	 */
	CTrackRevisionsManager.prototype.AddChange = function(sId, oChange)
	{
		if (this.private_CheckChangeObject(sId))
			this.Changes[sId].push(oChange);
	};
	/**
	 * Получаем массив изменений заданного элемента
	 * @param sElementId
	 * @returns {CRevisionsChange[]}
	 */
	CTrackRevisionsManager.prototype.GetElementChanges = function(sElementId)
	{
		if (this.Changes[sElementId])
			return this.Changes[sElementId];

		return [];
	};
	CTrackRevisionsManager.prototype.ContinueTrackRevisions = function(isComplete)
	{
		if (this.IsAllChecked())
			return;
		
		flushElementToCheck();

		var nStartTime = performance.now();

		// За раз обрабатываем не больше 500 параграфов либо не больше 4мс по времени,
		// чтобы не подвешивать клиент на открытии файлов
		const nMaxCounter = 500;
		let nCounter      = 0;

		var bNeedUpdate = false;

		let nIndex = this.CheckArray.length - 1;
		for (; nIndex >= 0; --nIndex)
		{
			if (this.private_TrackChangesForSingleElement(this.CheckArray[nIndex].GetId()))
				bNeedUpdate = true;

			if (true !== isComplete)
			{
				++nCounter;
				if (nCounter >= nMaxCounter || (performance.now() - nStartTime) > 4)
					break;
			}
		}

		this.CheckArray.length = nIndex < 0 ? 0 : nIndex;

		// TODO: Сделать нормальную проверку, что текущий параграф или текущее выделение попала в проверенные элементы
		//if (bNeedUpdate)
			this.LogicDocument.UpdateInterface();
	};
	/**
	 * Ищем следующее изменение
	 * @returns {?CRevisionsChange}
	 */
	CTrackRevisionsManager.prototype.GetNextChange = function()
	{
		if (this.CurChange && this.CurChange.IsComplexChange())
		{
			var arrChanges = this.CurChange.GetSimpleChanges();

			this.CurChange  = null;
			this.CurElement = null;

			if (arrChanges.length > 0)
			{
				this.CurChange  = arrChanges[arrChanges.length - 1];
				this.CurElement = this.CurChange.GetElement();

				if (!this.CurElement || !this.Changes[this.CurElement.GetId()])
				{
					this.CurChange  = null;
					this.CurElement = null;
				}
			}
		}

		var oChange = this.private_GetNextChange();
		if (oChange && oChange.IsMove() && !oChange.IsComplexChange())
		{
			oChange        = this.CollectMoveChange(oChange);
			this.CurChange = oChange;
		}

		return oChange;
	};
	CTrackRevisionsManager.prototype.private_GetNextChange = function()
	{
		var oInitialCurChange  = this.CurChange;
		var oInitialCurElement = this.CurElement;

		var oNextElement = null;
		if (null !== this.CurChange && null !== this.CurElement && this.Changes[this.CurElement.GetId()])
		{
			var arrChangesArray = this.Changes[this.CurElement.GetId()];

			var nChangeIndex = -1;
			for (var nIndex = 0, nCount = arrChangesArray.length; nIndex < nCount; ++nIndex)
			{
				if (this.CurChange === arrChangesArray[nIndex])
				{
					nChangeIndex = nIndex;
					break;
				}
			}

			if (-1 !== nChangeIndex && nChangeIndex < arrChangesArray.length - 1)
			{
				this.CurChange = arrChangesArray[nChangeIndex + 1];
				return this.CurChange;
			}

			oNextElement = this.LogicDocument.GetRevisionsChangeElement(1, this.CurElement);
		}
		else
		{
			var oSearchEngine = this.LogicDocument.private_GetRevisionsChangeElement(1, null);
			oNextElement      = oSearchEngine.GetFoundedElement();
			if (null !== oNextElement && oNextElement === oSearchEngine.GetCurrentElement())
			{
				var arrNextChangesArray = this.Changes[oNextElement.GetId()];
				if (arrNextChangesArray && arrNextChangesArray.length > 0)
				{
					if (oNextElement instanceof Paragraph)
					{
						var ParaContentPos = oNextElement.Get_ParaContentPos(oNextElement.IsSelectionUse(), true);
						for (var nChangeIndex = 0, nCount = arrNextChangesArray.length; nChangeIndex < nCount; ++nChangeIndex)
						{
							var ChangeEndPos = arrNextChangesArray[nChangeIndex].get_EndPos();
							if (ParaContentPos.Compare(ChangeEndPos) <= 0)
							{
								this.CurChange  = arrNextChangesArray[nChangeIndex];
								this.CurElement = oNextElement;
								return this.CurChange;
							}
						}
					}
					else if (oNextElement instanceof CTable && oNextElement.IsCellSelection())
					{
						var arrSelectedCells = oNextElement.GetSelectionArray();
						if (arrSelectedCells.length > 0)
						{
							var nTableRow = arrSelectedCells[0].Row;
							for (var nChangeIndex = 0, nCount = arrNextChangesArray.length; nChangeIndex < nCount; ++nChangeIndex)
							{
								var nStartRow = arrNextChangesArray[nChangeIndex].get_StartPos();
								if (nTableRow <= nStartRow)
								{
									this.CurChange  = arrNextChangesArray[nChangeIndex];
									this.CurElement = oNextElement;
									return this.CurChange;
								}
							}
						}
					}

					oNextElement = this.LogicDocument.GetRevisionsChangeElement(1, oNextElement);
				}
			}
		}

		if (null !== oNextElement)
		{
			var arrNextChangesArray = this.Changes[oNextElement.GetId()];
			if (arrNextChangesArray && arrNextChangesArray.length > 0)
			{
				this.CurChange  = arrNextChangesArray[0];
				this.CurElement = oNextElement;
				return this.CurChange;
			}
		}

		if (null !== oInitialCurChange && null !== oInitialCurElement)
		{
			this.CurChange  = oInitialCurChange;
			this.CurElement = oInitialCurElement;
			return oInitialCurChange;
		}

		this.CurChange  = null;
		this.CurElement = null;
		return null;
	};
	/**
	 * Ищем следующее изменение
	 * @returns {?CRevisionsChange}
	 */
	CTrackRevisionsManager.prototype.GetPrevChange = function()
	{
		if (this.CurChange && this.CurChange.IsComplexChange())
		{
			var arrChanges = this.CurChange.GetSimpleChanges();

			this.CurChange  = null;
			this.CurElement = null;

			if (arrChanges.length > 0)
			{
				this.CurChange  = arrChanges[0];
				this.CurElement = this.CurChange.GetElement();

				if (!this.CurElement || !this.Changes[this.CurElement.GetId()])
				{
					this.CurChange  = null;
					this.CurElement = null;
				}
			}
		}

		var oChange = this.private_GetPrevChange();
		if (oChange && oChange.IsMove() && !oChange.IsComplexChange())
		{
			oChange        = this.CollectMoveChange(oChange);
			this.CurChange = oChange;
		}

		return oChange;
	};
	CTrackRevisionsManager.prototype.private_GetPrevChange = function()
	{
		var oInitialCurChange  = this.CurChange;
		var oInitialCurElement = this.CurElement;

		var oPrevElement = null;
		if (null !== this.CurChange && null !== this.CurElement)
		{
			var arrChangesArray = this.Changes[this.CurElement.GetId()];
			var nChangeIndex    = -1;
			for (var nIndex = 0, nCount = arrChangesArray.length; nIndex < nCount; ++nIndex)
			{
				if (this.CurChange === arrChangesArray[nIndex])
				{
					nChangeIndex = nIndex;
					break;
				}
			}

			if (-1 !== nChangeIndex && nChangeIndex > 0)
			{
				this.CurChange = arrChangesArray[nChangeIndex - 1];
				return this.CurChange;
			}

			oPrevElement = this.LogicDocument.GetRevisionsChangeElement(-1, this.CurElement);
		}
		else
		{
			var SearchEngine = this.LogicDocument.private_GetRevisionsChangeElement(-1, null);
			oPrevElement     = SearchEngine.GetFoundedElement();
			if (null !== oPrevElement && oPrevElement === SearchEngine.GetCurrentElement())
			{
				var arrPrevChangesArray = this.Changes[oPrevElement.GetId()];
				if (undefined !== arrPrevChangesArray && arrPrevChangesArray.length > 0)
				{
					if (oPrevElement instanceof Paragraph)
					{
						var ParaContentPos = oPrevElement.Get_ParaContentPos(oPrevElement.IsSelectionUse(), true);
						for (var ChangeIndex = arrPrevChangesArray.length - 1; ChangeIndex >= 0; ChangeIndex--)
						{
							var ChangeStartPos = arrPrevChangesArray[ChangeIndex].get_StartPos();
							if (ParaContentPos.Compare(ChangeStartPos) >= 0)
							{
								this.CurChange  = arrPrevChangesArray[ChangeIndex];
								this.CurElement = oPrevElement;
								return this.CurChange;
							}
						}
					}
					else if (oPrevElement instanceof CTable && oPrevElement.IsCellSelection())
					{
						var arrSelectedCells = oPrevElement.GetSelectionArray();
						if (arrSelectedCells.length > 0)
						{
							var nTableRow = arrSelectedCells[0].Row;
							for (var nChangeIndex = arrPrevChangesArray.length - 1; nChangeIndex >= 0; --nChangeIndex)
							{
								var nStartRow = arrPrevChangesArray[nChangeIndex].get_StartPos();
								if (nTableRow >= nStartRow)
								{
									this.CurChange  = arrPrevChangesArray[nChangeIndex];
									this.CurElement = oPrevElement;
									return this.CurChange;
								}
							}
						}
					}

					oPrevElement = this.LogicDocument.GetRevisionsChangeElement(-1, oPrevElement);
				}
			}
		}

		if (null !== oPrevElement)
		{
			var arrPrevChangesArray = this.Changes[oPrevElement.GetId()];
			if (undefined !== arrPrevChangesArray && arrPrevChangesArray.length > 0)
			{
				this.CurChange  = arrPrevChangesArray[arrPrevChangesArray.length - 1];
				this.CurElement = oPrevElement;
				return this.CurChange;
			}
		}

		if (null !== oInitialCurChange && null !== oInitialCurElement)
		{
			this.CurChange  = oInitialCurChange;
			this.CurElement = oInitialCurElement;
			return oInitialCurChange;
		}

		this.CurChange  = null;
		this.CurElement = null;
		return null;
	};
	/**
	 * Проверяем есть ли непримененные изменения в документе
	 * @returns {boolean}
	 */
	CTrackRevisionsManager.prototype.Have_Changes = function()
	{
		var oTableId = this.LogicDocument ? this.LogicDocument.GetTableId() : null;

		for (var sElementId in this.Changes)
		{
			var oElement = oTableId ? oTableId.Get_ById(sElementId) : null;

			if (!oElement || !oElement.IsUseInDocument || !oElement.IsUseInDocument())
				continue;

			if (this.Changes[sElementId].length > 0)
				return true;
		}

		return false;
	};
	/**
	 * Проверяем есть ли изменения, сделанные другими пользователями
	 * @returns {boolean}
	 */
	CTrackRevisionsManager.prototype.HaveOtherUsersChanges = function()
	{
		var sUserId = this.LogicDocument.GetUserId(false);
		for (var sParaId in this.Changes)
		{
			var oParagraph = AscCommon.g_oTableId.Get_ById(sParaId);
			if (!oParagraph || !oParagraph.IsUseInDocument())
				continue;

			for (var nIndex = 0, nCount = this.Changes[sParaId].length; nIndex < nCount; ++nIndex)
			{
				var oChange = this.Changes[sParaId][nIndex];
				if (oChange.get_UserId() !== sUserId)
					return true;
			}
		}

		return false;
	};
	CTrackRevisionsManager.prototype.ClearCurrentChange = function()
	{
		this.CurChange  = null;
		this.CurElement = null;
	};
	CTrackRevisionsManager.prototype.SetCurrentChange = function(oCurChange)
	{
		if (oCurChange)
		{
			this.CurChange  = oCurChange;
			this.CurElement = oCurChange.GetElement();
		}
	};
	CTrackRevisionsManager.prototype.GetCurrentChangeElement = function()
	{
		return this.CurElement;
	};
	CTrackRevisionsManager.prototype.GetCurrentChange = function()
	{
		return this.CurChange;
	};
	CTrackRevisionsManager.prototype.InitSelectedChanges = function()
	{
		var oEditorApi = this.LogicDocument.GetApi();
		if (!oEditorApi)
			return;

		oEditorApi.sync_BeginCatchRevisionsChanges();
		oEditorApi.sync_EndCatchRevisionsChanges();
	};
	CTrackRevisionsManager.prototype.ClearSelectedChanges = function()
	{
		if (this.SelectedChanges.length > 0)
		{
			var oEditorApi = this.LogicDocument.GetApi();
			if (!oEditorApi)
				return;

			oEditorApi.sync_BeginCatchRevisionsChanges();
			oEditorApi.sync_EndCatchRevisionsChanges();
		}

		this.SelectedChanges = [];
	};
	/**
	 * Добавляем изменение, видимое в текущей позиции
	 * @param oChange
	 */
	CTrackRevisionsManager.prototype.AddSelectedChange = function(oChange)
	{
		if (this.CurChange)
			return;

		if (oChange && c_oAscRevisionsChangeType.MoveMark === oChange.get_Type())
			return;

		if (oChange.IsMove() && !oChange.IsComplexChange())
			oChange = this.CollectMoveChange(oChange);

		for (var nIndex = 0, nCount = this.SelectedChanges.length; nIndex < nCount; ++nIndex)
		{
			var oVisChange = this.SelectedChanges[nIndex];
			if (oVisChange.IsComplexChange() && !oChange.IsComplexChange())
			{
				var arrSimpleChanges = oVisChange.GetSimpleChanges();
				for (var nSimpleIndex = 0, nSimpleCount = arrSimpleChanges.length; nSimpleIndex < nSimpleCount; ++nSimpleIndex)
				{
					if (arrSimpleChanges[nSimpleIndex] === oChange)
						return;
				}
			}
			else if (!oVisChange.IsComplexChange() && oChange.IsComplexChange())
			{
				var arrSimpleChanges = oChange.GetSimpleChanges();
				for (var nSimpleIndex = 0, nSimpleCount = arrSimpleChanges.length; nSimpleIndex < nSimpleCount; ++nSimpleIndex)
				{
					if (arrSimpleChanges[nSimpleIndex] === oVisChange)
					{
						this.SelectedChanges.splice(nIndex, 1);
						nCount--;
						nIndex--;
						break;
					}
				}
			}
			else if (oVisChange.IsComplexChange() && oChange.IsComplexChange())
			{
				var arrVisSC    = oVisChange.GetSimpleChanges();
				var arrChangeSC = oChange.GetSimpleChanges();

				var isEqual = false;
				if (arrVisSC.length === arrChangeSC.length)
				{
					isEqual = true;
					for (var nSimpleIndex = 0, nSimplesCount = arrVisSC.length; nSimpleIndex < nSimplesCount; ++nSimpleIndex)
					{
						if (arrVisSC[nSimpleIndex] !== arrChangeSC[nSimpleIndex])
						{
							isEqual = false;
							break;
						}
					}
				}

				if (isEqual)
					return;
			}
			else if (oChange === oVisChange)
			{
				return;
			}
		}

		this.SelectedChanges.push(oChange);
	};
	CTrackRevisionsManager.prototype.GetSelectedChanges = function()
	{
		return this.SelectedChanges;
	};
	CTrackRevisionsManager.prototype.BeginCollectChanges = function(bSaveCurrentChange)
	{
		if (!this.IsAllChecked())
			return;

		this.PrevSelectedChanges = this.SelectedChanges;
		this.SelectedChanges     = [];

		if (true !== bSaveCurrentChange)
		{
			this.ClearCurrentChange();
		}
		else if (this.CurElement && this.CurChange)
		{
			var oSelectionBounds = this.CurElement.GetSelectionBounds();

			var oBounds = oSelectionBounds.Direction > 0 ? oSelectionBounds.Start : oSelectionBounds.End;

			if (oBounds)
			{
				var X = this.LogicDocument.Get_PageLimits(oBounds.Page).XLimit;
				this.CurChange.put_InternalPos(X, oBounds.Y, oBounds.Page);
				this.SelectedChanges.push(this.CurChange);
			}
		}
	};
	CTrackRevisionsManager.prototype.EndCollectChanges = function()
	{
		if (!this.IsAllChecked())
			return;

		var oEditor = this.LogicDocument.GetApi();
		if (this.CurChange)
			this.SelectedChanges = [this.CurChange];

		var isPositionChanged = false;
		var isArrayChanged    = false;
		var isShowChanges     = this.CurChange || !this.LogicDocument.IsTextSelectionUse();

		var nChangesCount = this.SelectedChanges.length;
		if (this.PrevSelectedChanges.length !== nChangesCount || this.PrevShowChanges !== isShowChanges)
		{
			isArrayChanged = true;
		}
		else if (0 !== nChangesCount)
		{
			for (var nChangeIndex = 0; nChangeIndex < nChangesCount; ++nChangeIndex)
			{
				if (this.SelectedChanges[nChangeIndex] !== this.PrevSelectedChanges[nChangeIndex])
				{
					isArrayChanged = true;
					break;
				}
				else if (this.SelectedChanges[nChangeIndex].IsPositionChanged())
				{
					isPositionChanged = true;
				}
			}
		}

		if (isArrayChanged)
		{
			oEditor.sync_BeginCatchRevisionsChanges();

			if (nChangesCount > 0)
			{
				var oPos = this.private_GetSelectedChangesXY();
				for (var ChangeIndex = 0; ChangeIndex < nChangesCount; ChangeIndex++)
				{
					var Change = this.SelectedChanges[ChangeIndex];
					Change.put_XY(oPos.X, oPos.Y);
					oEditor.sync_AddRevisionsChange(Change);
				}
			}
			oEditor.sync_EndCatchRevisionsChanges(isShowChanges);
		}
		else if (isPositionChanged)
		{
			this.UpdateSelectedChangesPosition(oEditor);
		}

		this.PrevShowChanges = isShowChanges;
	};
	CTrackRevisionsManager.prototype.UpdateSelectedChangesPosition = function(oEditor)
	{
		if (this.SelectedChanges.length > 0)
		{
			var oPos = this.private_GetSelectedChangesXY();
			oEditor.sync_UpdateRevisionsChangesPosition(oPos.X, oPos.Y);
		}
	};
	CTrackRevisionsManager.prototype.private_GetSelectedChangesXY = function()
	{
		if (!this.SelectedChanges.length)
			return {X : 0, Y : 0};
		
		let change = this.SelectedChanges[0];
		
		let element = change.GetElement();
		if (!element)
			return {X : 0, Y : 0};
		
		let x    = change.GetInternalPosX();
		let y    = change.GetInternalPosY();
		let page = change.GetInternalPosPageNum();

		let transform = element.Get_ParentTextTransform();
		if (transform)
			y = transform.TransformPointY(x, y);
		
		let drawingCoords = this.LogicDocument.getDrawingDocument().ConvertCoordsToCursorWR(x, y, page);
		return {X : drawingCoords.X, Y : drawingCoords.Y};
	};
	CTrackRevisionsManager.prototype.Get_AllChangesLogicDocuments = function()
	{
		this.CompleteTrackChanges();
		var LogicDocuments = {};

		for (var ParaId in this.Changes)
		{
			var Para = AscCommon.g_oTableId.Get_ById(ParaId);
			if (Para && Para.Get_Parent())
			{
				LogicDocuments[Para.Get_Parent().Get_Id()] = true;
			}
		}

		return LogicDocuments;
	};
	CTrackRevisionsManager.prototype.GetChangeRelatedParagraphs = function(oChange, bAccept)
	{
		var oRelatedParas = {};

		if (oChange.IsComplexChange())
		{
			var arrSimpleChanges = oChange.GetSimpleChanges();
			for (var nIndex = 0, nCount = arrSimpleChanges.length; nIndex < nCount; ++nIndex)
			{
				this.private_GetChangeRelatedParagraphs(arrSimpleChanges[nIndex], bAccept, oRelatedParas);
			}
		}
		else
		{
			this.private_GetChangeRelatedParagraphs(oChange, bAccept, oRelatedParas);
		}

		return this.private_ConvertParagraphsObjectToArray(oRelatedParas);
	};
	CTrackRevisionsManager.prototype.private_GetChangeRelatedParagraphs = function(oChange, bAccept, oRelatedParas)
	{
		if (oChange)
		{
			var nType    = oChange.GetType();
			var oElement = oChange.GetElement();
			if (oElement && oElement.IsUseInDocument())
			{
				oRelatedParas[oElement.GetId()] = true;
				if ((c_oAscRevisionsChangeType.ParaAdd === nType && true !== bAccept) || (c_oAscRevisionsChangeType.ParaRem === nType && true === bAccept))
				{
					var oLogicDocument = oElement.GetParent();
					var nParaIndex     = oElement.GetIndex();

					if (oLogicDocument && -1 !== nParaIndex)
					{
						if (nParaIndex < oLogicDocument.GetElementsCount() - 1)
						{
							var oNextElement = oLogicDocument.GetElement(nParaIndex + 1);
							if (oNextElement && oNextElement.IsParagraph())
								oRelatedParas[oNextElement.GetId()] = true;
						}
					}
				}
			}
		}
	};
	CTrackRevisionsManager.prototype.private_ConvertParagraphsObjectToArray = function(ParagraphsObject)
	{
		var ParagraphsArray = [];
		for (var ParaId in ParagraphsObject)
		{
			var Para = AscCommon.g_oTableId.Get_ById(ParaId);
			if (null !== Para)
			{
				ParagraphsArray.push(Para);
			}
		}
		return ParagraphsArray;
	};
	CTrackRevisionsManager.prototype.Get_AllChangesRelatedParagraphs = function(bAccept)
	{
		var RelatedParas = {};
		for (var ParaId in this.Changes)
		{
			for (var ChangeIndex = 0, ChangesCount = this.Changes[ParaId].length; ChangeIndex < ChangesCount; ++ChangeIndex)
			{
				var Change = this.Changes[ParaId][ChangeIndex];
				this.private_GetChangeRelatedParagraphs(Change, bAccept, RelatedParas);
			}
		}
		return this.private_ConvertParagraphsObjectToArray(RelatedParas);
	};
	CTrackRevisionsManager.prototype.Get_AllChangesRelatedParagraphsBySelectedParagraphs = function(SelectedParagraphs, bAccept)
	{
		var RelatedParas = {};
		for (var ParaIndex = 0, ParasCount = SelectedParagraphs.length; ParaIndex < ParasCount; ++ParaIndex)
		{
			var Para = SelectedParagraphs[ParaIndex];
			var ParaId = Para.Get_Id();
			if (this.Changes[ParaId] && this.Changes[ParaId].length > 0)
			{
				RelatedParas[ParaId] = true;
				if (true === Para.Selection_CheckParaEnd())
				{
					var CheckNext = false;
					for (var ChangeIndex = 0, ChangesCount = this.Changes[ParaId].length; ChangeIndex < ChangesCount; ++ChangeIndex)
					{
						var ChangeType = this.Changes[ParaId][ChangeIndex].get_Type();
						if ((c_oAscRevisionsChangeType.ParaAdd === ChangeType && true !== bAccept) || (c_oAscRevisionsChangeType.ParaRem === ChangeType && true === bAccept))
						{
							CheckNext = true;
							break;
						}
					}

					if (true === CheckNext)
					{
						var NextElement = Para.Get_DocumentNext();
						if (null !== NextElement && type_Paragraph === NextElement.Get_Type())
						{
							RelatedParas[NextElement.Get_Id()] = true;
						}
					}
				}
			}
		}
		return this.private_ConvertParagraphsObjectToArray(RelatedParas);
	};
	CTrackRevisionsManager.prototype.Get_AllChanges = function()
	{
		this.CompleteTrackChanges();
		return this.Changes;
	};
	CTrackRevisionsManager.prototype.IsAllChecked = function()
	{
		return (!this.CheckArray.length && !haveElementToCheck());
	};
	/**
	 * Завершаем проверку всех элементов на наличие рецензирования
	 */
	CTrackRevisionsManager.prototype.CompleteTrackChanges = function()
	{
		while (!this.IsAllChecked())
			this.ContinueTrackRevisions();
	};
	/**
	 * Завершаем проверку рецензирования для заданных элементов
	 * @param arrElements
	 * @returns {boolean}
	 */
	CTrackRevisionsManager.prototype.CompleteTrackChangesForElements = function(arrElements)
	{
		var isChecked = false;
		for (var nIndex = 0, nCount = arrElements.length; nIndex < nCount; ++nIndex)
		{
			if (this.private_TrackChangesForSingleElement(arrElements[nIndex].GetId()))
				isChecked = true;
		}

		return isChecked;
	};
	CTrackRevisionsManager.prototype.private_TrackChangesForSingleElement = function(Id)
	{
		if (!this.CheckMap[Id])
			return false;

		let oElement = this.CheckMap[Id];

		delete this.CheckMap[Id];

		if (!oElement.IsUseInDocument())
			return false;

		let isHaveChanges = !!this.Changes[Id];

		this.private_RemoveChangeObject(Id);
		oElement.CheckRevisionsChanges(this);

		return !(!isHaveChanges && !this.Changes[Id]);
	};
	/**
	 * При чтении файла обновляем Id перетаскиваний в рецензировании
	 * @param sMoveId
	 */
	CTrackRevisionsManager.prototype.UpdateMoveId = function(sMoveId)
	{
		if (0 === sMoveId.indexOf("move"))
		{
			var nId = parseInt(sMoveId.substring(4));
			if (!isNaN(nId))
				this.MoveId = Math.max(this.MoveId, nId);
		}
	};
	/**
	 * Возвращаем новый идентификатор перемещений
	 * @returns {string}
	 */
	CTrackRevisionsManager.prototype.GetNewMoveId = function()
	{
		this.MoveId++;
		return "move" + this.MoveId;
	};
	CTrackRevisionsManager.prototype.RegisterMoveMark = function(oMark)
	{
		if (this.LogicDocument && this.LogicDocument.PrintSelection)
			return;

		if (!oMark)
			return;

		var sMarkId = oMark.GetMarkId();
		var isFrom  = oMark.IsFrom();
		var isStart = oMark.IsStart();

		this.UpdateMoveId(sMarkId);

		if (!this.MoveMarks[sMarkId])
		{
			this.MoveMarks[sMarkId] = {

				From : {
					Start : null,
					End   : null
				},

				To : {
					Start : null,
					End   : null
				}
			};
		}

		if (isFrom)
		{
			if (isStart)
				this.MoveMarks[sMarkId].From.Start = oMark;
			else
				this.MoveMarks[sMarkId].From.End = oMark;
		}
		else
		{
			if (isStart)
				this.MoveMarks[sMarkId].To.Start = oMark;
			else
				this.MoveMarks[sMarkId].To.End = oMark;
		}
	};
	CTrackRevisionsManager.prototype.UnregisterMoveMark = function(oMark)
	{
		if (this.LogicDocument && this.LogicDocument.PrintSelection)
			return;

		if (!oMark)
			return;

		var sMarkId = oMark.GetMarkId();
		delete this.MoveMarks[sMarkId];

		// TODO: Возможно тут нужно проделать дополнительные действия
	};
	CTrackRevisionsManager.prototype.private_CheckChangeObject = function(sId)
	{
		var oElement = AscCommon.g_oTableId.Get_ById(sId);
		if (!oElement)
			return false;

		if (!this.Changes[sId])
			this.Changes[sId] = [];

		var nDeletePosition = -1;
		for (var nIndex = 0, nCount = this.ChangesOutline.length; nIndex < nCount; ++nIndex)
		{
			if (this.ChangesOutline[nIndex].GetId() === sId)
			{
				nDeletePosition = nIndex;
				break;
			}
		}

		var oDocPos = oElement.GetDocumentPositionFromObject();
		if (!oDocPos)
			return;

		var nAddPosition = -1;
		for (var nIndex = 0, nCount = this.ChangesOutline.length; nIndex < nCount; ++nIndex)
		{
			var oTempDocPos = this.ChangesOutline[nIndex].GetDocumentPositionFromObject();

			if (this.private_CompareDocumentPositions(oDocPos, oTempDocPos) < 0)
			{
				nAddPosition = nIndex;
				break;
			}
		}

		if (-1 === nAddPosition)
			nAddPosition = this.ChangesOutline.length;

		if (nAddPosition === nDeletePosition || (-1 !== nAddPosition && -1 !== nDeletePosition && nDeletePosition === nAddPosition - 1))
			return true;

		if (-1 !== nDeletePosition)
		{
			this.ChangesOutline.splice(nDeletePosition, 1);

			if (nAddPosition > nDeletePosition)
				nAddPosition--;
		}

		this.ChangesOutline.splice(nAddPosition, 0, oElement);

		return true;
	};
	CTrackRevisionsManager.prototype.private_CompareDocumentPositions = function(oDocPos1, oDocPos2)
	{
		if (oDocPos1.Class !== oDocPos2.Class)
		{
			// TODO: Здесь нужно доработать сравнение позиций, когда они из разных частей документа
			if (oDocPos1.Class instanceof CDocument)
				return -1;
			else if (oDocPos1.Class instanceof CDocument)
				return 1;
			else
				return 1;
		}

		for (var nIndex = 0, nCount = oDocPos1.length; nIndex < nCount; ++nIndex)
		{
			if (oDocPos2.length <= nIndex)
				return 1;

			if (oDocPos1[nIndex].Position < oDocPos2[nIndex].Position)
				return -1;
			else if (oDocPos1[nIndex].Position > oDocPos2[nIndex].Position)
				return 1;
		}

		return 0;
	};
	CTrackRevisionsManager.prototype.private_RemoveChangeObject = function(sId)
	{
		if (this.Changes[sId])
			delete this.Changes[sId];

		for (var nIndex = 0, nCount = this.ChangesOutline.length; nIndex < nCount; ++nIndex)
		{
			if (this.ChangesOutline[nIndex].GetId() === sId)
			{
				this.ChangesOutline.splice(nIndex, 1);
				return;
			}
		}
	};
	/**
	 * Собираем изменение связанное с переносом
	 * @param {CRevisionsChange} oChange
	 * @returns {CRevisionsChange}
	 */
	CTrackRevisionsManager.prototype.CollectMoveChange = function(oChange)
	{
		var isFrom = c_oAscRevisionsChangeType.TextRem === oChange.GetType() || c_oAscRevisionsChangeType.ParaRem === oChange.GetType() || (c_oAscRevisionsChangeType.MoveMark === oChange.GetType() && oChange.GetValue().IsFrom());

		var nStartIndex  = -1;
		var oStartChange = null;

		var oElement = oChange.GetElement();
		if (!oElement)
			return oChange;

		var nDeep = 0;
		var nSearchIndex = -1;
		for (var nIndex = 0, nCount = this.ChangesOutline.length; nIndex < nCount; ++nIndex)
		{
			if (this.ChangesOutline[nIndex] === oElement)
			{
				nSearchIndex = nIndex;
				break;
			}
		}

		if (-1 === nSearchIndex)
			return oChange;

		var isStart = false;

		for (var nIndex = nSearchIndex; nIndex >= 0; --nIndex)
		{
			var arrCurChanges = this.Changes[this.ChangesOutline[nIndex].GetId()];

			if (!arrCurChanges)
			{
				isStart = true;
				continue;
			}

			for (var nChangeIndex = arrCurChanges.length - 1; nChangeIndex >= 0; --nChangeIndex)
			{
				var oCurChange = arrCurChanges[nChangeIndex];
				if (!isStart)
				{
					if (oCurChange === oChange)
						isStart = true;
				}

				if (isStart)
				{
					var nCurChangeType = oCurChange.GetType();
					if (nCurChangeType === c_oAscRevisionsChangeType.MoveMark)
					{
						var oMoveMark = oCurChange.GetValue();
						if ((isFrom && oMoveMark.IsFrom()) || (!isFrom && !oMoveMark.IsFrom()))
						{
							if (oMoveMark.IsStart())
							{
								if (nDeep > 0)
								{
									nDeep--;
								}
								else if (nDeep === 0)
								{
									nStartIndex  = nIndex;
									oStartChange = oCurChange;
									break;
								}
							}
							else if (oCurChange !== oChange)
							{
								nDeep++;
							}
						}
					}
				}
			}

			if (oStartChange)
				break;

			isStart = true;
		}

		if (!oStartChange || -1 === nStartIndex)
			return oChange;

		var sValue     = "";
		var arrChanges = [oStartChange];

		isStart = false;
		nDeep   = 0;
		var isEnd = false;
		for (var nIndex = nStartIndex, nCount = this.ChangesOutline.length; nIndex < nCount; ++nIndex)
		{
			var arrCurChanges = this.Changes[this.ChangesOutline[nIndex].GetId()];
			for (var nChangeIndex = 0, nChangesCount = arrCurChanges.length; nChangeIndex < nChangesCount; ++nChangeIndex)
			{
				var oCurChange = arrCurChanges[nChangeIndex];
				if (!isStart)
				{
					if (oCurChange === oStartChange)
						isStart = true;
				}
				else
				{
					var nCurChangeType = oCurChange.GetType();
					if (isFrom)
					{
						if (c_oAscRevisionsChangeType.TextRem === nCurChangeType || c_oAscRevisionsChangeType.ParaRem === nCurChangeType)
						{
							if (0 === nDeep)
							{
								sValue += c_oAscRevisionsChangeType.TextRem === nCurChangeType ? oCurChange.GetValue() : "\n";
								arrChanges.push(oCurChange);
							}
						}
						else if (c_oAscRevisionsChangeType.MoveMark === nCurChangeType && oCurChange.GetValue().IsFrom())
						{
							if (oCurChange.GetValue().IsStart())
							{
								nDeep++;
							}
							else if (nDeep > 0)
							{
								nDeep--;
							}
							else
							{
								arrChanges.push(oCurChange);
								isEnd = true;
								break;
							}
						}
					}
					else
					{
						if (c_oAscRevisionsChangeType.TextAdd === nCurChangeType || c_oAscRevisionsChangeType.ParaAdd === nCurChangeType)
						{
							if (0 === nDeep)
							{
								sValue += c_oAscRevisionsChangeType.TextAdd === nCurChangeType ? oCurChange.GetValue() : "\n";
								arrChanges.push(oCurChange);
							}
						}
						else if (c_oAscRevisionsChangeType.MoveMark === nCurChangeType && !oCurChange.GetValue().IsFrom())
						{
							if (oCurChange.GetValue().IsStart())
							{
								nDeep++;
							}
							else if (nDeep > 0)
							{
								nDeep--;
							}
							else
							{
								arrChanges.push(oCurChange);
								isEnd = true;
								break;
							}
						}
					}
				}
			}

			if (!isStart)
				return oChange;

			if (isEnd)
				break;
		}

		var sMoveId = oStartChange.GetValue().GetMarkId();
		var isDown  = null;

		for (var nIndex = 0, nCount = this.ChangesOutline.length; nIndex < nCount; ++nIndex)
		{
			var arrCurChanges = this.Changes[this.ChangesOutline[nIndex].GetId()];
			if (!arrCurChanges)
				continue;

			for (var nChangeIndex = 0, nChangesCount = arrCurChanges.length; nChangeIndex < nChangesCount; ++nChangeIndex)
			{
				var oCurChange = arrCurChanges[nChangeIndex];
				if (c_oAscRevisionsChangeType.MoveMark === oCurChange.GetType())
				{
					var oMark = oCurChange.GetValue();
					if (sMoveId === oMark.GetMarkId())
					{
						isDown = !!oMark.IsFrom();
						break;
					}
				}
			}

			if (null !== isDown)
				break;
		}

		if (!isEnd || null === isDown)
			return oChange;

		var oMoveChange = new CRevisionsChange();
		oMoveChange.SetType(isFrom ? c_oAscRevisionsChangeType.TextRem : c_oAscRevisionsChangeType.TextAdd);
		oMoveChange.SetValue(sValue);
		oMoveChange.SetElement(oStartChange.GetElement());
		oMoveChange.SetUserId(oStartChange.GetUserId());
		oMoveChange.SetUserName(oStartChange.GetUserName());
		oMoveChange.SetDateTime(oStartChange.GetDateTime());
		oMoveChange.SetMoveType(isFrom ? Asc.c_oAscRevisionsMove.MoveFrom : Asc.c_oAscRevisionsMove.MoveTo);
		oMoveChange.SetSimpleChanges(arrChanges);
		oMoveChange.SetMoveId(sMoveId);
		oMoveChange.SetMovedDown(isDown);
		oMoveChange.SetXY(oChange.GetX(), oChange.GetY());
		oMoveChange.SetInternalPos(oChange.GetInternalPosX(), oChange.GetInternalPosY(), oChange.GetInternalPosPageNum());
		return oMoveChange;
	};
	/**
	 * Получаем массив всех изменений связанных с заданным переносом
	 * @param {string} sMoveId
	 * @returns {CRevisionsChange[]}
	 */
	CTrackRevisionsManager.prototype.GetAllMoveChanges = function(sMoveId)
	{
		var oStartFromChange = null;
		var oStartToChange   = null;

		for (var sElementId in this.Changes)
		{
			var arrElementChanges = this.Changes[sElementId];
			for (var nChangeIndex = 0, nChangesCount = arrElementChanges.length; nChangeIndex < nChangesCount; ++nChangeIndex)
			{
				var oCurChange = arrElementChanges[nChangeIndex];
				if (c_oAscRevisionsChangeType.MoveMark === oCurChange.GetType() && sMoveId === oCurChange.GetValue().GetMarkId() && oCurChange.GetValue().IsStart())
				{
					if (oCurChange.GetValue().IsFrom())
						oStartFromChange = oCurChange;
					else
						oStartToChange = oCurChange;
				}
			}

			if (oStartFromChange && oStartToChange)
				break;
		}

		if (!oStartFromChange || !oStartToChange)
			return {From : [], To : []};

		return {
			From : this.CollectMoveChange(oStartFromChange).GetSimpleChanges(),
			To   : this.CollectMoveChange(oStartToChange).GetSimpleChanges()
		};
	};
	/**
	 * Начинаем процесс обработки(принятия или отклонения) перетаскивания текста
	 * @param sMoveId {string} идентификатор перетаскивания
	 * @param sUserId {string} идентификатор пользователя
	 * @returns {CTrackRevisionsMoveProcessEngine}
	 */
	CTrackRevisionsManager.prototype.StartProcessReviewMove = function(sMoveId, sUserId)
	{
		return (this.ProcessMove = new CTrackRevisionsMoveProcessEngine(sMoveId, sUserId));
	};
	/**
	 * Завершаем процесс обработки перетаскивания текста
	 */
	CTrackRevisionsManager.prototype.EndProcessReviewMove = function()
	{
		// TODO: Здесь нужно сделать обработку MovesToDelete

		this.ProcessMove = null;
	};
	/**
	 * Проверям, запущен ли процесс обрабокти перетаскивания текста
	 * @returns {?CTrackRevisionsMoveProcessEngine}
	 */
	CTrackRevisionsManager.prototype.GetProcessTrackMove = function()
	{
		return this.ProcessMove;
	};
	/**
	 * Получаем метки переноса
	 * @param sMarkId
	 */
	CTrackRevisionsManager.prototype.GetMoveMarks = function(sMarkId)
	{
		return this.MoveMarks[sMarkId];
	};
	/**
	 * Получаем элементарное изменение связанное с заданным переносом, относящееся к метке переноса
	 * @param {string} sMoveId
	 * @param {boolean} isFrom
	 * @param {boolean} isStart
	 */
	CTrackRevisionsManager.prototype.GetMoveMarkChange = function(sMoveId, isFrom, isStart)
	{
		this.CompleteTrackChanges();

		var oMoveChanges = this.GetAllMoveChanges(sMoveId);
		var arrChanges   = isFrom ? oMoveChanges.From : oMoveChanges.To;

		for (var nIndex = 0, nCount = arrChanges.length; nIndex < nCount; ++nIndex)
		{
			var oChange = arrChanges[nIndex];
			if (Asc.c_oAscRevisionsChangeType.MoveMark === oChange.GetType())
			{
				var oMark = oChange.GetValue();
				if (oMark.IsFrom() === isFrom && oMark.IsStart() === isStart)
				{
					return oChange;
				}
			}
		}

		return null;
	};
	//--------------------------------------------------------export----------------------------------------------------
	window['AscWord'].CTrackRevisionsManager = CTrackRevisionsManager;
	window['AscWord'].checkElementInRevision = checkElementInRevision;

})(window);