/*
 * Copyright 2022 Peter Han
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

//#define DEBUG_LAYOUT
using PeterHan.PLib.UI.Layouts;
using System;
using UnityEngine;
using UnityEngine.UI;

namespace PeterHan.PLib.UI {
	/// <summary>
	/// A freezable, flexible layout manager that fixes the issues I am having with
	/// HorizontalLayoutGroup and VerticalLayoutGroup. You get a content size fitter for
	/// free too!
	/// 
	/// Intended to work something like Java's BoxLayout...
	/// </summary>
	public sealed class BoxLayoutGroup : AbstractLayoutGroup {
		/// <summary>
		/// Calculates the size of the box layout container.
		/// </summary>
		/// <param name="obj">The container to lay out.</param>
		/// <param name="args">The parameters to use for layout.</param>
		/// <param name="direction">The direction which is being calculated.</param>
		/// <returns>The minimum and preferred box layout size.</returns>
		private static BoxLayoutResults Calc(GameObject obj, BoxLayoutParams args,
				PanelDirection direction) {
			var transform = obj.AddOrGet<RectTransform>();
			int n = transform.childCount;
			var result = new BoxLayoutResults(direction, n);
			var components = ListPool<Component, BoxLayoutGroup>.Allocate();
			for (int i = 0; i < n; i++) {
				var child = transform.GetChild(i)?.gameObject;
				if (child != null && child.activeInHierarchy) {
					// Only on active game objects
					components.Clear();
					child.GetComponents(components);
					var hc = PUIUtils.CalcSizes(child, direction, components);
					if (!hc.ignore) {
						if (args.Direction == direction)
							result.Accum(hc, args.Spacing);
						else
							result.Expand(hc);
						result.children.Add(hc);
					}
				}
			}
			components.Recycle();
			return result;
		}

		/// <summary>
		/// Lays out components in the box layout container.
		/// </summary>
		/// <param name="args">The parameters to use for layout.</param>
		/// <param name="required">The calculated minimum and preferred sizes.</param>
		/// <param name="size">The total available size in this dimension.</param>
		private static void DoLayout(BoxLayoutParams args, BoxLayoutResults required,
				float size) {
			if (required == null)
				throw new ArgumentNullException(nameof(required));
			var direction = required.direction;
			var status = new BoxLayoutStatus(direction, args.Margin ?? new RectOffset(), size);
			if (args.Direction == direction)
				DoLayoutLinear(required, args, status);
			else
				DoLayoutPerp(required, args, status);
		}

		/// <summary>
		/// Lays out components in the box layout container parallel to the layout axis.
		/// </summary>
		/// <param name="required">The calculated minimum and preferred sizes.</param>
		/// <param name="args">The parameters to use for layout.</param>
		/// <param name="status">The current status of layout.</param>
		private static void DoLayoutLinear(BoxLayoutResults required, BoxLayoutParams args,
				BoxLayoutStatus status) {
			var total = required.total;
			var components = ListPool<ILayoutController, BoxLayoutGroup>.Allocate();
			var direction = args.Direction;
			// Determine flex size ratio
			float size = status.size, prefRatio = 0.0f, minSize = total.min, prefSize =
				total.preferred, excess = Math.Max(0.0f, size - prefSize), flexTotal = total.
				flexible, offset = status.offset, spacing = args.Spacing;
			if (size > minSize && prefSize > minSize)
				// Do not divide by 0
				prefRatio = Math.Min(1.0f, (size - minSize) / (prefSize - minSize));
			if (excess > 0.0f && flexTotal == 0.0f)
				// If no components can be expanded, offset all
				offset += PUIUtils.GetOffset(args.Alignment, status.direction, excess);
			foreach (var child in required.children) {
				var obj = child.source;
				// Active objects only
				if (obj != null && obj.activeInHierarchy) {
					float compSize = child.min;
					if (prefRatio > 0.0f)
						compSize += (child.preferred - child.min) * prefRatio;
					if (excess > 0.0f && flexTotal > 0.0f)
						compSize += excess * child.flexible / flexTotal;
					// Place and size component
					obj.AddOrGet<RectTransform>().SetInsetAndSizeFromParentEdge(status.edge,
						offset, compSize);
					offset += compSize + ((compSize > 0.0f) ? spacing : 0.0f);
					// Invoke SetLayout on dependents
					components.Clear();
					obj.GetComponents(components);
					foreach (var component in components)
						if (direction == PanelDirection.Horizontal)
							component.SetLayoutHorizontal();
						else // if (direction == PanelDirection.Vertical)
							component.SetLayoutVertical();
				}
			}
			components.Recycle();
		}

		/// <summary>
		/// Lays out components in the box layout container against the layout axis.
		/// </summary>
		/// <param name="required">The calculated minimum and preferred sizes.</param>
		/// <param name="args">The parameters to use for layout.</param>
		/// <param name="status">The current status of layout.</param>
		private static void DoLayoutPerp(BoxLayoutResults required, BoxLayoutParams args,
				BoxLayoutStatus status) {
			var components = ListPool<ILayoutController, BoxLayoutGroup>.Allocate();
			var direction = args.Direction;
			float size = status.size;
			foreach (var child in required.children) {
				var obj = child.source;
				// Active objects only
				if (obj != null && obj.activeInHierarchy) {
					float compSize = size;
					if (child.flexible <= 0.0f)
						// Does not expand to all
						compSize = Math.Min(compSize, child.preferred);
					float offset = (size > compSize) ? PUIUtils.GetOffset(args.Alignment,
						status.direction, size - compSize) : 0.0f;
					// Place and size component
					obj.AddOrGet<RectTransform>().SetInsetAndSizeFromParentEdge(status.edge,
						offset + status.offset, compSize);
					// Invoke SetLayout on dependents
					components.Clear();
					obj.GetComponents(components);
					foreach (var component in components)
						if (direction == PanelDirection.Horizontal)
							component.SetLayoutVertical();
						else // if (direction == PanelDirection.Vertical)
							component.SetLayoutHorizontal();
				}
			}
			components.Recycle();
		}

		/// <summary>
		/// The parameters used to set up this box layout.
		/// </summary>
		public BoxLayoutParams Params {
			get {
				return parameters;
			}
			set {
				parameters = value ?? throw new ArgumentNullException(nameof(Params));
			}
		}

		/// <summary>
		/// Results from the horizontal calculation pass.
		/// </summary>
		private BoxLayoutResults horizontal;

		/// <summary>
		/// The parameters used to set up this box layout.
		/// </summary>
		[SerializeField]
		private BoxLayoutParams parameters;

		/// <summary>
		/// Results from the vertical calculation pass.
		/// </summary>
		private BoxLayoutResults vertical;

		internal BoxLayoutGroup() {
			horizontal = null;
			layoutPriority = 1;
			parameters = new BoxLayoutParams();
			vertical = null;
		}

		public override void CalculateLayoutInputHorizontal() {
			if (!locked) {
				var margin = parameters.Margin;
				float gap = (margin == null) ? 0.0f : margin.left + margin.right;
				horizontal = Calc(gameObject, parameters, PanelDirection.Horizontal);
				var hTotal = horizontal.total;
				minWidth = hTotal.min + gap;
				preferredWidth = hTotal.preferred + gap;
#if DEBUG_LAYOUT
				PUIUtils.LogUIDebug("CalculateLayoutInputHorizontal for {0} preferred {1:F2}".
					F(gameObject.name, preferredWidth));
#endif
			}
		}

		public override void CalculateLayoutInputVertical() {
			if (!locked) {
				var margin = parameters.Margin;
				float gap = (margin == null) ? 0.0f : margin.top + margin.bottom;
				vertical = Calc(gameObject, parameters, PanelDirection.Vertical);
				var vTotal = vertical.total;
				minHeight = vTotal.min + gap;
				preferredHeight = vTotal.preferred + gap;
#if DEBUG_LAYOUT
				PUIUtils.LogUIDebug("CalculateLayoutInputVertical for {0} preferred {1:F2}".F(
					gameObject.name, preferredHeight));
#endif
			}
		}

		protected override void OnDisable() {
			base.OnDisable();
			horizontal = null;
			vertical = null;
		}

		protected override void OnEnable() {
			base.OnEnable();
			horizontal = null;
			vertical = null;
		}

		public override void SetLayoutHorizontal() {
			if (horizontal != null && !locked) {
#if DEBUG_LAYOUT
				PUIUtils.LogUIDebug("SetLayoutHorizontal for {0} resolved width to {1:F2}".F(
					gameObject.name, rectTransform.rect.width));
#endif
				DoLayout(parameters, horizontal, rectTransform.rect.width);
			}
		}

		public override void SetLayoutVertical() {
			if (vertical != null && !locked) {
#if DEBUG_LAYOUT
				PUIUtils.LogUIDebug("SetLayoutVertical for {0} resolved height to {1:F2}".F(
					gameObject.name, rectTransform.rect.height));
#endif
				DoLayout(parameters, vertical, rectTransform.rect.height);
			}
		}
	}
}