/*
Copyright (c) 2018, 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 System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using MatterHackers.Agg;
using MatterHackers.Agg.Platform;
using MatterHackers.Agg.UI;
using MatterHackers.Agg.UI.Tests;
using MatterHackers.GuiAutomation;
using MatterHackers.MatterControl;
using MatterHackers.MatterControl.SlicerConfiguration;
using MatterHackers.MatterControl.Tests.Automation;
using MatterHackers.SerialPortCommunication.FrostedSerial;
using NUnit.Framework;
using static MatterControl.Tests.MatterControl.SliceSettingsFieldTests;

namespace MatterControl.Tests.MatterControl
{
	public static class RunnerX
	{
		public static Task RunTest(this SystemWindow systemWindow, AutomationTest automationTest, int timeout)
		{
			return AutomationRunner.ShowWindowAndExecuteTests(systemWindow, automationTest, timeout);
		}

		[DebuggerStepThrough]
		public static void Add(this List<ValueMap> valueMap, string input, string expected)
		{
			valueMap.Add(new ValueMap(input, expected));
		}
	}

	[TestFixture, Category("SliceSettingsTests"), RunInApplicationDomain, Apartment(ApartmentState.STA)]
	public class SliceSettingsFieldTests
	{
		[SetUp]
		public void TestSetup()
		{
			StaticData.RootPath = TestContext.CurrentContext.ResolveProjectPath(4, "StaticData");
			MatterControlUtilities.OverrideAppDataLocation(TestContext.CurrentContext.ResolveProjectPath(4));
		}

		[Test]
		public Task TestExistsForEachUIFieldType()
		{
			var testClass = this.GetType();
			var thisClassMethods = testClass.GetMethods(BindingFlags.Public | BindingFlags.Instance);

			// Find and validate all UIField types, skipping abstract classes
			foreach (var fieldType in PluginFinder.FindTypes<UIField>().Where(fieldType => !fieldType.IsAbstract))
			{
				if (fieldType.Name == "UIField")
				{
					continue;
				}

				string expectedTestName = $"{fieldType.Name}Test";
				Assert.AreEqual(
					1,
					thisClassMethods.Where(m => m.Name == expectedTestName).Count(),
					"Required test missing: " + expectedTestName);
			}

			return Task.CompletedTask;
		}

		[Test]
		public async Task DoubleFieldTest()
		{
			var theme = MatterHackers.MatterControl.AppContext.Theme;
			var testField = new DoubleField(theme);

			await ValidateAgainstValueMap(
				testField,
				theme,
				(field) => (field.Content as MHNumberEdit).ActuallNumberEdit.Text,
				new List<ValueMap>()
				{
					{ "0.12345", "0.12345" },
					{ "1.2345", "1.2345" },
					{ "12.345", "12.345" },
					{ "12.7", "12.7" },
					{ "+0.12345", "0.12345" },
					{ "+1.2345", "1.2345" },
					{ "+12.345", "12.345" },
					{ "-0.12345", "-0.12345" },
					{ "-1.2345", "-1.2345" },
					{ "-12.345", "-12.345" },
					{ "12.7", "12.7" },
					{ "22", "22" },
					// Invalid values revert to expected
					{ "abc", "0" },
					{ "+abc", "0" },
					{ "-abc", "0" },
				});
		}

		[Test]
		public async Task PositiveDoubleFieldTest()
		{
			var theme = MatterHackers.MatterControl.AppContext.Theme;
			var testField = new PositiveDoubleField(theme);

			await ValidateAgainstValueMap(
				testField,
				theme,
				(field) => (field.Content as MHNumberEdit).ActuallNumberEdit.Text,
				new List<ValueMap>()
				{
					{ "0.12345", "0.12345" },
					{ "1.2345", "1.2345" },
					{ "12.345", "12.345" },
					{ "12.7", "12.7" },
					{ "+0.12345", "0.12345" },
					{ "+1.2345", "1.2345" },
					{ "+12.345", "12.345" },
					{ "-0.12345", "0" },
					{ "-1.2345", "0" },
					{ "-12.345", "0" },
					{ "-12.7", "0" },
					{ "22", "22" },
					// Invalid values revert to expected
					{ "abc", "0" },
					{ "+abc", "0" },
					{ "-abc", "0" },
				});
		}

		[Test]
		public async Task IntFieldTest()
		{
			var theme = MatterHackers.MatterControl.AppContext.Theme;
			var testField = new IntField(theme);

			await ValidateAgainstValueMap(
				testField,
				theme,
				(field) => (field.Content as MHNumberEdit).ActuallNumberEdit.Text,
				new List<ValueMap>()
				{
					{ "0.12345", "0" },
					{ "1.2345", "1" },
					{ "12.345", "12" },
					{ "12.7", "12" }, // Floor not round?
					{ "+0.12345", "0" },
					{ "+1.2345", "1" },
					{ "+12.345", "12" },
					{ "-0.12345", "0" },
					{ "-1.2345", "-1" },
					{ "-12.345", "-12" },
					{ "-12.7", "-12" }, // Floor not round?
					{ "22", "22" },
					// Invalid values revert to expected
					{ "abc", "0" },
					{ "+abc", "0" },
					{ "-abc", "0" },
				});
		}

		[Test]
		public async Task DoubleOrPercentFieldTest()
		{
			var theme = MatterHackers.MatterControl.AppContext.Theme;
			var testField = new DoubleOrPercentField(theme);

			await ValidateAgainstValueMap(
				testField,
				theme,
				(field) => (field.Content as MHTextEditWidget).ActualTextEditWidget.Text,
				new List<ValueMap>()
				{
					{ "0.12345", "0.12345" },
					{ "0.12345%", "0.12345%" },
					{ "1.2345", "1.2345" },
					{ "1.2345%", "1.2345%" },
					{ "12.345", "12.345" },
					{ "12.345%", "12.345%" },
					{ "12.7", "12.7" },
					{ "12.7%", "12.7%" },
					{ "+0.12345", "0.12345" },
					{ "+0.12345%", "0.12345%" },
					{ "+1.2345", "1.2345" },
					{ "+1.2345%", "1.2345%" },
					{ "+12.345", "12.345" },
					{ "+12.345%", "12.345%" },
					{ "-0.12345", "-0.12345" },
					{ "-0.12345%", "-0.12345%" },
					{ "-1.2345", "-1.2345" },
					{ "-1.2345%", "-1.2345%" },
					{ "-12.345", "-12.345" },
					{ "-12.345%", "-12.345%" },
					{ "12.7", "12.7" },
					{ "12.7%", "12.7%" },
					{ "22", "22" },
					{ "22%", "22%" },
					// Invalid values revert to expected
					{ "abc", "0" },
					{ "abc%", "0%" },
					{ "+abc", "0" },
					{ "+abc%", "0%" },
					{ "-abc", "0" },
					{ "-abc%", "0%" },
				});
		}

		[Test]
		public async Task IntOrMmFieldTest()
		{
			var theme = MatterHackers.MatterControl.AppContext.Theme;
			var testField = new IntOrMmField(theme);

			await ValidateAgainstValueMap(
				testField,
				theme,
				(field) => (field.Content as MHTextEditWidget).ActualTextEditWidget.Text,
				new List<ValueMap>()
				{
					{ "0.12345", "0" },
					{ "0.12345mm", "0.12345mm" },
					{ "1.2345", "1" },
					{ "1.2345mm", "1.2345mm" },
					{ "12.345", "12" },
					{ "12.345mm", "12.345mm" },
					{ "12.7", "12" },
					{ "12.7mm", "12.7mm" },
					{ "+0.12345", "0" },
					{ "+0.12345mm", "0.12345mm" },
					{ "+1.2345", "1" },
					{ "+1.2345mm", "1.2345mm" },
					{ "+12.345", "12" },
					{ "+12.345mm", "12.345mm" },
					{ "-0.12345", "0" },
					{ "-0.12345mm", "0mm" },
					{ "-1.2345", "0" },
					{ "-1.2345mm", "0mm" },
					{ "-12.345", "0" },
					{ "-12.345mm", "0mm" },
					{ "12.7", "12" },
					{ "12.7mm", "12.7mm" },
					{ "22", "22" },
					{ "22mm", "22mm" },
					// Invalid values revert to expected
					{ "abc", "0" },
					{ "abcmm", "0mm" },
					{ "+abc", "0" },
					{ "+abcmm", "0mm" },
					{ "-abc", "0" },
					{ "-abcmm", "0mm" },
				});
		}

		[Test]
		public void CorrectStyleForSettingsRow()
		{
			var settings = new PrinterSettings();
			var printer = new PrinterConfig(settings);

			settings.OemLayer = new PrinterSettingsLayer();
			settings.QualityLayer = new PrinterSettingsLayer();
			settings.MaterialLayer = new PrinterSettingsLayer();
			Assert.AreEqual(0, settings.UserLayer.Count);

			var theme = new ThemeConfig();
			var settingsContext = new SettingsContext(printer, null, NamedSettingsLayers.All);

			var key = SettingsKey.layer_height;

			void TestStyle(Color color, bool restoreButton)
			{
				var data = SliceSettingsRow.GetStyleData(printer, theme, settingsContext, key, true);
				Assert.AreEqual(color, data.highlightColor);
				Assert.AreEqual(restoreButton, data.showRestoreButton);
			}

			// make sure all the colors are different
			Assert.AreNotEqual(Color.Transparent, theme.PresetColors.MaterialPreset);
			Assert.AreNotEqual(Color.Transparent, theme.PresetColors.QualityPreset);
			Assert.AreNotEqual(theme.PresetColors.MaterialPreset, theme.PresetColors.QualityPreset);
			Assert.AreNotEqual(theme.PresetColors.MaterialPreset, theme.PresetColors.UserOverride);
			Assert.AreNotEqual(theme.PresetColors.QualityPreset, theme.PresetColors.UserOverride);

			// nothing set no override
			TestStyle(Color.Transparent, false);

			// user override
			settings.UserLayer[key] = "123";
			TestStyle(theme.PresetColors.UserOverride, true);
			settings.UserLayer.Remove(key);

			// Quality override
			settings.QualityLayer[key] = "123";
			TestStyle(theme.PresetColors.QualityPreset, false);
			settings.QualityLayer.Remove(key);

			// Material override
			settings.MaterialLayer[key] = "123";
			TestStyle(theme.PresetColors.MaterialPreset, false);
			settings.MaterialLayer.Remove(key);

			// user override that is the same as the default
			settings.UserLayer[key] = settings.BaseLayer[key];
			TestStyle(Color.Transparent, false);
			settings.UserLayer.Remove(key);

			// Quality override same as default
			settings.QualityLayer[key] = settings.BaseLayer[key];
			TestStyle(theme.PresetColors.QualityPreset, false);
			settings.QualityLayer.Remove(key);

			// Material override same as default
			settings.MaterialLayer[key] = settings.BaseLayer[key];
			TestStyle(theme.PresetColors.MaterialPreset, false);
			settings.MaterialLayer.Remove(key);
		}

		[Test]
		public void RightClickMenuWorksOnSliceSettings()
		{
			PrinterSettings.SliceEngines["MatterSlice"] = new EngineMappingsMatterSlice();
			Clipboard.SetSystemClipboard(new SimulatedClipboard());

			var systemWindow = new SystemWindow(800, 600)
			{
				Name = "Main Window",
			};

			Application.AddTextWidgetRightClickMenu();

			AutomationRunner.TimeToMoveMouse = .1;

			var container = new FlowLayoutWidget(FlowDirection.TopToBottom)
			{
				HAnchor = HAnchor.Stretch,
				VAnchor = VAnchor.Fit,
			};
			systemWindow.AddChild(container);

			var theme = ApplicationController.Instance.Theme;
			var settings = new PrinterSettings();
			settings.SetValue(SettingsKey.printer_name, "Test Name");
			settings.SetValue(SettingsKey.start_gcode, "Test GCode");
			var printer = new PrinterConfig(settings);
			var settingsContext = new SettingsContext(printer, null, NamedSettingsLayers.All);
			var testData = new (string setting, string paste, bool selectsOnFocus, string postCutAll)[]
			{
				(SettingsKey.layer_height, "987.654", true, "0"),
				(SettingsKey.start_gcode, "Paste text", false, ""),
				(SettingsKey.printer_name, "three word name", true, ""),
			};

			int tabIndex = 0;

			var fields = new Dictionary<string, GuiWidget>();

			for (int i = 0; i < testData.Length; i++)
			{
				var settingsData = PrinterSettings.SettingsData[testData[i].setting];

				var itemRow = SliceSettingsTabView.CreateItemRow(settingsData,
					settingsContext,
					printer,
					theme,
					ref tabIndex);

				fields[testData[i].setting] = itemRow;

				container.AddChild(itemRow);
			}

			systemWindow.RunTest(testRunner =>
			{
				void RunSingeTest(string setting, string pastText, bool selectsOnFocus, string postCutAll)
				{
					var textWidget = fields[setting].Descendants<InternalTextEditWidget>().First();
					// no selection to start
					Assert.IsTrue(string.IsNullOrEmpty(textWidget.Selection), "Should not have selection");

					// select all and ensure everything is selected
					testRunner.RightClickByName(GetSliceSettingsField(setting));
					if (selectsOnFocus)
					{
						testRunner.Delay(); // wait a moment for the selection
						Assert.IsTrue(!string.IsNullOrEmpty(textWidget.Selection), "Should have selection");
					}
					else
					{
						Assert.IsTrue(string.IsNullOrEmpty(textWidget.Selection), "Should not have selection");
					}

					testRunner.ClickByName("Select All Menu Item")
						.Delay();
					Assert.IsTrue(textWidget.Selection == textWidget.Text, "Everything is selected");

					// make sure there is no text in the copy buffer
					Clipboard.Instance.SetText("");

					// copy text out and make sure we get it
					testRunner.RightClickByName(GetSliceSettingsField(setting));
					Assert.IsTrue(textWidget.Selection == textWidget.Text, "Selection remains after right click");
					testRunner.ClickByName("Copy Menu Item");
					Assert.AreEqual(Clipboard.Instance.GetText(), textWidget.Text, "Copied everything");

					// past in text and make sure it changed
					Clipboard.Instance.SetText(pastText);
					testRunner.RightClickByName(GetSliceSettingsField(setting))
						.ClickByName("Paste Menu Item");
					Assert.AreEqual(pastText, textWidget.Text, "Pasted everything");

					// cut works
					testRunner.RightClickByName(GetSliceSettingsField(setting))
						.ClickByName("Select All Menu Item")
						.Delay();
					Assert.IsTrue(textWidget.Selection == textWidget.Text, "Everything is selected");

					testRunner.RightClickByName(GetSliceSettingsField(setting));
					Assert.IsTrue(textWidget.Selection == textWidget.Text, "Selection remains after right click");
					var preCutText = textWidget.Text;
					testRunner.ClickByName("Cut Menu Item");
					// loose the selection
					testRunner.ClickByName("Main Window")
						.Delay();
					Assert.AreEqual(postCutAll, textWidget.Text, "Cut everything");
					Assert.AreEqual(preCutText, Clipboard.Instance.GetText(), "Cut everything");
				}

				// testRunner.Delay(2000);

				for (int i = 0; i < testData.Length; i++)
				{
					var data = testData[i];
					RunSingeTest(data.setting, data.paste, data.selectsOnFocus, data.postCutAll);
				}

				return Task.CompletedTask;
			},
			2000);
		}

		private string GetSliceSettingsField(string sliceSettingsKey)
		{
			var settingData = PrinterSettings.SettingsData[sliceSettingsKey];
			return $"{settingData.PresentationName} Field";
		}

		[Test]
		public async Task ComPortFieldTest()
		{
			FrostedSerialPort.MockPortsForTest = true;

			var theme = new ThemeConfig();

			var field = new ComPortField(new PrinterConfig(PrinterSettings.Empty), theme);

			await ValidateAgainstValueMap(
				field,
				theme,
				(f) => (f.Content.Children<DropDownList>().FirstOrDefault() as DropDownList).SelectedLabel,
				new List<ValueMap>()
				{
					{ "COM-TestA", "COM-TestA" },
					{ "COM-TestB", "COM-TestB" },
					{ "COM-TestC", "COM-TestC" },
					{ "COM-Test0", "COM-Test0" },
					{ "COM-Test1", "COM-Test1" },
				});
		}

		[TearDown]
		public void TearDown()
		{
			FrostedSerialPort.MockPortsForTest = false;
		}

		[Test, Ignore("Not Implemented")]
		public void CheckboxFieldTest()
		{
			Assert.Fail();
		}

		[Test, Ignore("Not Implemented")]
		public void MaterialIndexFieldTest()
		{
			Assert.Fail();
		}

		[Test, Ignore("Not Implemented")]
		public void ColorFieldTest()
		{
			Assert.Fail();
		}

		[Test, Ignore("Not Implemented")]
		public void ChildrenSelectorListFieldTest()
		{
			Assert.Fail();
		}

		[Test, Ignore("Not Implemented")]
		public void ToggleboxFieldTest()
		{
			Assert.Fail();
		}

		[Test]
		public async Task MultilineStringFieldTest()
		{
			var theme = MatterHackers.MatterControl.AppContext.Theme;

			var testField = new MultilineStringField(theme);

			await ValidateAgainstValueMap(
				testField,
				theme,
				(field) => (field.Content as MHTextEditWidget).ActualTextEditWidget.Text,
				new List<ValueMap>()
				{
					{ "0.12345", "0.12345" },
					{ "1.2345", "1.2345" },
					{ "12.345", "12.345" },
					{ "12.7", "12.7" },
					{ "+0.12345", "+0.12345" },
					{ "+1.2345", "+1.2345" },
					{ "+12.345", "+12.345" },
					{ "-0.12345", "-0.12345" },
					{ "-1.2345", "-1.2345" },
					{ "-12.345", "-12.345" },
					{ "12.7", "12.7" },
					{ "22", "22" },
					{ "abc", "abc" },
					{ "+abc", "+abc" },
					{ "-abc", "-abc" },
					{ "-abc\nline2", "-abc\nline2" },
				});
		}

		[Test]
		public async Task Vector2FieldTest()
		{
			var theme = MatterHackers.MatterControl.AppContext.Theme;

			var testField = new Vector2Field(theme);

			await ValidateAgainstValueMap(
				testField,
				theme,
				(field) =>
				{
					return string.Join(",", field.Content.Children.OfType<MHNumberEdit>().Select(w => w.ActuallNumberEdit.Text).ToArray());
				},
				new List<ValueMap>()
				{
					{ "0.1,0.2", "0.1,0.2" },
					{ "1,2", "1,2" },
					{ ",2", "0,2" }, // Empty components should revert to 0s
					{ "x,2", "0,2" }, // Non-numeric components should revert to 0s
					{ "2", "0,0" }, // Non-vector4 csv should revert to Vector4.Zero
				});
		}

		[Test]
		public async Task Vector3FieldTest()
		{
			var theme = MatterHackers.MatterControl.AppContext.Theme;

			var testField = new Vector3Field(theme);

			await ValidateAgainstValueMap(
				testField,
				theme,
				(field) =>
				{
					return string.Join(",", field.Content.Children.OfType<MHNumberEdit>().Select(w => w.ActuallNumberEdit.Text).ToArray());
				},
				new List<ValueMap>()
				{
					{ "0.1,0.2,0.3", "0.1,0.2,0.3" },
					{ "1,2,3", "1,2,3" },
					{ ",2,", "0,2,0" }, // Empty components should revert to 0s
					{ "x,2,y", "0,2,0" }, // Non-numeric components should revert to 0s
					{ ",2", "0,0,0" }, // Non-vector4 csv should revert to Vector4.Zero
				});
		}

		[Test]
		public async Task Vector4FieldTest()
		{
			var theme = MatterHackers.MatterControl.AppContext.Theme;

			Vector4Field.VectorXYZWEditWidth = 50;

			var testField = new Vector4Field(theme);

			await ValidateAgainstValueMap(
				testField,
				theme,
				(field) =>
				{
					return string.Join(",", field.Content.Children.OfType<MHNumberEdit>().Select(w => w.ActuallNumberEdit.Text).ToArray());
				},
				new List<ValueMap>()
				{
					{ "0.1,0.2,0.3,0.4", "0.1,0.2,0.3,0.4" },
					{ "1,2,3,4", "1,2,3,4" },
					{ ",2,,4", "0,2,0,4" }, // Empty components should revert to 0s
					{ "x,2,y,4", "0,2,0,4" }, // Non-numeric components should revert to 0s
					{ ",2,", "0,0,0,0" }, // Non-vector4 csv should revert to Vector4.Zero
				});
		}

		[Test]
		public async Task BoundsFieldTest()
		{
			var theme = MatterHackers.MatterControl.AppContext.Theme;

			var testField = new BoundsField(theme);

			await ValidateAgainstValueMap(
				testField,
				theme,
				(field) =>
				{
					return string.Join(",", field.Content.Children.OfType<MHNumberEdit>().Select(w => w.ActuallNumberEdit.Text).ToArray());
				},
				new List<ValueMap>()
				{
					{ "0.1,0.2,0.3,0.4", "0.1,0.2,0.3,0.4" },
					{ "1,2,3,4", "1,2,3,4" },
					{ ",2,,4", "0,2,0,4" }, // Empty components should revert to 0s
					{ "x,2,y,4", "0,2,0,4" }, // Non-numeric components should revert to 0s
					{ ",2,", "0,0,0,0" }, // Non-vector4 csv should revert to Vector4.Zero
				});
		}

		[Test, Ignore("Not Implemented")]
		public void ListFieldTest()
		{
			Assert.Fail();
		}

		[Test]
		public async Task ExtruderOffsetFieldTest()
		{
			var theme = MatterHackers.MatterControl.AppContext.Theme;

			var printer = new PrinterConfig(new PrinterSettings());
			var testField = new ExtruderOffsetField(printer,
				new SettingsContext(printer, null, NamedSettingsLayers.All),
				theme);

			await ValidateAgainstValueMap(
				testField,
				theme,
				(field) =>
				{
					return string.Join("x", field.Content.Descendants<MHNumberEdit>().Select(w => w.ActuallNumberEdit.Text).ToArray());
				},
				new List<ValueMap>()
				{
					{ "0x0x0", "0x0x0" },
					{ "0x0", "0x0x0" }, // we store 3 offsets now, when we see 2 we should make 3
					// {"", "0x0x0"}, // no values should become 0s
				});
		}

		[Test, Ignore("Not Implemented")]
		public void TextFieldTest()
		{
			Assert.Fail();
		}

		[Test, Ignore("Not Implemented")]
		public void ReadOnlyTextFieldTest()
		{
			Assert.Fail();
		}

		[Test, Ignore("Not Implemented")]
		public void BoundDoubleFieldTest()
		{
			Assert.Fail();
		}

		[Test, Ignore("Not Implemented")]
		public void CharFieldTest()
		{
			Assert.Fail();
		}

		[Test, Ignore("Not Implemented")]
		public void DirectionVectorFieldTest()
		{
			Assert.Fail();
		}

		[Test, Ignore("Not Implemented")]
		public void EnumFieldTest()
		{
			Assert.Fail();
		}

		[Test, Ignore("Not Implemented")]
		public void IconEnumFieldTest()
		{
			Assert.Fail();
		}

		[Test, Ignore("Not Implemented")]
		public async Task MarkdownEditFieldTest()
		{
			Assert.Fail();
		}

		[Test, Ignore("Not Implemented")]
		public async Task ListStringFieldTest()
		{
			Assert.Fail();
		}

		[Test, Ignore("Not Implemented")]
		public async Task SurfacedEditorsFieldTest()
		{
			Assert.Fail();
		}

		public class ValueMap
		{
			[DebuggerStepThrough]
			public ValueMap(string input, string expected)
			{
				this.InputValue = input;
				this.ExpectedValue = expected;
			}

			public string InputValue { get; }

			public string ExpectedValue { get; }
		}

		/// <summary>
		/// Take a UIField, a delegate to resolve the UI widget value and a map of input->expected values and validates the results for a given field
		/// </summary>
		/// <param name="field"></param>
		/// <param name="collectValueFromWidget">A delegate to resolve the currently displayed widget value</param>
		/// <param name="valuesMap">A map of input to expected values</param>
		/// <returns></returns>
		public static Task ValidateAgainstValueMap(UIField field, ThemeConfig theme, Func<UIField, string> collectValueFromWidget, IEnumerable<ValueMap> valuesMap)
		{
			// *************** Enable to investigate/debug/develop new/existing tests ************************
			bool investigateDebugTests = false;
			var perItemDelay = investigateDebugTests ? 1000 : 0;

			var testsWindow = new UIFieldTestWindow(500, 200, field, theme);

			return testsWindow.RunTest((testRunner) =>
			{
				foreach (var item in valuesMap)
				{
					testsWindow.SetAndValidateValues(item.ExpectedValue, item.InputValue, collectValueFromWidget, perItemDelay);
				}

				return Task.CompletedTask;
			}, 30);
		}
	}
}
