/*
 * (c) Copyright Ascensio System SIA 2010-2025
 *
 * 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()
{
	/**
	 * @constructor
	 */
	function DocumentPageSection()
	{
		this.Pos    = 0;
		this.EndPos = -1;
		
		this.ResetSectionStart = false; // Если секция разбилась внутри блочного контент контрола
		
		this.Y      = 0;
		this.YLimit = 0;
		
		this.YLimit2 = 0;
		
		this.Index   = -1;
		this.SectPr  = null;
		
		this.Columns = [];
		this.ColumnsSep = false;
		
		this.IterationsCount       = 0;
		this.CurrentY              = 0;
		this.RecalculateBottomLine = true;
		this.CanDecrease           = true;
		this.WasIncrease           = false; // Было ли хоть раз увеличение
		this.IterationStep         = 10;
		this.IterationDirection    = 0;
	}
	/**
	 * Инициализируем параметры данной секции
	 * @param {number} nPageAbs
	 * @param {AscWord.SectPr} oSectPr
	 * @param {Number} nSectionIndex
	 */
	DocumentPageSection.prototype.Init = function(nPageAbs, oSectPr, nSectionIndex)
	{
		var oFrame  = oSectPr.GetContentFrame(nPageAbs);
		var nX      = oFrame.Left;
		var nXLimit = oFrame.Right;
		
		for (var nCurColumn = 0, nColumnsCount = oSectPr.GetColumnCount(); nCurColumn < nColumnsCount; ++nCurColumn)
		{
			this.Columns[nCurColumn] = new AscWord.DocumentPageColumn();
			
			this.Columns[nCurColumn].X      = nX;
			this.Columns[nCurColumn].XLimit = nColumnsCount - 1 === nCurColumn ? nXLimit : nX + oSectPr.GetColumnWidth(nCurColumn);
			
			nX += oSectPr.GetColumnWidth(nCurColumn) + oSectPr.GetColumnSpace(nCurColumn);
		}
		this.ColumnsSep = oSectPr.GetColumnSep();
		
		this.Y       = oFrame.Top;
		this.YLimit  = oFrame.Bottom;
		this.YLimit2 = oFrame.Bottom;
		this.Index   = nSectionIndex;
		this.SectPr  = oSectPr;
	};
	DocumentPageSection.prototype.GetIndex = function()
	{
		return this.Index;
	};
	DocumentPageSection.prototype.GetSectPr = function()
	{
		return this.SectPr;
	};
	DocumentPageSection.prototype.Copy = function()
	{
		var NewSection = new DocumentPageSection();
		
		NewSection.Pos    = this.Pos;
		NewSection.EndPos = this.EndPos;
		NewSection.Y      = this.Y;
		NewSection.YLimit = this.YLimit;
		
		for (var ColumnIndex = 0, Count = this.Columns.length; ColumnIndex < Count; ++ColumnIndex)
		{
			NewSection.Columns[ColumnIndex] = this.Columns[ColumnIndex].Copy();
		}
		
		return NewSection;
	};
	DocumentPageSection.prototype.Shift = function(Dx, Dy)
	{
		this.Y      += Dy;
		this.YLimit += Dy;
		
		for (var ColumnIndex = 0, Count = this.Columns.length; ColumnIndex < Count; ++ColumnIndex)
		{
			this.Columns[ColumnIndex].Shift(Dx, Dy);
		}
	};
	DocumentPageSection.prototype.CorrectY = function(y)
	{
		return (y < this.Y ? this.Y : (y > this.YLimit ? this.YLimit : y));
	};
	/**
	 * Происходи ли процесс расчета нижней границы разрыва секции на текущей странице
	 * @returns {boolean}
	 */
	DocumentPageSection.prototype.IsCalculatingSectionBottomLine = function()
	{
		return (this.IterationsCount > 0 && true === this.RecalculateBottomLine);
	};
	/**
	 * Можно ли расчитывать нижнюю границу разрыва секции на текущей странице
	 * @returns {boolean}
	 */
	DocumentPageSection.prototype.CanRecalculateBottomLine = function()
	{
		return this.RecalculateBottomLine;
	};
	/**
	 * Запрещаем возможность расчета нижней границы разрыва секции на текущей страницы
	 */
	DocumentPageSection.prototype.ForbidRecalculateBottomLine = function()
	{
		this.RecalculateBottomLine = false;
	};
	DocumentPageSection.prototype.GetY = function()
	{
		return this.Y;
	};
	DocumentPageSection.prototype.GetYLimit = function()
	{
		if (0 === this.IterationsCount)
			return this.YLimit;
		else
			return this.CurrentY;
	};
	/**
	 * Производим шаг рассчета нижней границы рарзрыва секции
	 * @param {boolean} isIncrease
	 * @returns {number}
	 */
	DocumentPageSection.prototype.IterateBottomLineCalculation = function(isIncrease)
	{
		// Алгоритм следующий:
		// На первом шаге мы прогнозируем положение границы по уже имеющемуся объему текста и
		// ширине колонок.
		// Далее мы сдвигаем границу на значение IterationStep, вверх или вниз в зависимости
		// от результата расчета страницы. При перемене направления сдвига мы всегда уменьшаем шаг
		// в 2 раза. Также мы можем уменьшать шаг в 2 раза, если сдвигаем границу вверх, и хотябы
		// раз до этого двигали ее вниз. Останавливаем итерацию при попытке подвинуть границу наверх,
		// когда шаг итерации становится менее 2мм.
		
		if (0 === this.IterationsCount)
		{
			// Пытаемся заранее спрогнозировать позицию, где должно быть разделение. Учитывая, что колонки могут быть разной
			// ширины, мы расчитываем суммарную занимаемую текстом область. Делим ее по колонкам, с учетом их суммарной
			// ширины.
			
			var nSumArea = 0, nSumWidth = 0;
			for (var nColumnIndex = 0, nColumnsCount = this.Columns.length; nColumnIndex < nColumnsCount; ++nColumnIndex)
			{
				var oColumn = this.Columns[nColumnIndex];
				if (true !== oColumn.Empty)
					nSumArea += (oColumn.Bounds.Bottom - this.Y) * (oColumn.XLimit - oColumn.X);
				
				nSumWidth += oColumn.XLimit - oColumn.X;
			}
			
			if (nSumWidth > 0.001)
				this.CurrentY = this.Y + nSumArea / nSumWidth;
			else
				this.CurrentY = this.Y;
		}
		else
		{
			if (false === isIncrease)
			{
				if (this.IterationDirection > 0 || this.WasIncrease)
					this.IterationStep /= 2;
				
				this.CurrentY -= this.IterationStep;
				this.IterationDirection = -1;
				
				if (this.CurrentY < this.Y)
				{
					// Такое может быть, когда у нас всего одна строка в начале страницы, которую мы размещаем всегда
					this.CurrentY    = this.Y;
					this.CanDecrease = false;
				}
			}
			else
			{
				if (this.IterationDirection < 0)
					this.IterationStep /= 2;
				
				this.CurrentY += this.IterationStep;
				this.IterationDirection = 1;
				
				this.WasIncrease = true;
			}
		}
		
		if (this.IterationStep < 2)
			this.CanDecrease = false;
		
		this.CurrentY = Math.min(this.CurrentY, this.YLimit2);
		
		// // Recalculation LOG
		// console.log(`Calculate continuous section count=${this.IterationsCount} step=${this.IterationStep} Y=${this.CurrentY}`);
		
		this.IterationsCount++;
		return this.CurrentY;
	};
	DocumentPageSection.prototype.Reset_Columns = function()
	{
		for (var ColumnIndex = 0, Count = this.Columns.length; ColumnIndex < Count; ++ColumnIndex)
		{
			this.Columns[ColumnIndex].Reset();
		}
	};
	/**
	 * Можем ли мы провести еще одну итерацию с уменьшением нижней границы
	 * @returns {boolean}
	 */
	DocumentPageSection.prototype.CanDecreaseBottomLine = function()
	{
		return this.CanDecrease;
	};
	DocumentPageSection.prototype.CanIncreaseBottomLine = function()
	{
		// Данная функция не должна возвращать false, если возвращает, значит неправильно работает алгоритм по вычислению
		// нижней границы continuous секции
		// if (!(this.YLimit2 - this.CurrentY > 0.001))
		// 	console.log("Bad continuous section calculate");
		
		return (this.YLimit2 - this.CurrentY > 0.001);
	};
	DocumentPageSection.prototype.GetBottomLimit = function()
	{
		let bottomLimit = this.Y;
		for (let column = 0, columnCount = this.Columns.length; column < columnCount; ++column)
		{
			bottomLimit = Math.max(bottomLimit, this.Columns[column].Bounds.Bottom);
		}
		return bottomLimit;
	};
	//--------------------------------------------------------export----------------------------------------------------
	AscWord.DocumentPageSection = DocumentPageSection;
	
})();