using System;
using System.Linq;
using System.Text.RegularExpressions;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Sarand.Net.Standard.Base.Utils;

namespace Sarand.UnitTests.Core.Base.Utils
{
	[TestClass]
	public class StringUtil_Tester
	{
		// --- Data Members ---

		private Random random = new Random();

		// --- Empty and Blank Values ---

		[TestMethod]
		public void StringUtil_IsEmpty()
		{
			// Leading spaces.
			Assert.AreEqual(true, StringUtil.IsEmpty(null));
			Assert.AreEqual(true, StringUtil.IsEmpty(""));
			Assert.AreEqual(false, StringUtil.IsEmpty(" "));
			Assert.AreEqual(false, StringUtil.IsEmpty("A"));
			Assert.AreEqual(false, StringUtil.IsEmpty("Abc"));
			Assert.AreEqual(true, "".IsEmpty());
			Assert.AreEqual(false, "Abc".IsEmpty());
		}

		[TestMethod]
		public void StringUtil_IsBlank()
		{
			// Leading spaces.
			Assert.AreEqual(true, StringUtil.IsBlank(null));
			Assert.AreEqual(true, StringUtil.IsBlank(""));
			Assert.AreEqual(true, StringUtil.IsBlank(" "));
			Assert.AreEqual(true, StringUtil.IsBlank("    "));
			Assert.AreEqual(true, StringUtil.IsBlank(" \n\t "));
			Assert.AreEqual(false, StringUtil.IsBlank("A"));
			Assert.AreEqual(false, StringUtil.IsBlank("Abc"));
			Assert.AreEqual(true, "".IsBlank());
			Assert.AreEqual(true, " ".IsBlank());
			Assert.AreEqual(false, "Abc".IsBlank());
		}

		// --- Regular Expression Matching ---

		[TestMethod]
		public void StringUtil_IsMatch()
		{
			// IsMatch.
			Assert.AreEqual(true, "ABCDEF".IsMatch("ABCDEF"));
			Assert.AreEqual(true, "ABCDEF".IsMatch("^ABCDEF$"));
			Assert.AreEqual(true, "ABCDEF".IsMatchCI("AbCdEf"));
			Assert.AreEqual(true, "ABCDEF".IsMatchCI("^AbCdEf$"));
			Assert.AreEqual(true, "ABCDEF".IsMatch("^ABC"));
			Assert.AreEqual(true, "ABCDEF".IsMatchCI("AbC"));
			Assert.AreEqual(true, "ABCDEF".IsMatch("CDE"));
			Assert.AreEqual(true, "ABCDEF".IsMatchCI("cDe"));
			Assert.AreEqual(true, "ABCDEF".IsMatch("CDE", System.Text.RegularExpressions.RegexOptions.None));
			Assert.AreEqual(true, "ABCDEF".IsMatch(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)));
			Assert.AreEqual(true, "ABCDEF".IsMatch(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)));

			// IsMatch with escaped content.
			Assert.AreEqual(true, "ABC\\sDEF".IsMatch("\\\\s"));
			Assert.AreEqual(true, "AB(CD)EF".IsMatch("(..)"));
			Assert.AreEqual(true, "AB(CD)EF".IsMatch("\\(CD\\)"));

