/*
Copyright (c) 2019, Lars Brubaker, John Lewin
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the FreeBSD Project.
*/

using System;
using System.Collections.Generic;
using MatterHackers.Agg;
using MatterHackers.Agg.Image;
using MatterHackers.Agg.Platform;
using MatterHackers.Agg.UI;
using MatterHackers.Localizations;
using MatterHackers.MatterControl.CustomWidgets;
using MatterHackers.MatterControl.PartPreviewWindow;
using MatterHackers.MatterControl.PrinterCommunication;
using MatterHackers.VectorMath;

namespace MatterHackers.MatterControl
{
	public class ThemeConfig
	{
		private ImageBuffer restoreNormal;
		private ImageBuffer restoreHover;

		public int FontSize7 { get; } = 7;

		public int FontSize8 { get; } = 8;

		public int FontSize9 { get; } = 9;

		public int FontSize10 { get; } = 10;

		public int FontSize11 { get; } = 11;

		public int FontSize12 { get; } = 12;

		public int FontSize14 { get; } = 14;

		public int DefaultFontSize { get; set; } = 11;

		public int DefaultContainerPadding { get; } = 10;

		public int H1PointSize { get; } = 11;

		public double ButtonHeight => 32 * GuiWidget.DeviceScale;

		public double TabButtonHeight => 30 * GuiWidget.DeviceScale;

		public double MenuGutterWidth => 35 * GuiWidget.DeviceScale;

		public double MicroButtonHeight => 20 * GuiWidget.DeviceScale;

		private double MicroButtonWidth => 30 * GuiWidget.DeviceScale;

		private readonly int defaultScrollBarWidth = 120;

		/// <summary>
		/// Gets a value indicating whether icons should be inverted due to black source images on a dark theme
		/// </summary>
		public bool InvertIcons => this?.IsDarkTheme ?? false;

		public void MakeRoundedButton(GuiWidget button, Color? boarderColor = null)
		{
			if (button is TextButton textButton)
			{
				textButton.VAnchor |= VAnchor.Fit;
				textButton.HAnchor |= HAnchor.Fit;
				textButton.HoverColor = this.AccentMimimalOverlay;
				textButton.Padding = new BorderDouble(7, 5);
				if (boarderColor != null)
				{
					textButton.BorderColor = boarderColor.Value;
				}
				else
				{
					textButton.BorderColor = this.TextColor;
				}
				textButton.BackgroundOutlineWidth = 1;
				textButton.BackgroundRadius = textButton.Height / 2;
			}
		}

		public void ApplyPrimaryActionStyle(GuiWidget guiWidget)
		{
			guiWidget.BackgroundColor = new Color(this.AccentMimimalOverlay, 50);

			Color hoverColor = this.AccentMimimalOverlay;

			switch (guiWidget)
			{
				case PopupMenuButton menuButton:
					menuButton.HoverColor = hoverColor;
					break;
				case SimpleFlowButton flowButton:
					flowButton.HoverColor = hoverColor;
					break;
				case SimpleButton button:
					button.HoverColor = hoverColor;
					break;
			}
		}

		internal void RemovePrimaryActionStyle(GuiWidget guiWidget)
		{
			guiWidget.BackgroundColor = Color.Transparent;

			// Buttons in toolbars should revert to ToolbarButtonHover when reset
			bool parentIsToolbar = guiWidget.Parent?.Parent is Toolbar;

			switch (guiWidget)
			{
				case SimpleFlowButton flowButton:
					flowButton.HoverColor = parentIsToolbar ? this.ToolbarButtonHover : Color.Transparent;
					break;
				case SimpleButton button:
					button.HoverColor = parentIsToolbar ? this.ToolbarButtonHover : Color.Transparent;
					break;
			}
		}

		public BorderDouble TextButtonPadding { get; } = new BorderDouble(14, 0);

		public BorderDouble ButtonSpacing { get; } = new BorderDouble(right: 3);

		public BorderDouble ToolbarPadding { get; } = 3;

