/*
 * (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 logicDocument = null;
	let styleManager  = null;
	let styleCounter  = 0;

	const Key = {
		_0 : 48,
		_1 : 49,
		_2 : 50,
		_3 : 51,
		_4 : 52,
		_5 : 53,
		_6 : 54,
		_7 : 55,
		_8 : 56,
		_9 : 57,

		A : 65,
		B : 66,
		C : 67,
		D : 68,
		E : 69,
		F : 70,

		a : 97,
		b : 98,
		c : 99,
		d : 100,
		e : 101,
		f : 102,

		space : 32,
		backspace : 8,
		minus : 45,
		delete : 46,
		enter : 13
	};

	function IsKeyDown(key)
	{
		return (Key.space === key
			|| Key.backspace === key
			|| Key.enter === key
			|| Key.delete === key);
	}

	function CreateLogicDocument()
	{
		if (logicDocument)
			return logicDocument;

		logicDocument = new AscWord.CDocument(AscTest.DrawingDocument, true);
		logicDocument.Api = AscTest.Editor;
		logicDocument.On_EndLoad();

		AscTest.DrawingDocument.m_oLogicDocument = logicDocument;
		
		styleManager = logicDocument.GetStyleManager();

		return logicDocument;
	}
	function CreateParagraph()
	{
		return new AscWord.Paragraph();
	}
	function CreateRun()
	{
		return new AscWord.CRun();
	}
	function CreateTable(rows, cols, tableGrid)
	{
		let t = new AscWord.CTable(AscTest.DrawingDocument, null, true, rows, cols, tableGrid);
		t.CorrectBadTable();
		return t;
	}
	function CreateImage(w, h)
	{
		if (!logicDocument)
			return null;
		
		let drawingObjects = logicDocument.GetDrawingObjects();
		let drawing = new ParaDrawing(w, h, null, logicDocument.DrawingDocument, logicDocument, null);
		let image   = drawingObjects.createImage(AscCommon.g_sWordPlaceholderImage, 0, 0, w, h);
		image.setParent(drawing);
		drawing.Set_GraphicObject(image);
		return drawing;
	}
	function CreateStyle(styleType, name)
	{
		if (!styleManager)
			return null;
		
		if (!name)
			name = "style" + (++styleCounter);
		
		let style = new AscWord.CStyle(name, null, null, styleType);
		styleManager.Add(style);
		return style;
	}
	function CreateParagraphStyle(name)
	{
		return CreateStyle(styletype_Paragraph, name);
	}
	function CreateRunStyle(name)
	{
		return CreateStyle(styletype_Character, name);
	}
	function CreateMath()
	{
		let math = new AscWord.ParaMath();
		let run = new AscWord.CRun(null, true);
		math.Root.AddToContent(0, run);
		return math;
	}
	function CreateBlockLevelSdt()
	{
		return new AscWord.CBlockLevelSdt()
	}
	function CreateDefaultHeader(sectPr)
	{
		if (!sectPr || !logicDocument)
			return null;
		
		let header = new AscCommonWord.CHeaderFooter(logicDocument.HdrFtr, logicDocument, logicDocument.DrawingDocument, AscCommon.hdrftr_Header);
		sectPr.Set_Header_Default(header);
		return header.GetContent();
	}
	function GetParagraphText(paragraph)
	{
		return paragraph.GetText({
			ParaSeparator : "",
			TableCellSeparator : "",
			TableRowSeparator : "",
		});
	}
	function GetParagraphReviewText(paragraph)
	{
		let result = [];
		paragraph.CheckRunContent(function(run)
		{
			let text = run.GetText({
				ParaSeparator : "",
				Text : ""
			});
			if (!text || !text.length)
				return;
			
			let reviewType = run.GetReviewType();
			if (result.length && reviewType === result[result.length - 1][0])
				result[result.length - 1][1] += text;
			else
				result.push([reviewType, text]);
		});
		return result;
	}
	function GetBlockLevelSdtText(cc)
	{
		let result = "";
		cc.CheckRunContent(function(run)
		{
			result += run.GetText();
		});
		return result;
	}
	function GetBlockLevelSdtReviewText(cc)
	{
		let result = [];
		cc.CheckRunContent(function(run)
		{
			let text = run.GetText({
				ParaSeparator : "",
				Text : ""
			});
			if (!text || !text.length)
				return;
			
			let reviewType = run.GetReviewType();
			if (result.length && reviewType === result[result.length - 1][0])
				result[result.length - 1][1] += text;
			else
				result.push([reviewType, text]);
		});
		return result;
	}
	function RemoveTableBorders(table)
	{
		function CreateNoneBorder()
		{
			let border = new AscWord.CBorder();
			border.SetNone();
			return border;
		}

		table.Set_TableBorder_Left(CreateNoneBorder());
		table.Set_TableBorder_Top(CreateNoneBorder());
		table.Set_TableBorder_Right(CreateNoneBorder());
		table.Set_TableBorder_Bottom(CreateNoneBorder());
		table.Set_TableBorder_InsideH(CreateNoneBorder());
		table.Set_TableBorder_InsideV(CreateNoneBorder());
	}
	function RemoveTableMargins(table)
	{
		table.Set_TableCellMar(0, 0, 0, 0);
		
		for (let rowIndex = 0, rowCount = table.GetRowsCount(); rowIndex < rowIndex; ++rowIndex)
		{
			let row = table.GetRow(rowIndex);
			for (let cellIndex = 0, cellCount = table.GetCells; cellIndex < cellCount; ++cellIndex)
			{
				row.GetCell(cellIndex).Set_Margins(null);
			}
		}
	}
	function SetFillingFormMode(isOForm)
	{
		editor.restrictions = Asc.c_oAscRestrictionType.OnlyForms;

		if (isOForm)
			editor.DocInfo = {Format : "oform", isFormatWithForms : function() {return true;}};
		else
			editor.DocInfo = {Format : "docx", isFormatWithForms : function() {return false;}};
	}
	function SetEditingMode()
	{
		editor.restrictions = Asc.c_oAscRestrictionType.None;

		editor.DocInfo = {Format : "docx"};
	}
	function SetTrackRevisions(turnOn)
	{
		if (!logicDocument)
			return;
		
		logicDocument.SetLocalTrackRevisions(turnOn);
	}
	function AcceptAllRevisionChanges()
	{
		if (!logicDocument)
			return;
		
		logicDocument.AcceptAllRevisionChanges();
	}
	function RejectAllRevisionChanges()
	{
		if (!logicDocument)
			return;
		
		logicDocument.RejectAllRevisionChanges();
	}
	function AcceptRevisionChangesBySelection()
	{
		if (!logicDocument)
			return;
		
		logicDocument.AcceptRevisionChangesBySelection();
	}
	function RejectRevisionChangesBySelection()
	{
		if (!logicDocument)
			return;
		
		logicDocument.RejectRevisionChangesBySelection();
	}
	function PressKey(keyCode, isCtrl, isShift, isAlt)
	{
		if (!logicDocument)
			return;

		global_mouseEvent.CtrlKey  = !!isCtrl;
		global_mouseEvent.ShiftKey = !!isShift;
		global_mouseEvent.AltKey   = !!isAlt;
		global_mouseEvent.KeyCode  = keyCode;

		if (IsKeyDown(keyCode))
			logicDocument.OnKeyDown(global_mouseEvent);
		else
			logicDocument.OnKeyPress(global_mouseEvent);
	}
	function MoveCursorLeft(isShift, isCtrl, count)
	{
		if (!logicDocument)
			return;
		
		if (!count)
			count = 1;
		
		while (count)
		{
			logicDocument.MoveCursorLeft(!!isShift, !!isCtrl);
			--count;
		}
	}
	function MoveCursorRight(isShift, isCtrl, count)
	{
		if (!logicDocument)
			return;

		if (!count)
			count = 1;

		while (count)
		{
			logicDocument.MoveCursorRight(!!isShift, !!isCtrl, false);
			--count;
		}
	}
	function ClickMouseButton(x, y, page, isRight, count)
	{
		if (!logicDocument)
			return;

		let e = new AscCommon.CMouseEventHandler();

		e.Button     = isRight ? AscCommon.g_mouse_button_right : AscCommon.g_mouse_button_left;
		e.ClickCount = count ? count : 1;

		e.Type = AscCommon.g_mouse_event_type_down;
		logicDocument.OnMouseDown(e, x, y, page);

		e.Type = AscCommon.g_mouse_event_type_up;
		logicDocument.OnMouseUp(e, x, y, page);
	}
	function Recalculate()
	{
		if (!logicDocument)
			return;

		logicDocument.RecalculateFromStart(false);
	}
	function ClearDocument()
	{
		if (!logicDocument)
			return;

		logicDocument.RemoveFromContent(0, logicDocument.GetElementsCount(), false);
	}
	function ClearParagraph(p)
	{
		if (!p)
			return;
		
		p.RemoveFromContent(0, p.GetElementsCount());
	}
	function AddTextToParagraph(p, text)
	{
		let run = CreateRun();
		p.AddToContentToEnd(run);
		run.AddText(text);
		return run;
	}
	function EnterText(text)
	{
		if (!logicDocument)
			return;
		
		logicDocument.EnterText(text);
	}
	function CorrectEnterText(oldText, newText)
	{
		if (!logicDocument)
			return;

		logicDocument.CorrectEnterText(oldText, newText);
	}
	function BeginCompositeInput()
	{
		if (!logicDocument)
			return;

		logicDocument.getCompositeInput().begin();
	}
	function ReplaceCompositeInput(text)
	{
		if (!logicDocument)
			return;

		logicDocument.getCompositeInput().replace(text);
	}
	function EndCompositeInput()
	{
		if (!logicDocument)
			return;

		logicDocument.getCompositeInput().end();
	}
	function EnterTextCompositeInput(text)
	{
		BeginCompositeInput();
		ReplaceCompositeInput(text);
		EndCompositeInput();
	}
	function MoveCursorToParagraph(paragraph, isToStart)
	{
		if (!paragraph || !(paragraph instanceof AscWord.Paragraph))
			return;
		
		paragraph.SetThisElementCurrent();
		
		if (false === isToStart)
			paragraph.MoveCursorToEndPos();
		else
			paragraph.MoveCursorToStartPos();
	}
	function AddNumbering(type, subtype)
	{
		if (!logicDocument)
			return;
		
		let numObject = AscWord.GetNumberingObjectByDeprecatedTypes(type, subtype);
		if (!numObject)
			return;
		
		let _numInfo = numObject;
		if (typeof _numInfo === "string" || _numInfo instanceof String)
		{
			try
			{
				_numInfo = JSON.parse(numInfo);
			}
			catch (e)
			{
				return;
			}
		}
		
		logicDocument.SetParagraphNumbering(_numInfo);
	}
	function SetParagraphNumberingLvl(paragraph, iLvl)
	{
		let numPr = paragraph.GetNumPr();
		if (!numPr)
			return;
		
		paragraph.SetNumPr(numPr.NumId, iLvl)
	}
	function SelectDocumentRange(startPos, endPos)
	{
		if (!logicDocument)
			return;
		
		logicDocument.RemoveSelection();
		logicDocument.Selection.Use = true;
		logicDocument.Selection.StartPos = startPos;
		logicDocument.Selection.EndPos   = endPos;

		let direction = startPos < endPos ? 1 : -1;
		for (let pos = startPos; pos <= endPos; ++pos)
		{
			logicDocument.Content[pos].SelectAll(direction);
		}
	}
	function SelectParagraphRange(paragraph, start, end)
	{
		if (!paragraph || start >= end)
			return;
		
		if (logicDocument)
			logicDocument.RemoveSelection();
		
		paragraph.RemoveSelection();
		paragraph.MoveCursorToStartPos();
		for (let i = 0; i < start; ++i)
			paragraph.MoveCursorRight(false, false);
		
		let startPos = paragraph.getCurrentPos();
		for (let i = start; i < end; ++i)
			paragraph.MoveCursorRight(false, false);
		
		let endPos = paragraph.getCurrentPos();
		paragraph.StartSelectionFromCurPos();
		paragraph.SetSelectionContentPos(startPos, endPos, false);
		paragraph.Document_SetThisElementCurrent();
	}
	function SelectParagraph(paragraph)
	{
		if (logicDocument)
			logicDocument.RemoveSelection();
		
		paragraph.SelectAll();
		paragraph.Document_SetThisElementCurrent();
	}
	function GetFinalSection()
	{
		if (!logicDocument)
			return null;
		
		return logicDocument.SectPr;
	}
	function SetCompatibilityMode(mode)
	{
		if (!logicDocument)
			return;
		
		logicDocument.Settings.CompatibilityMode = mode;
	}
	function StartCollaboration()
	{
		AscCommon.CollaborativeEditing.Start_CollaborationEditing();
		if (logicDocument)
			logicDocument.StartCollaborationEditing();
		
		SyncCollaboration();
	}
	function SyncCollaboration()
	{
		AscCommon.CollaborativeEditing.Send_Changes();
		
	}
	function EndCollaboration()
	{
		AscCommon.CollaborativeEditing.End_CollaborationEditing();
	}
	function StartTextSpeaker()
	{
		AscCommon.EditorActionSpeaker.run();
	}
	function StopTextSpeaker()
	{
		AscCommon.EditorActionSpeaker.stop();
	}
	function SelectTableCells(table, startCell, startRow, endCell, endRow)
	{
		if (!logicDocument)
			return;
		
		logicDocument.RemoveSelection();
		// TODO: Get rid of double SelectRange
		table.SelectRange(startCell, startRow, endCell, endRow);
		table.Document_SetThisElementCurrent();
		table.SelectRange(startCell, startRow, endCell, endRow);
	}
	function MergeTableCells(table, startCell, startRow, endCell, endRow)
	{
		SelectTableCells(table, startCell, startRow, endCell, endRow);
		table.MergeTableCells(true);
	}
	
	//--------------------------------------------------------export----------------------------------------------------
	AscTest.CreateLogicDocument              = CreateLogicDocument;
	AscTest.GetLogicDocument                 = CreateLogicDocument;
	AscTest.CreateParagraph                  = CreateParagraph;
	AscTest.CreateRun                        = CreateRun;
	AscTest.CreateTable                      = CreateTable;
	AscTest.CreateImage                      = CreateImage;
	AscTest.CreateStyle                      = CreateStyle;
	AscTest.CreateParagraphStyle             = CreateParagraphStyle;
	AscTest.CreateRunStyle                   = CreateRunStyle;
	AscTest.CreateMath                       = CreateMath;
	AscTest.CreateBlockLvlSdt                = CreateBlockLevelSdt;
	AscTest.CreateDefaultHeader              = CreateDefaultHeader;
	AscTest.GetParagraphText                 = GetParagraphText;
	AscTest.GetParagraphReviewText           = GetParagraphReviewText;
	AscTest.GetBlockLevelSdtText             = GetBlockLevelSdtText;
	AscTest.GetBlockLevelSdtReviewText       = GetBlockLevelSdtReviewText;
	AscTest.RemoveTableBorders               = RemoveTableBorders;
	AscTest.RemoveTableMargins               = RemoveTableMargins;
	AscTest.SetFillingFormMode               = SetFillingFormMode;
	AscTest.SetEditingMode                   = SetEditingMode;
	AscTest.SetTrackRevisions                = SetTrackRevisions;
	AscTest.AcceptAllRevisionChanges         = AcceptAllRevisionChanges;
	AscTest.RejectAllRevisionChanges         = RejectAllRevisionChanges;
	AscTest.AcceptRevisionChangesBySelection = AcceptRevisionChangesBySelection;
	AscTest.RejectRevisionChangesBySelection = RejectRevisionChangesBySelection;
	AscTest.PressKey                         = PressKey;
	AscTest.MoveCursorLeft                   = MoveCursorLeft;
	AscTest.MoveCursorRight                  = MoveCursorRight;
	AscTest.Recalculate                      = Recalculate;
	AscTest.ClickMouseButton                 = ClickMouseButton;
	AscTest.ClearDocument                    = ClearDocument;
	AscTest.ClearParagraph                   = ClearParagraph;
	AscTest.AddTextToParagraph               = AddTextToParagraph;
	AscTest.EnterText                        = EnterText;
	AscTest.CorrectEnterText                 = CorrectEnterText;
	AscTest.BeginCompositeInput              = BeginCompositeInput;
	AscTest.ReplaceCompositeInput            = ReplaceCompositeInput;
	AscTest.EndCompositeInput                = EndCompositeInput;
	AscTest.EnterTextCompositeInput          = EnterTextCompositeInput;
	AscTest.Key                              = Key;
	AscTest.MoveCursorToParagraph            = MoveCursorToParagraph;
	AscTest.AddNumbering                     = AddNumbering;
	AscTest.SetParagraphNumberingLvl         = SetParagraphNumberingLvl;
	AscTest.SelectDocumentRange              = SelectDocumentRange;
	AscTest.GetFinalSection                  = GetFinalSection;
	AscTest.SetCompatibilityMode             = SetCompatibilityMode;
	AscTest.StartCollaboration               = StartCollaboration;
	AscTest.SyncCollaboration                = SyncCollaboration;
	AscTest.EndCollaboration                 = EndCollaboration;
	AscTest.SelectParagraphRange             = SelectParagraphRange;
	AscTest.SelectParagraph                  = SelectParagraph;
	AscTest.StartTextSpeaker                 = StartTextSpeaker;
	AscTest.StopTextSpeaker                  = StopTextSpeaker;
	AscTest.SelectTableCells                 = SelectTableCells;
	AscTest.MergeTableCells                  = MergeTableCells;

})(window);