/*
 * (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)
{
	/**
	 * Механизм поиска. Хранит параграфы с найденной строкой
	 * @constructor
	 */
	function CDocumentSearch(oLogicDocument)
	{
		this.LogicDocument = oLogicDocument;
		this.Text          = "";
		this.MatchCase     = false;
		this.Word          = false;
		this.Pattern       = new AscCommonWord.CSearchPatternEngine();

		this.Prefix        = [];

		this.Id            = 0;
		this.Count         = 0;
		this.Elements      = {};
		this.ReplacedId    = [];
		this.CurId         = -1;
		this.Direction     = true; // направление true - вперед, false - назад
		this.ClearOnRecalc = true; // Флаг, говорящий о том, запустился ли пересчет из-за Replace
		this.Selection     = false;
		this.Footnotes     = [];
		this.Endnotes      = [];
		this.InsertPattern = new AscCommonWord.CSearchPatternEngine();

		this.TextAroundId     = -1;
		this.TextAroundTimer  = null;
		this.TextAroundUpdate = true;
		this.ReplaceEvent     = true;
		this.TextAroundEmpty  = true; // Флаг, что все очищено, чтобы не очищать повторно
	}

	CDocumentSearch.prototype.Reset = function()
	{
		this.Text      = "";
		this.MatchCase = false;
		this.Word	   = false;
	};
	/**
	 * @param {AscCommon.CSearchSettings} oProps
	 */
	CDocumentSearch.prototype.Compare = function(oProps)
	{
		return (oProps && this.Text === oProps.GetText()
			&& this.MatchCase === oProps.IsMatchCase()
			&& this.Word === oProps.IsWholeWords());
	};
	CDocumentSearch.prototype.Clear = function()
	{
		this.Reset();

		// Очищаем предыдущие элементы поиска
		for (var Id in this.Elements)
		{
			this.Elements[Id].ClearSearchResults();
		}

		this.Id         = 0;
		this.Count      = 0;
		this.Elements   = {};
		this.ReplacedId = [];
		this.CurId      = -1;
		this.Direction  = true;

		this.TextAroundUpdate = true;
		this.StopTextAround();
		this.SendClearAllTextAround();
	};
	CDocumentSearch.prototype.Add = function(Paragraph)
	{
		this.Count++;
		this.Elements[this.Id++] = Paragraph;
		return (this.Id - 1);
	};
	CDocumentSearch.prototype.GetElementsMap = function()
	{
		let map = {};
		for (let searchId in this.Elements)
		{
			let paraId = this.Elements[searchId].GetId();
			if (!map[paraId])
				map[paraId] = this.Elements[searchId];
		}
		return map;
	};
	CDocumentSearch.prototype.Select = function(nId, bUpdateStates)
	{
		var Paragraph = this.Elements[nId];
		if (Paragraph)
		{
			var SearchElement = Paragraph.SearchResults[nId];
			if (SearchElement)
			{
				Paragraph.Selection.Use   = true;
				Paragraph.Selection.Start = false;

				Paragraph.Set_SelectionContentPos(SearchElement.StartPos, SearchElement.EndPos);
				Paragraph.Set_ParaContentPos(SearchElement.StartPos, false, -1, -1);

				Paragraph.Document_SetThisElementCurrent(false !== bUpdateStates);
			}

			this.SetCurrent(nId);
		}
	};
	CDocumentSearch.prototype.SetCurrent = function(nId)
	{
		this.CurId = undefined !== nId ? nId : -1;
		let nIndex = -1 !== this.CurId ? this.GetElementIndexById(this.CurId) : -1;

		let oApi = this.LogicDocument.GetApi()
		oApi.sync_setSearchCurrent(nIndex, this.Count);
	};
	CDocumentSearch.prototype.ResetCurrent = function()
	{
		this.SetCurrent(-1);
	};
	CDocumentSearch.prototype.GetCount = function()
	{
		return this.Count;
	};
	CDocumentSearch.prototype.GetCurrent = function()
	{
		return this.CurId;
	};
	CDocumentSearch.prototype.Replace = function(sReplaceString, Id, bRestorePos)
	{
		this.InsertPattern.Set(sReplaceString);

		var oPara = this.Elements[Id];
		if (oPara)
		{
			if (oPara.IsInPlaceholder())
				return false;
			
			var oLogicDocument   = oPara.LogicDocument;
			var isTrackRevisions = oLogicDocument ? oLogicDocument.IsTrackRevisions() : false;

			var SearchElement = oPara.SearchResults[Id];
			if (SearchElement)
			{
				if (oPara.GetPlaceHolderObject(SearchElement.StartPos)
					|| oPara.GetPlaceHolderObject(SearchElement.EndPos))
					return false;
				
				var ContentPos, StartPos, EndPos, bSelection;
				if (true === bRestorePos)
				{
					// Сохраняем позицию состояние параграфа, чтобы курсор остался в том же месте и после замены.
					bSelection = oPara.IsSelectionUse();
					ContentPos = oPara.Get_ParaContentPos(false, false);
					StartPos   = oPara.Get_ParaContentPos(true, true);
					EndPos     = oPara.Get_ParaContentPos(true, false);

					oPara.Check_NearestPos({ContentPos : ContentPos});
					oPara.Check_NearestPos({ContentPos : StartPos});
					oPara.Check_NearestPos({ContentPos : EndPos});
				}

				if (isTrackRevisions)
				{
					// Встанем в конечную позицию поиска и добавим новый текст
					var oEndContentPos = SearchElement.EndPos;
					var oEndRun        = SearchElement.ClassesE[SearchElement.ClassesE.length - 1];

					var nRunPos = oEndContentPos.Get(SearchElement.ClassesE.length - 1);

					if (reviewtype_Add === oEndRun.GetReviewType() && oEndRun.GetReviewInfo().IsCurrentUser())
					{
						this.private_AddReplacedStringToRun(oEndRun, nRunPos);
					}
					else
					{
						var oRunParent      = oEndRun.GetParent();
						var nRunPosInParent = oEndRun.GetPosInParent(oRunParent);
						var oReplaceRun     = oEndRun.Split2(nRunPos, oRunParent, nRunPosInParent);

						if (!oReplaceRun.IsEmpty())
							oReplaceRun.Split2(0, oRunParent, nRunPosInParent + 1);

						this.private_AddReplacedStringToRun(oReplaceRun, 0);
						oReplaceRun.SetReviewType(reviewtype_Add);
					}
				}
				else
				{
					// Сначала в начальную позицию поиска добавляем новый текст
					var StartContentPos = SearchElement.StartPos;
					var StartRun        = SearchElement.ClassesS[SearchElement.ClassesS.length - 1];

					var RunPos = StartContentPos.Get(SearchElement.ClassesS.length - 1);
					this.private_AddReplacedStringToRun(StartRun, RunPos);
				}

				// Выделяем старый объект поиска и удаляем его
				oPara.Selection.Use = true;
				oPara.Set_SelectionContentPos(SearchElement.StartPos, SearchElement.EndPos);
				oPara.Remove();

				// Перемещаем курсор в конец поиска
				oPara.RemoveSelection();
				oPara.Set_ParaContentPos(SearchElement.StartPos, true, -1, -1);

				// Удаляем запись о данном элементе
				this.Count--;

				oPara.RemoveSearchResult(Id);
				delete this.Elements[Id];
				this.private_AddReplacedId(Id);

				if (true === bRestorePos)
				{
					oPara.Set_SelectionContentPos(StartPos, EndPos);
					oPara.Set_ParaContentPos(ContentPos, true, -1, -1);
					oPara.Selection.Use = bSelection;
					oPara.Clear_NearestPosArray();
				}

				if (this.ReplaceEvent && !this.TextAroundUpdate)
					this.LogicDocument.GetApi().sync_removeTextAroundSearch(Id);

				return true;
			}
		}

		return false;
	};
	CDocumentSearch.prototype.private_AddReplacedId = function(nId)
	{
		for (let nPos = 0, nCount = this.ReplacedId.length; nPos < nCount; ++nPos)
		{
			if (this.ReplacedId[nPos] > nId)
				return this.ReplacedId.splice(nPos, 0, nId);
		}

		this.ReplacedId.push(nId);
	};
	CDocumentSearch.prototype.private_AddReplacedStringToRun = function(oRun, nInRunPos)
	{
		var isMathRun = oRun.IsMathRun();
		for (var nIndex = 0, nAdd = 0, nCount = this.InsertPattern.GetLength(); nIndex < nCount; ++nIndex)
		{
			var oItem = this.InsertPattern.Get(nIndex).ToRunElement(isMathRun);
			if (oItem)
			{
				oRun.AddToContent(nInRunPos + nAdd, oItem, false);
				nAdd++;
			}
		}
	};
	CDocumentSearch.prototype.GetElementIndexById = function(nId)
	{
		for (let nPos = 0, nCount = this.ReplacedId.length; nPos < nCount; ++nPos)
		{
			if (this.ReplacedId[nPos] > nId)
				return (nId - nPos);
			else if (this.ReplacedId[nPos] === nId)
				return -1;
		}

		return (nId - this.ReplacedId.length);
	};
	CDocumentSearch.prototype.ReplaceAll = function(NewStr, bUpdateStates)
	{
		this.RemoveEvent = false;

		for (var Id = this.Id; Id >= 0; --Id)
		{
			if (this.Elements[Id])
				this.Replace(NewStr, Id, true);
		}

		this.RemoveEvent = true;

		this.Clear();
	};
	/**
	 * @param {AscCommon.CSearchSettings} oProps
	 */
	CDocumentSearch.prototype.Set = function(oProps)
	{
		if (!oProps)
			return;

		this.Text      = oProps.GetText();
		this.MatchCase = oProps.IsMatchCase();
		this.Word      = oProps.IsWholeWords();

		var _sText = this.Text;
		if (!this.MatchCase)
			_sText = this.Text.toLowerCase();

		this.Pattern.Set(_sText);
		this.private_CalculatePrefix();
	};
	CDocumentSearch.prototype.IsWholeWords = function()
	{
		return this.Word;
	};
	CDocumentSearch.prototype.IsMatchCase = function()
	{
		return this.MatchCase;
	};
	CDocumentSearch.prototype.SetFootnotes = function(arrFootnotes)
	{
		this.Footnotes = arrFootnotes;
	};
	CDocumentSearch.prototype.SetEndnotes = function(arrEndnotes)
	{
		this.Endnotes = arrEndnotes;
	};
	CDocumentSearch.prototype.GetFootnotes = function()
	{
		return this.Footnotes;
	};
	CDocumentSearch.prototype.GetEndnotes = function()
	{
		return this.Endnotes;
	};
	CDocumentSearch.prototype.GetDirection = function()
	{
		return this.Direction;
	};
	CDocumentSearch.prototype.SetDirection = function(bDirection)
	{
		this.Direction = bDirection;
	};
	CDocumentSearch.prototype.private_CalculatePrefix = function()
	{
		var nLen = this.Pattern.GetLength();

		this.Prefix    = new Int32Array(nLen);
		this.Prefix[0] = 0;

		for (var nPos = 1, nK = 0; nPos < nLen; ++nPos)
		{
			nK = this.Prefix[nPos - 1]
			while (nK > 0 && !(this.Pattern.Get(nPos).IsMatch(this.Pattern.Get(nK))))
				nK = this.Prefix[nK - 1];

			if (this.Pattern.Get(nPos).IsMatch(this.Pattern.Get(nK)))
				nK++;

			this.Prefix[nPos] = nK;
		}
	};
	CDocumentSearch.prototype.GetPrefix = function(nIndex)
	{
		return this.Prefix[nIndex];
	};
	CDocumentSearch.prototype.StartTextAround = function()
	{
		if (!this.TextAroundUpdate)
			return this.SendAllTextAround();

		this.TextAroundUpdate = false;
		this.StopTextAround();

		this.TextAroundId = 0;

		this.LogicDocument.GetApi().sync_startTextAroundSearch();

		let oThis = this;
		this.TextAroundTimer = setTimeout(function()
		{
			oThis.ContinueGetTextAround()
		}, 20);

		this.TextArround = [];
	};
	CDocumentSearch.prototype.ContinueGetTextAround = function()
	{
		let arrResult = [];

		let nStartTime = performance.now();
		while (performance.now() - nStartTime < 20)
		{
			if (this.TextAroundId >= this.Id)
				break;

			let sId = this.TextAroundId++;

			if (!this.Elements[sId])
				continue;

			let textAround = this.Elements[sId].GetTextAroundSearchResult(sId);
			this.TextArround[sId] = textAround;
			arrResult.push([sId, textAround]);
		}

		if (arrResult.length)
			this.TextAroundEmpty = false;

		this.LogicDocument.GetApi().sync_getTextAroundSearchPack(arrResult);

		let oThis = this;
		if (this.TextAroundId >= 0 && this.TextAroundId < this.Id)
		{
			this.TextAroundTimer = setTimeout(function()
			{
				oThis.ContinueGetTextAround();
			}, 20);
		}
		else
		{
			this.TextAroundId    = -1;
			this.TextAroundTimer = null;
			this.LogicDocument.GetApi().sync_endTextAroundSearch();
		}
	};
	CDocumentSearch.prototype.StopTextAround = function()
	{
		if (this.TextAroundTimer)
		{
			clearTimeout(this.TextAroundTimer);
			this.LogicDocument.GetApi().sync_endTextAroundSearch();
		}

		this.TextAroundTimer = null;
		this.TextAroundId    = -1;
	};
	CDocumentSearch.prototype.SendAllTextAround = function()
	{
		if (this.TextAroundTimer)
			return;

		let arrResult = [];
		for (let nId = 0; nId < this.Id; ++nId)
		{
			if (!this.Elements[nId] || undefined === this.TextArround[nId])
				continue;

			arrResult.push([nId, this.TextArround[nId]]);
		}

		let oApi = this.LogicDocument.GetApi();
		oApi.sync_startTextAroundSearch();
		oApi.sync_getTextAroundSearchPack(arrResult);
		oApi.sync_endTextAroundSearch();
	};
	CDocumentSearch.prototype.SendClearAllTextAround = function()
	{
		if (this.TextAroundEmpty)
			return;

		let oApi = this.LogicDocument.GetApi();
		if (!oApi)
			return;

		oApi.sync_startTextAroundSearch();
		oApi.sync_endTextAroundSearch();

		this.TextAroundEmpty = true;
	};

	//--------------------------------------------------------export----------------------------------------------------
	window['AscCommonWord'] = window['AscCommonWord'] || {};
	window['AscCommonWord'].CDocumentSearch = CDocumentSearch;

})(window);