		public BorderDouble TabbarPadding { get; } = new BorderDouble(3, 1);

		/// <summary>
		/// Gets the height or width of a given vertical or horizontal splitter bar
		/// </summary>
		public int SplitterWidth
		{
			get
			{
				double splitterSize = 6 * GuiWidget.DeviceScale;

				if (GuiWidget.TouchScreenMode)
				{
					splitterSize *= 1.4;
				}

				return (int)splitterSize;
			}
		}

		public PresetColors PresetColors { get; set; } = new PresetColors();

		public bool IsDarkTheme { get; set; }

		public Color SlightShade { get; set; }

		public Color MinimalShade { get; set; }

		public Color Shade { get; set; }

		public Color DarkShade { get; set; }

		public Color BackgroundColor { get; set; }

		public Color TextColor { get; set; } = Color.Black;

		public Color TabBarBackground { get; set; }

		public Color InactiveTabColor { get; set; }

		public Color InteractionLayerOverlayColor { get; set; }

		public TextWidget CreateHeading(string text)
		{
			return new TextWidget(text, pointSize: this.H1PointSize, textColor: this.TextColor, bold: true)
			{
				Margin = new BorderDouble(0, 5)
			};
		}

		public Color SplitterBackground { get; set; } = new Color(0, 0, 0, 60);

		public Color TabBodyBackground { get; set; }

		public Color ToolbarButtonBackground { get; set; } = Color.Transparent;

		public Color ToolbarButtonHover => this.SlightShade;

		public Color ToolbarButtonDown => this.MinimalShade;

		public Color ThumbnailBackground { get; set; }

		public Color AccentMimimalOverlay { get; set; }

		public BorderDouble SeparatorMargin { get; }

		public ImageBuffer GeneratingThumbnailIcon { get; private set; }

		public class StateColor
		{
			public Color BackgroundColor { get; set; }

			public Color ForegroundColor { get; set; }

			public Color BorderColor { get; set; }

			public Color TextColor { get; set; }

			public Color LightTextColor { get; set; }
		}

		public class ThreeStateColor
		{
			public StateColor Focused { get; set; } = new StateColor();

			public StateColor Hovered { get; set; } = new StateColor();

			public StateColor Inactive { get; set; } = new StateColor();
		}

		public class DropListStyle : ThreeStateColor
		{
			public StateColor Open { get; set; } = new StateColor();
		}

		public ThreeStateColor EditFieldColors { get; set; } = new ThreeStateColor();

		public Color LightTextColor { get; set; }

		public Color BorderColor { get; set; }

		public Color BorderColor40 { get; set; }

		public Color BorderColor20 { get; set; }

		internal void EnsureDefaults()
		{
			// if (this.BedColor == Color.Transparent)
			// {
			// 	this.BedColor = this.ResolveColor(this.BackgroundColor, Color.Gray.WithAlpha(60));
			// }

			// EnsureDefaults is called after deserialization and at a point when state should be fully loaded. Invoking RebuildTheme here ensures icons are inverted correctly
			this.RebuildTheme();
		}

		public Color RowBorder { get; set; }

		public DropListStyle DropList { get; set; } = new DropListStyle();

		public Color DisabledColor { get; set; }

		public Color SplashAccentColor { get; set; }

		public Color BedBackgroundColor { get; set; }

		public Color PrimaryAccentColor { get; set; }

		public Color SectionBackgroundColor { get; set; }

		public Color PopupBorderColor { get; set; }

		public Color BedColor { get; set; }

		public Color UnderBedColor { get; set; }

		public Color PrinterBedTextColor { get; set; }

		public GridColors BedGridColors { get; set; } = new GridColors();
		public double ButtonRadius { get; set; } = 3;

		public GuiWidget CreateSearchButton()
		{
			return new IconButton(StaticData.Instance.LoadIcon("icon_search_24x24.png", 16, 16, this.InvertIcons), this)
			{
				ToolTipText = "Search".Localize(),
			};
		}