			// Not match.
			Assert.AreEqual(false, "ABCDEF".IsMatch("cDe"));
			Assert.AreEqual(false, "ABCDEF".IsMatchCI("eFg"));
			Assert.AreEqual(false, "ABCDEF".IsMatch("cDe", System.Text.RegularExpressions.RegexOptions.None));
			Assert.AreEqual(false, "ABCDEF".IsMatch(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)));
		}

		[TestMethod]
		public void StringUtil_Match()
		{
			// Match.
			Assert.AreEqual("CDE", "ABCDEF".GetMatch("CDE"));
			Assert.AreEqual("CDE", "ABCDEF".GetMatchCI("cDe"));
			Assert.AreEqual("CDE", "ABCDEF".Match("CDE", System.Text.RegularExpressions.RegexOptions.None).Value);
			Assert.AreEqual("CDE", "ABCDEF".Match(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)).Value);
			Assert.AreEqual("CDE", "ABCDEF".Match(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)).Value);

			// Match with escaped content.
			Assert.AreEqual(" ", "ABC DEF".GetMatch("\\s"));
			Assert.AreEqual("\\s", "ABC\\sDEF".GetMatch("\\\\s"));
			Assert.AreEqual("AB", "AB(CD)EF".GetMatch("(..)"));
			Assert.AreEqual("(CD)", "AB(CD)EF".GetMatch("\\(..\\)"));
			Assert.AreEqual("(CD)", "AB(CD)EF".GetMatch("\\(CD\\)"));

			// Not match.
			Assert.AreEqual(null, "ABCDEF".GetMatch("cDe"));
			Assert.AreEqual(null, "ABCDEF".GetMatch("eFg"));
			Assert.AreEqual("", "ABCDEF".Match("cDe", System.Text.RegularExpressions.RegexOptions.None).Value);
			Assert.AreEqual("", "ABCDEF".Match(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)).Value);
		}

		[TestMethod]
		public void StringUtil_Matches()
		{
			// Match.
			Assert.AreEqual(1, "ABCDEF".GetMatches("CDE").Count);
			Assert.AreEqual(1, "ABCDEF".GetMatchesCI("cDe").Count);
			Assert.AreEqual(1, "ABCDEF".Matches("CDE", System.Text.RegularExpressions.RegexOptions.None).Count);
			Assert.AreEqual(1, "ABCDEF".Matches(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)).Count);
			Assert.AreEqual(1, "ABCDEF".Matches(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)).Count);

			// Match with escaped content.
			Assert.AreEqual(1, "ABC DEF".GetMatchesCI("\\s").Count);
			Assert.AreEqual(1, "ABC\\sDEF".GetMatchesCI("\\\\s").Count);
			Assert.AreEqual(4, "AB(CD)EF".GetMatchesCI("(..)").Count);
			Assert.AreEqual("D)", "AB(CD)EF".GetMatchesCI("(..)")[2]);
			Assert.AreEqual(1, "AB(CD)EF".GetMatchesCI("\\(..\\)").Count);
			Assert.AreEqual(1, "AB(CD)EF".GetMatchesCI("\\(CD\\)").Count);

			// Not match.
			Assert.AreEqual(0, "ABCDEF".GetMatches("cDe").Count);
			Assert.AreEqual(0, "ABCDEF".GetMatches("eFg").Count);
			Assert.AreEqual(0, "ABCDEF".Matches("cDe", System.Text.RegularExpressions.RegexOptions.None).Count);
			Assert.AreEqual(0, "ABCDEF".Matches(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)).Count);
		}

		[TestMethod]
		public void StringUtil_MatchCount()
		{
			// Match.
			Assert.AreEqual(1, "ABCDEF".GetMatchCount("CDE"));
			Assert.AreEqual(1, "ABCDEF".MatchesCount(new Regex("CDE")));
			Assert.AreEqual(2, "ABCDEFGHICDEJKL".GetMatchCount("CDE"));
			Assert.AreEqual(2, "ABCDEFGHICDEJKL".MatchesCount(new Regex("CDE")));
		}

		// --- Padding ---

		[TestMethod]
		public void StringUtil_PadLeft()
		{
			// Leading spaces.
			Assert.AreEqual("   ", "".PadLeft(3, ' '));
			Assert.AreEqual("  A", "A".PadLeft(3, ' '));
			Assert.AreEqual(" AB", "AB".PadLeft(3, ' '));
			Assert.AreEqual("ABC", "ABC".PadLeft(3, ' '));
			Assert.AreEqual("ABCD", "ABCD".PadLeft(3, ' '));

			// Leading zeroes.
			Assert.AreEqual("00", "".PadLeft(2, '0'));
			Assert.AreEqual("01", "1".PadLeft(2, '0'));
			Assert.AreEqual("123", "123".PadLeft(3, '0'));
			Assert.AreEqual("0123", "123".PadLeft(4, '0'));
			Assert.AreEqual("00123", "123".PadLeft(5, '0'));
		}
		[TestMethod]
		public void StringUtil_PadRight()
		{
			// Leading spaces.
			Assert.AreEqual("   ", "".PadRight(3, ' '));
			Assert.AreEqual("A  ", "A".PadRight(3, ' '));
			Assert.AreEqual("AB ", "AB".PadRight(3, ' '));
			Assert.AreEqual("ABC", "ABC".PadRight(3, ' '));
			Assert.AreEqual("ABCD", "ABCD".PadRight(3, ' '));

			// Trailing zeroes.
			Assert.AreEqual("00", "".PadRight(2, '0'));
			Assert.AreEqual("10", "1".PadRight(2, '0'));
			Assert.AreEqual("12", "12".PadRight(2, '0'));
			Assert.AreEqual("123", "123".PadRight(3, '0'));
			Assert.AreEqual("1230", "123".PadRight(4, '0'));
			Assert.AreEqual("12300", "123".PadRight(5, '0'));
		}

		// --- Safe Substrings ---

		[TestMethod]
		public void StringUtil_SubstringSafe()
		{
			Assert.AreEqual("", StringUtil.SubstringSafe(null, 0));
			Assert.AreEqual("", StringUtil.SubstringSafe("", 0));
			Assert.AreEqual("", "".SubstringSafe(0));

			// Right portion from start position.
			Assert.AreEqual("abc", "abc".SubstringSafe(-3));
			Assert.AreEqual("abc", "abc".SubstringSafe(-2));
			Assert.AreEqual("abc", "abc".SubstringSafe(-1));
			Assert.AreEqual("abc", "abc".SubstringSafe(0));
			Assert.AreEqual("bc", "abc".SubstringSafe(1));
			Assert.AreEqual("c", "abc".SubstringSafe(2));
			Assert.AreEqual("", "abc".SubstringSafe(3));

			// Zero length.
			Assert.AreEqual("", StringUtil.SubstringSafe(null, 0, 0));
			Assert.AreEqual("", StringUtil.SubstringSafe("", 0, 0));
			Assert.AreEqual("", "".SubstringSafe(0, 0));
			Assert.AreEqual("", "abc".SubstringSafe(-1, 0));
			Assert.AreEqual("", "abc".SubstringSafe(0, 0));
			Assert.AreEqual("", "abc".SubstringSafe(1, 0));
			Assert.AreEqual("", "abc".SubstringSafe(2, 0));
			Assert.AreEqual("", "abc".SubstringSafe(3, 0));
			Assert.AreEqual("", "abc".SubstringSafe(4, 0));

			// Mid portion.
			Assert.AreEqual("abc", "abcde".SubstringSafe(0, 3));
			Assert.AreEqual("bcd", "abcde".SubstringSafe(1, 3));
			Assert.AreEqual("cde", "abcde".SubstringSafe(2, 3));

			// Excessive length.
			Assert.AreEqual("abcde", "abcde".SubstringSafe(-1, 12));
			Assert.AreEqual("abcde", "abcde".SubstringSafe(0, 12));
			Assert.AreEqual("bcde", "abcde".SubstringSafe(1, 12));
			Assert.AreEqual("cde", "abcde".SubstringSafe(2, 12));
			Assert.AreEqual("de", "abcde".SubstringSafe(3, 12));
			Assert.AreEqual("e", "abcde".SubstringSafe(4, 12));
			Assert.AreEqual("", "abcde".SubstringSafe(5, 12));
		}
		// --- The End ---
	}
}