		public ThemeConfig()
		{
			this.SeparatorMargin = (this.ButtonSpacing * 2).Clone(left: this.ButtonSpacing.Right);
			this.RebuildTheme();
		}

		public void SetDefaults()
		{
			this.DisabledColor = new Color(this.LightTextColor, 50);
			this.SplashAccentColor = new Color(this.PrimaryAccentColor, 185).OverlayOn(Color.White).ToColor();
		}

		public void RebuildTheme()
		{
			int size = (int)(16 * GuiWidget.DeviceScale);

			// On Android, use red icon as no hover events, otherwise transparent and red on hover
			restoreNormal = ColorCircle(size, (AggContext.OperatingSystem == OSType.Android) ? new Color(200, 0, 0) : Color.Transparent);
			restoreHover = ColorCircle(size, new Color("#DB4437"));

			this.GeneratingThumbnailIcon = StaticData.Instance.LoadIcon("building_thumbnail_40x40.png", 40, 40, this.InvertIcons);

			ScrollBar.DefaultThumbView.ThumbColor = new Color(this.TextColor, 30);
		}

		public JogControls.MoveButton CreateMoveButton(PrinterConfig printer, string label, PrinterConnection.Axis axis, double movementFeedRate, bool levelingButtons = false)
		{
			return new JogControls.MoveButton(label, printer, axis, movementFeedRate, this)
			{
				BackgroundColor = this.MinimalShade,
				BorderColor = this.BorderColor40,
				BackgroundOutlineWidth = 1,
				VAnchor = VAnchor.Absolute,
				HAnchor = HAnchor.Absolute,
				Margin = 0,
				Padding = 0,
				Height = (levelingButtons ? 45 : 40) * GuiWidget.DeviceScale,
				Width = (levelingButtons ? 90 : 40) * GuiWidget.DeviceScale,
			};
		}

		public JogControls.ExtrudeButton CreateExtrudeButton(PrinterConfig printer, string label, double movementFeedRate, int extruderNumber, bool levelingButtons = false)
		{
			return new JogControls.ExtrudeButton(printer, label, movementFeedRate, extruderNumber, this)
			{
				BackgroundColor = this.MinimalShade,
				BorderColor = this.BorderColor40,
				BackgroundOutlineWidth = 1,
				VAnchor = VAnchor.Absolute,
				HAnchor = HAnchor.Absolute,
				Margin = 0,
				Padding = 0,
				Height = (levelingButtons ? 45 : 40) * GuiWidget.DeviceScale,
				Width = (levelingButtons ? 90 : 40) * GuiWidget.DeviceScale,
			};
		}

		public RadioTextButton CreateMicroRadioButton(string text, IList<GuiWidget> siblingRadioButtonList = null)
		{
			var radioButton = new RadioTextButton(text, this, this.FontSize8)
			{
				SiblingRadioButtonList = siblingRadioButtonList,
				Padding = new BorderDouble(5, 0),
				SelectedBackgroundColor = this.SlightShade,
				UnselectedBackgroundColor = this.SlightShade,
				HoverColor = this.AccentMimimalOverlay,
				Margin = new BorderDouble(right: 1),
				HAnchor = HAnchor.Absolute,
				Height = this.MicroButtonHeight,
				Width = this.MicroButtonWidth
			};

			// Add to sibling list if supplied
			siblingRadioButtonList?.Add(radioButton);

			return radioButton;
		}

		public TextButton CreateLightDialogButton(string text)
		{
			return CreateDialogButton(text, new Color(Color.White, 15), new Color(Color.White, 25));
		}

		public TextButton CreateDialogButton(string text)
		{
			return CreateDialogButton(text, this.SlightShade, this.SlightShade.WithAlpha(75));
		}

		public TextButton CreateDialogButton(string text, Color backgroundColor, Color hoverColor)
		{
#if !__ANDROID__
			return new TextButton(text, this)
			{
				BackgroundColor = backgroundColor,
				HoverColor = hoverColor,
				MinimumSize = new Vector2(75, 0),
				Margin = this.ButtonSpacing
			};
#else
			var button = new TextButton(text, this, this.FontSize14)
			{
				BackgroundColor = backgroundColor,
				HoverColor = hoverColor,
				// Enlarge button height and margin on Android
				Height = 34 * GuiWidget.DeviceScale,
			};
			button.Padding = button.Padding * 1.2;

			return button;
#endif
		}

		public Color GetBorderColor(int alpha)
		{
			return new Color(this.BorderColor, alpha);
		}

		// Compute an opaque color from a source and a target with alpha
		public Color ResolveColor(Color background, Color overlay)
		{
			return ResolveColor2(background, overlay);
		}

		// Compute an opaque color from a source and a target with alpha
		public static Color ResolveColor2(Color background, Color overlay)
		{
			return new BlenderBGRA().Blend(background, overlay);
		}

		public FlowLayoutWidget CreateMenuItems(PopupMenu popupMenu, IEnumerable<NamedAction> menuActions)
		{
			// Create menu items in the DropList for each element in this.menuActions
			foreach (var menuAction in menuActions)
			{
				if (menuAction is ActionSeparator)
				{
					popupMenu.CreateSeparator();
				}
				else
				{
					if (menuAction is NamedActionGroup namedActionButtons)
					{
						var content = new FlowLayoutWidget()
						{
							HAnchor = HAnchor.Fit | HAnchor.Stretch
						};

						var textWidget = new TextWidget(menuAction.Title, pointSize: this.DefaultFontSize, textColor: this.TextColor)
						{
							// Padding = MenuPadding,
							VAnchor = VAnchor.Center
						};
						content.AddChild(textWidget);

						content.AddChild(new HorizontalSpacer());

						foreach (var actionButton in namedActionButtons.Group)
						{
							var button = new TextButton(actionButton.Title, this)
							{
								Border = new BorderDouble(1, 0, 0, 0),
								BorderColor = this.MinimalShade,
								HoverColor = this.AccentMimimalOverlay,
								Enabled = actionButton.IsEnabled()
							};

							content.AddChild(button);

							if (actionButton.IsEnabled())
							{
								button.Click += (s, e) =>
								{
									actionButton.Action();
									popupMenu.Unfocus();
								};
							}
						}

						var menuItem = new PopupMenu.MenuItem(content, this)
						{
							HAnchor = HAnchor.Fit | HAnchor.Stretch,
							VAnchor = VAnchor.Fit,
							HoverColor = Color.Transparent,
						};
						popupMenu.AddChild(menuItem);
						menuItem.Padding = new BorderDouble(menuItem.Padding.Left,
							menuItem.Padding.Bottom,
							0,
							menuItem.Padding.Top);
					}
					else
					{
						PopupMenu.MenuItem menuItem;

						if (menuAction is NamedBoolAction boolAction)
						{
							menuItem = popupMenu.CreateBoolMenuItem(menuAction.Title, boolAction.GetIsActive, boolAction.SetIsActive);
						}
						else
						{
							menuItem = popupMenu.CreateMenuItem(menuAction.Title, menuAction.Icon, menuAction.Shortcut);
						}

						menuItem.Name = $"{menuAction.Title} Menu Item";

						menuItem.Enabled = menuAction is NamedActionGroup
							|| (menuAction.Action != null && menuAction.IsEnabled?.Invoke() != false);

						menuItem.ClearRemovedFlag();

						if (menuItem.Enabled)
						{
							menuItem.Click += (s, e) =>
							{
								menuAction.Action();
							};
						}
					}
				}
			}

			return popupMenu;
		}

		public PopupMenuButton CreateSplitButton(SplitButtonParams buttonParams, OperationGroup operationGroup = null)
		{
			PopupMenuButton menuButton = null;

			GuiWidget innerButton;
			if (buttonParams.ButtonText == null)
			{
				innerButton = new IconButton(buttonParams.Icon, this)
				{
					Name = buttonParams.ButtonName + " Inner SplitButton",
					Enabled = buttonParams.ButtonEnabled,
					ToolTipText = buttonParams.ButtonTooltip,
				};

				// Remove right Padding for drop style
				innerButton.Padding = innerButton.Padding.Clone(right: 0);
			}
			else
			{
				if (buttonParams.Icon == null)
				{
					innerButton = new TextButton(buttonParams.ButtonText, this)
					{
						Name = buttonParams.ButtonName,
						Enabled = buttonParams.ButtonEnabled,
						ToolTipText = buttonParams.ButtonTooltip,
					};
				}
				else
				{
					innerButton = new TextIconButton(buttonParams.ButtonText, buttonParams.Icon, this)
					{
						Name = buttonParams.ButtonName,
						Enabled = buttonParams.ButtonEnabled,
						ToolTipText = buttonParams.ButtonTooltip,
					};
				}
			}

			innerButton.Click += (s, e) =>
			{
				buttonParams.ButtonAction.Invoke(menuButton);
			};


			if (operationGroup == null)
			{
				menuButton = new PopupMenuButton(innerButton, this);
			}
			else
			{
				menuButton = new OperationGroupButton(operationGroup, innerButton, this);
			}

			var theme = ApplicationController.Instance.MenuTheme;
			menuButton.DynamicPopupContent = () =>
			{
				var popupMenu = new PopupMenu(theme);
				buttonParams.ExtendPopupMenu?.Invoke(popupMenu);

				return popupMenu;
			};

			menuButton.Name = buttonParams.ButtonName + " Menu SplitButton";
			if (buttonParams.ButtonText == null)
			{
				menuButton.BackgroundColor = this.ToolbarButtonBackground;
			}
			else
			{
				menuButton.BackgroundColor = this.MinimalShade;
			}

			menuButton.HoverColor = this.ToolbarButtonHover;
			menuButton.MouseDownColor = this.ToolbarButtonDown;
			menuButton.DrawArrow = true;
			menuButton.Margin = this.ButtonSpacing;
			menuButton.DistinctPopupButton = true;
			menuButton.BackgroundRadius = new RadiusCorners(theme.ButtonRadius, theme.ButtonRadius, 0, 0);

			innerButton.Selectable = true;
			return menuButton;
		}

		private static ImageBuffer ColorCircle(int size, Color color)
		{
			var imageBuffer = new ImageBuffer(size, size);
			Graphics2D normalGraphics = imageBuffer.NewGraphics2D();
			var center = new Vector2(size / 2.0, size / 2.0);

			Color barColor;
			if (color != Color.Transparent)
			{
				normalGraphics.Circle(center, size / 2.0, color);
				barColor = Color.White;
			}
			else
			{
				barColor = new Color("#999");
			}

			normalGraphics.Line(center + new Vector2(-size / 4.0, -size / 4.0), center + new Vector2(size / 4.0, size / 4.0), barColor, 2 * GuiWidget.DeviceScale);
			normalGraphics.Line(center + new Vector2(-size / 4.0, size / 4.0), center + new Vector2(size / 4.0, -size / 4.0), barColor, 2 * GuiWidget.DeviceScale);

			return imageBuffer;
		}

		public GuiWidget CreateSmallResetButton()
		{
			return new HoverImageWidget(restoreNormal, restoreHover)
			{
				VAnchor = VAnchor.Center,
				Margin = new BorderDouble(0, 0, 5, 0)
			};
		}

		public SolidSlider CreateSolidSlider(GuiWidget wordOptionContainer, string header, ThemeConfig theme, double min = 0, double max = .5)
		{
			double scrollBarWidth = 10;

			wordOptionContainer.AddChild(new TextWidget(header, textColor: this.TextColor)
			{
				Margin = new BorderDouble(10, 3, 3, 5),
				HAnchor = HAnchor.Left
			});

			var namedSlider = new SolidSlider(new Vector2(), scrollBarWidth, theme, 0, 1)
			{
				TotalWidthInPixels = defaultScrollBarWidth,
				Minimum = min,
				Maximum = max,
				Margin = new BorderDouble(12, 4),
				HAnchor = HAnchor.Stretch,
			};

			wordOptionContainer.AddChild(namedSlider);

			return namedSlider;
		}

		public MenuItem CreateCheckboxMenuItem(string text, string itemValue, bool itemChecked, BorderDouble padding, EventHandler eventHandler)
		{
			var checkbox = new CheckBox(text)
			{
				Checked = itemChecked
			};
			checkbox.CheckedStateChanged += eventHandler;

			return new MenuItem(checkbox, itemValue)
			{
				Padding = padding,
			};
		}

		public void ApplyBottomBorder(GuiWidget widget, bool shadedBorder = false)
		{
			widget.BorderColor = shadedBorder ? this.MinimalShade : this.BorderColor20;

			this.ApplyBorder(widget, new BorderDouble(bottom: 1), shadedBorder);
		}

		public void ApplyBorder(GuiWidget widget, BorderDouble border, bool shadedBorder = false)
		{
			widget.BorderColor = shadedBorder ? this.MinimalShade : this.BorderColor20;
			widget.Border = border;
		}

		public SectionWidget ApplyBoxStyle(SectionWidget sectionWidget)
		{
			return ApplyBoxStyle(
				sectionWidget,
				this.SectionBackgroundColor,
				margin: new BorderDouble(this.DefaultContainerPadding, 0, this.DefaultContainerPadding, this.DefaultContainerPadding));
		}

		public SolidSlider ApplySliderStyle(SolidSlider solidSlider)
		{
			solidSlider.View.TrackColor = this.SlightShade;
			solidSlider.View.TrackRadius = 4;

			return solidSlider;
		}

		public DoubleSolidSlider ApplySliderStyle(DoubleSolidSlider solidSlider)
		{
			solidSlider.View.TrackColor = this.SlightShade;
			solidSlider.View.TrackRadius = 4;

			return solidSlider;
		}

		// ApplySquareBoxStyle
		public SectionWidget ApplyBoxStyle(SectionWidget sectionWidget, BorderDouble margin)
		{
			sectionWidget.BackgroundColor = this.SectionBackgroundColor;
			sectionWidget.Margin = 0;
			sectionWidget.Border = new BorderDouble(bottom: 1);
			sectionWidget.BorderColor = this.RowBorder;

			return sectionWidget;
		}

		public SectionWidget ApplyBoxStyle(SectionWidget sectionWidget, Color backgroundColor, BorderDouble margin)
		{
			// Enforce panel padding
			// sectionWidget.ContentPanel.Padding = new BorderDouble(10, 0, 10, 2);
			// sectionWidget.ContentPanel.Padding = 0;

			sectionWidget.BorderColor = Color.Transparent;
			sectionWidget.BorderRadius = 5;
			sectionWidget.Margin = margin;
			sectionWidget.BackgroundColor = backgroundColor;

			return sectionWidget;
		}
	}

	public class PresetColors
	{
		public Color MaterialPreset { get; set; } = Color.Orange;

		public Color QualityPreset { get; set; } = Color.Yellow;

		public Color UserOverride { get; set; } = new Color(68, 95, 220, 150);
	}

	public class GridColors
	{
		public Color Red { get; set; }

		public Color Green { get; set; }

		public Color Blue { get; set; }

		public Color Line { get; set; }
	}

	public class SplitButtonParams
	{
		public ImageBuffer Icon { get; set; }

		public bool ButtonEnabled { get; set; } = true;

		public string ButtonName { get; set; }

		public Action<GuiWidget> ButtonAction { get; set; }

		public string ButtonTooltip { get; set; }

		public Action MenuAction { get; set; }

		public Action<PopupMenu> ExtendPopupMenu { get; set; }

		public string ButtonText { get; set; }
	}
}