Test Complex DateParsing with Result<T> Accepting Wild Card | C# Online Compiler

Test Complex DateParsing with Result<T> Accepting Wild Card by Marcelo Scofano

using System;
using System.IO;
using System.Text;
using System.Collections.Generic;
using System.Linq;
using System.Globalization;
using System.Collections;
using CSharpFunctionalExtensions;
using System.Text.RegularExpressions;
using System.ComponentModel;
using System.Reflection;

public class Program
{
	public static void Main()
	{
		var culture = SetCulture();
		Console.WriteLine($"________________________________________________________________________________________________________");
		Console.WriteLine();
		//string[] datesToTest = { /**/
		//	"03132002",
		//	"23132002",
		//	"03121980",
		//	"03112002",
		//	"1800",
		//	"2239",
		//	"2007",
		//	"2021",
		//	"052016",
		//	"122019",
		//	"23122022",
		//	"2017",
		//	"10122022",
		//	"20__",
		//	"23122019",
		//	"29122022",
		//	"21122022",
		//	"20122012",
		//	"20122011",
		//	"20/12/2011",
		//	"20-12-2011",
		//	"12/2019",
		//	"12-2019",
		//	"December2001",
		//	"Dezembro2019",
		//	"Dezembro/2001",
		//	"04 de Dezembro de 2001",
		//	"06Dezembro2001",
		//	"06Dez2001",
		//	"06Dec2001",
		//	"20230605161406"
		//};		
		string[] datesToTest = { /**/
			"03132002",
			"23132002",
			"03121980",
			"03112002",
			"1800",
			"2239",
			"2007",
			"2021",
			"052016",
			"122019",
			"23122022",
			"2017",
			"10122022",
			"20__",
			"23122019",
			"29122022",
			"21122022",
			"20122012",
			"20122011",
			"20/12/2011",
			"20-12-2011",
			"12/2019",
			"12-2019",
			"December2001",
			"Dezembro2019",
			"Dezembro/2001",
			"04 de Dezembro de 2001",
			"06Dezembro2001",
			"06Dez2001",
			"06Dec2001",
			"20230605161406"
		};
		TestDates(datesToTest, culture);
		Console.WriteLine();
		TestDates(datesToTest, new CultureInfo("en-US"));
		Console.WriteLine($"________________________________________________________________________________________________________");
		Console.WriteLine();
		Console.WriteLine($"-----------------------Testing Intervals-------------------------------------------------");
		//string[] intervalsToTest = {
		//	(" entre 2022 e 2021"), 
		//	(" entre 2013 e 2021"), 
		//	("entre 2013 e 2021"), 
		//	(" entre 19092007 e 12092022"), 
		//	(" entre 09192007 e 09122022"), 
		//	(" entre 19092022 e 12092022"), 
		//	(" entre 09192022 e 09122022"), 
		//	(" de 092017 até 102018"), 
		//	("de 092019 até 102018"), 
		//	(" de 2017 a 2018"), 
		//	(" de 1017 a 2318")
		//	};
		//		
		(string date, bool forceBeginDatePreviousYearIfReasonable)[] intervalsToTest = {
			(" entre 2022 e 2021", false), 
			(" entre 2013 e 2021", false), 
			("entre 2013 e 2021", false), 
			(" entre 19092007 e 12092022", false), 
			(" entre 09192007 e 09122022", false), 
			(" entre 19092022 e 12092022", false), 
			(" entre 09192022 e 09122022", false), 
			(" de 092017 até 102018", false), 
			("de 092019 até 102018", false), 
			(" de 2017 a 2018", false), 
			(" de 1017 a 2318", false),
			("de 2109 até 21102022", false), // err: 2109 interpreted as yyyy
			("de 2111 até 21102022", false),
			("de 2111 até 21102022", true),
			("de 21 até 23102022", false)
		};
		TestInterval(intervalsToTest, culture);
		Console.WriteLine();
		TestInterval(intervalsToTest, new CultureInfo("en-US"));
		Console.WriteLine();
		Console.WriteLine($"-----------------------Testing Dates-------------------------------------------------");
		var pattern = @"\b(?<datewithoutday>(?<month>0[1-9]|1[012])(?<year>19|20[0-9]{2}))|(?<datewithday>(?<day>0[1-9]|[12][0-9]|3[01])(?<month>0[1-9]|1[012])(?<year>19[0-9]{2}|20[0-9]{2}|21[0-9]{2}))|(?<dateonlyyear>(?<year>19[0-9]{2}|20[0-9]{2}|21[0-9]{2}))\b";
		// https://stackoverflow.com/questions/20490884/how-to-create-an-array-of-tuples
		//(string date, string replacePattern, string mask, bool acceptWildCard)[] datesWithMaskToTest = {
		//		("20__", string.Empty, "yyyy", true),
		//		("20__", string.Empty, "yyyy", false),
		//		("2006", string.Empty, "yyyy", false),
		//		("2138", string.Empty, "yyyy", false),
		//		("9238", string.Empty, "yyyy", false),
		//		("092006", @"$2/$3", "MM/yyyy", false),
		//		("122006", @"$2/$3", "MM/yyyy", false),
		//		("129238", @"$2/$3", "MM/yyyy", false),
		//		("122138", @"$2/$3", "MM/yyyy", false),
		//		("12-2138", @"$2$3", "MM-yyyy", false),
		//		("03032020", @"$5/$2/$3", "dd/MM/yyyy", false),
		//		("12092006", @"$5/$2/$3", "dd/MM/yyyy", false),
		//		("12-01-2138", @"$5$2$3", "dd-MM-yyyy", false)
		//	};		
		(string date, string replacePattern, string mask, bool acceptWildCard)[] datesWithMaskToTest = {
			("20__", string.Empty, "yyyy", true),
			("20__", string.Empty, "yyyy", false),
			("2006", string.Empty, "yyyy", false),
			("2138", string.Empty, "yyyy", false),
			("9238", string.Empty, "yyyy", false),
			("092006", @"$2/$3", "MM/yyyy", false),
			("122006", @"$2/$3", "MM/yyyy", false),
			("129238", @"$2/$3", "MM/yyyy", false),
			("122138", @"$2/$3", "MM/yyyy", false),
			("12-2138", @"$2$3", "MM-yyyy", false),
			("03032020", @"$5/$2/$3", "dd/MM/yyyy", false),
			("12092006", @"$5/$2/$3", "dd/MM/yyyy", false),
			("12-01-2138", @"$5$2$3", "dd-MM-yyyy", false)
		};
		foreach (var d in datesWithMaskToTest)
		{
			TestDate(d.date, pattern, d.replacePattern, d.mask, culture, d.acceptWildCard);
			var result = DateInSentence.FilterAbsurdDates(Result.Success(d.date), culture, d.acceptWildCard);
			//Console.WriteLine($"This date is {(result.returnedDate.IsSuccess ? "valid" : "not valid: " + result.returnedDate.Error)}");
			Console.WriteLine($"This date is {(result.IsSuccess ? "valid" : "not valid: " + result.Error)}");
			Console.WriteLine("#################################################################################");
		}

		;
		const string GrabDatesUTC = @"(?<dateUTC>(?<year>-?(?:[1-9][0-9]*)?[0-9]{4})-(?<month>1[0-2]|0[1-9])-(?<day>3[01]|0[1-9]|[12][0-9])T(?<hour>2[0-3]|[01][0-9]):(?<minute>[0-5][0-9]):(?<second>[0-5][0-9])(\\.[0-9]+)?(?<zeroUTCoffse>Z)?|(?<year>(?:[1-9][0-9]*)?[0-9]{4})(?<month>1[0-2]|0[1-9])(?<day>3[01]|0[1-9]|[12][0-9])(?<hour>2[0-3]|[01][0-9])(?<minute>[0-5][0-9])(?<second>[0-5][0-9])(\\.[0-9]+)?(?<zeroUTCoffse>Z)?)";
		TestDate("20230605161406", GrabDatesUTC, string.Empty, "yyyyMMddHHmmss", culture, false);
	}

	static CultureInfo SetCulture()
	{
		// Get the current UI culture
		//CultureInfo uiCulture = CultureInfo.CurrentUICulture;
		//Console.WriteLine($"The current UI culture is {uiCulture.Name}");
		// Set the current UI culture
		//CultureInfo.CurrentUICulture = new CultureInfo("pt-BR");		
		// https://phrase.com/blog/posts/all-you-need-to-know-about-cultureinfo-in-net-applications/
		CultureInfo culture = CultureInfo.CurrentCulture;
		Console.WriteLine($"The current culture DisplayName is {culture.DisplayName}");
		Console.WriteLine($"The current culture NativeName is {culture.NativeName}");
		Console.WriteLine($"The current culture IsNeutralCulture? {culture.IsNeutralCulture}");
		//var culture = CultureInfo.InvariantCulture; //= en-US
		// Set the current culture
		culture = new CultureInfo("pt-BR"); //("en-US");		
		Console.WriteLine($"After setting, CultureInfo is {culture.Name.ToString()}");
		Console.WriteLine($"After setting, CultureInfo DisplayName is {culture.DisplayName}");
		Console.WriteLine($"After setting, CultureInfo NativeName is {culture.NativeName}");
		Console.WriteLine($"The current culture IsNeutralCulture? {culture.IsNeutralCulture}");
		CultureInfo.CurrentCulture = culture;
		return culture;
	}

	static void TestDates(string[] datesToTest, CultureInfo culture)
	{
		DateTime dateToTest = DateTime.MinValue;
		Console.WriteLine($"################################################ Dates ({culture.Name.ToString()}) ################################################");
		var orderedDates = new List<(DateTime date, string rawDate)>();
		foreach (var date in datesToTest)
		{
			var isDate = DocNameHelper.DateTryParseExact(date, out dateToTest, culture);
			var result = DateInSentence.FilterAbsurdDates(Result.Success(date), culture);
			//Console.WriteLine($"This date is {(result.IsSuccess ? "valid" : "not valid: " + result.Error )}");			
			//dateToTest = result.returnedDate.IsSuccess ? dateToTest : DateTime.MinValue;
			dateToTest = result.IsSuccess ? dateToTest : DateTime.MinValue;
			orderedDates.Add((dateToTest, date));
		}

		orderedDates.Sort();
		foreach (var(date, rawDate)in orderedDates)
		{
			Console.WriteLine($"------------------------------------------------------------------------");
			var isDate = date != DateTime.MinValue;
			Console.WriteLine(@$"{rawDate, 25} é data? {isDate}{(isDate ? ": " + date.ToString() : "")}");
		//if (isDate) Console.WriteLine($"{rawDate}");			
		}
	}

	static void TestInterval((string date, bool forceBeginDatePreviousYearIfReasonable)[] intervalsToTest, CultureInfo culture)
	{
		const string GrabDateIntervalFromPartOfFile = @"(?<=\W)(?<interval>(?<starting>[ mçinícandouetr]+?)(?<datebegin>\d+)(?<link>[ eatéfimnldzou]+?)(?<=\W)(?<!\w-)(?<dateend>\d+))";
		Console.WriteLine($"################################################ Intervals ({culture.Name.ToString()}) ################################################");
		foreach (var interval in intervalsToTest)
		{
			var (begin, end) = GetInterval(interval.date, GrabDateIntervalFromPartOfFile);
			var result = DateInSentence.FilterAbsurdDates(Result.Success(begin), culture);
			//######//######### From TestingIntervalWithCombinationsOfYearInDates_IfBeginDateEarlierThanEndDate_ShouldPass			
			var (dateBegin, dateEnd) = IntervalInSentence.GetIntervalDates(interval.date, string.Empty);
			var beginIsDDMM = DocNameHelper.IsItPossibleToBeDDMMOrMMDD(dateBegin.Value, CultureInfo.CurrentCulture);
			//Assert.True(beginIsDDMM);
			var endIsDDMM = DocNameHelper.IsItPossibleToBeDDMMOrMMDD(dateEnd.Value, CultureInfo.CurrentCulture);
			//Assert.False(endIsDDMM);
			var validEndInterval = DocNameHelper.DateTryParseExact(dateEnd.Value, out var endInterval, CultureInfo.CurrentCulture, endIsDDMM);
			bool validBeginInterval = false;
			DateTime beginInterval = default;
			bool intervalInvalidBecauseBeginDateAfterEndDate = false;
			var dateParsed = InNameDate.CreateInstance(dateEnd.Value, CultureInfo.CurrentCulture, 2025);
	//
	//		bool beginDDMMDateIsInPreviousYear = false;
	//		
	//		
	//		var formatForDDMM = dateParsed.Mask;
	//		beginDDMMDateIsInPreviousYear =
	//			!DocNameHelper.IsDDMMBeginDateReallyBeforeEndDate(dateBegin.Value, endDateDDMM,
	//				CultureInfo.CurrentCulture, formatForDDMM);
	//		if (beginDDMMDateIsInPreviousYear && forcePreviousYearInDateBeginIfNeeded)
	//		{
	//			validBeginInterval =
	//				DocNameHelper.DateWithNoYearTryParseExact(dateBegin.Value, out beginInterval,
	//					CultureInfo.CurrentCulture, (endInterval.Year - 1).ToString());
	//		}
	//		else
	//		{
	//			validBeginInterval =
	//				DocNameHelper.DateWithNoYearTryParseExact(dateBegin.Value, out beginInterval,
	//					CultureInfo.CurrentCulture, endInterval.Year.ToString());
	//		}
	//	}

		//if (validBeginInterval && validEndInterval && !beginDDMMDateIsInPreviousYear)
		//	Assert.Equal((beginInterval < endInterval), isValid);
		//if (beginDDMMDateIsInPreviousYear && !forcePreviousYearInDateBeginIfNeeded)
		//	Assert.True(beginInterval > endInterval);

			intervalInvalidBecauseBeginDateAfterEndDate =// false;
					!DocNameHelper.IsDDMMBeginDateReallyBeforeEndDate(dateBegin.Value, dateEnd.Value,
																	  CultureInfo.CurrentCulture, dateParsed.Mask);
			validBeginInterval = DocNameHelper.DateTryParseExact(dateBegin.Value, out beginInterval, CultureInfo.CurrentCulture, beginIsDDMM);
			var errorMsgBeginDateAfterEndDate = intervalInvalidBecauseBeginDateAfterEndDate ? " because BeginDate is After EndDate" : string.Empty;
			var errorMsgInvalidBeginDateOrEndDate = result.IsFailure ? " because of BeginDate and/or EndDate are not valid" : string.Empty;
			Console.WriteLine($"Interval is {(intervalInvalidBecauseBeginDateAfterEndDate || result.IsFailure ? "INVALID" + errorMsgBeginDateAfterEndDate + errorMsgInvalidBeginDateOrEndDate : "Valid")}");
			//######//######### From TestingIntervalWithCombinationsOfYearInDates_IfBeginDateEarlierThanEndDate_ShouldPass						
			Console.WriteLine($"Begin date ({begin}) is {(result.IsSuccess ? "valid" : "not valid: " + result.Error)}. Mask: {dateParsed.Mask}.");
			result = DateInSentence.FilterAbsurdDates(Result.Success(end), culture);
			//Console.WriteLine($"End date ({end}) is {(result.returnedDate.IsSuccess ? "valid" : "not valid: " + result.returnedDate.Error)}");
			Console.WriteLine($"End date ({end}) is {(result.IsSuccess ? "valid" : "not valid: " + result.Error)}");
			Console.WriteLine("#################################################################################");
		}
	}
	static (string begin, string end) GetInterval(string rawInterval, string pattern)
	{
		//	Comparecimentos em sessões de fisioterapia em 2012 e 2015
		//Prontuário Itaú entre 19092007 e 12092022
		//Receitas ortopédicas entre 2013 e 2021
		// entre 2013 e 2021	
		var match = DocNameHelper.GetMatch(pattern, rawInterval); //, "dateend");
		Console.WriteLine($"##interval: {DocNameHelper.GetMatchMainGroup(pattern, rawInterval).Value}-------------------------------------------------"); // == match.Groups[0].Value.Dump("interval");
		Console.WriteLine($"starting: {DocNameHelper.GetMatch(pattern, rawInterval, "starting").Value}");
		Console.WriteLine($"datebegin: {match.Groups["datebegin"].Value}");
		Console.WriteLine($"link: {match.Groups["link"].Value}");
		Console.WriteLine($"dateend: {match.Groups["dateend"].Value}");
		return (match.Groups["datebegin"].Value, match.Groups["dateend"].Value);
	//var matches = GetMatches(pattern, " entre 2013 e 2021");
	//matches.Dump(); //"matches"
	}

	static void TestDate(string rawDate, string pattern, string replacePattern, string toTryParseExact, CultureInfo culture, bool acceptWildCard)
	{
		Console.WriteLine($"{rawDate}:");
		DateTime date = DateTime.MinValue;
		//var matches = Regex.Matches(rawDate, pattern);
		//matches.Dump();
		var dateFormatted = string.Empty;
		if (string.IsNullOrEmpty(replacePattern))
		{
			dateFormatted = rawDate;
		}
		else
		{
			dateFormatted = Regex.Replace(rawDate, pattern, replacePattern);
		}

		Console.WriteLine($"      dateFormatted {dateFormatted}:");
		dateFormatted.Dump();
		Console.WriteLine($"      TryParseExact with {toTryParseExact}:");
		DateTime.TryParseExact(dateFormatted, toTryParseExact // error if dd/mm or dd/mmm 
		, null, DateTimeStyles.AssumeLocal, out date);
		date.Dump();
		Console.WriteLine($"      TryParse:");
		DateTime.TryParse(dateFormatted, null, DateTimeStyles.AssumeLocal, out date);
		date.Dump();
		Console.WriteLine($"      FilterAbsurdDates with acceptWildCard = {acceptWildCard}:");
		var filter = DateInSentence.FilterAbsurdDates(Result.Success(dateFormatted), culture, acceptWildCard);
		filter.Dump();
	}
//
//Excised methods were here
//	
}

// ###################            ##################################      Enums      ##################################            ###################
public enum DateFormat
{
        NoDate = -1,
        yyyy = 0,
        MMyyyy,
        MMMyyyy,
        MMMMyyyy,

        MMdd,
        MMMdd,
        MMMMdd,
        MMddyyyy,
        MMMddyyyy,
        MMMMddyyyy,

        ddMM,
        ddMMM,
        ddMMMM,
        ddMMyyyy,
        ddMMMyyyy,
        ddMMMMyyyy,

        dd,
        MM,
        MMM,
        MMMM,

        yyyyMM,
        yyyyMMM,
        yyyyMMMM,
        yyyyMMdd,
        [Description("dd/MM/yyyy HH:mm:ss")]
        completeUpToSeconds,
        [Description("MM/dd/yyyy HH:mm:ss")]
        completeUpToSecondsUS,
        [Description("yyyyMMddHHmmss")]
        sortable,
        [Description("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'")]
		universalSortable
}

public enum CertaintyAboutElement
{
	NonExisting = -1,
	AbsolutelyCertain = 0,
	InformedGuess,
	InformedByUser,
	NotSure
}

public enum DocNamePart
{
	NoPart = 0,
	First,
	Middle,
	Last,
	Extension
}

public enum ElementRelativePosition
{
	DoesNotExist = 0,
	First,
	Middle,
	Last,
//Second,
//Third,
//Fourth,
//Fifty
}

public enum WhichElementItIs
{
	DoesNotExist = 0,
	WhicheverVersion,
	VersionNumberOnly,
	VersionWithPrefix,
	FileNameDate,
	FileNameInterval,
	GUID,
	DrugNameDose
}

// ###################            ##################################      Enums      ##################################            ###################
// ###################            ##################################      DocNameHelper      ##################################            ###################
public static class DocNameHelper
{
#region Public Constants
	public const string GrabNameAndExtension = @"(?<fullname>.+?)(\.(?<extension>[^.]*)$|$)"; //https://regex101.com/r/ThSD20/1
	public const string GrabPartsOfName = @"([\w _<>+;.,']*)*"; //https://regex101.com/r/mduYnK/2
	public const string GrabDelimiterWithSpaceAround = @"( - )";
	public const string GrabFakeDelimiterWithoutAnySpaceAround = @"(?<before>[\d\w' -.]*)(?<=\w)(?<FakeDelimiter>[-˗–])(?=\w)(?<after>[\d\w -.]*)";
	//https://regex101.com/r/dMMzEW/2
	public const string TemporarySubstitutionForFakeDelimiter = @"${before}<>${after}";
	public const string GrabTemporarySubstitutionForFakeDelimiter = @"(?<before>[\d\w -.]*)(?<=\w)(?<FakeDelimiter>\<\>)(?=\w)(?<after>[\d\w -.]*)";
	public const string RestorePreviousStateBeforeFakeDelimiter = @"${before}-${after}";
#endregion Public Constants
#region Common
	//        public static string StripOffDateIntervalVersionAndDrug(string partToBeStrippedOff, DocPartElementsMount docNameElements
	//            , string date = "", string version = "", string interval = "", string medicineAndDose = "")
	//        {
	//        }
	//        public static string StripOffPartWithConnector(string partToBeStrippedOff, string partToStrip
	//            , WhichElementItIs whichElementItIs, DocPartElementsMount docNameElements)
	//        {
	//
	//        }
	public static string StripOffPart(string partToBeStrippedOff, string partToRemove, string connectorBefore)
	{
		if (!string.IsNullOrEmpty(connectorBefore) && !string.IsNullOrWhiteSpace(connectorBefore))
			partToRemove = connectorBefore + partToRemove;
		if (!string.IsNullOrWhiteSpace(partToRemove))
			partToBeStrippedOff = partToBeStrippedOff.Replace(partToRemove.Trim(), string.Empty);
		return partToBeStrippedOff = partToBeStrippedOff.Trim();
	}

	public static bool DifficultyToTestPart(string partToTest)
	{
		return partToTest.Length > 10 && partToTest.DoesNotContainAnySpace();
	}

	public static Result<string> ReturnResult(string pattern, string part, string groupName, string errorMsg)
	{
		_ = GetMatch(pattern, part, groupName, errorMsg, out var result);
		//if ((!result.IsFailure && OutOfForbiddenZoneIfSamePart(groupName, partName, match, partHasGUID)) || !isDate) return result;
		//if (!result.IsFailure && OutOfForbiddenZoneIfSamePart(groupName, match, partHasGUID) || !isDate) return result;
		return result;
	}

	//GetMatch is a poor name...
	//Used in App
	internal static Match GetMatch(string pattern, string part, string groupName, string errorMsg, out Result<string> result)
	{
		var rgx = new Regex(pattern);
		var match = rgx.Match(" " + part.TrimStart());
		//BUG                     ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
		//Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
		result = match.Success ? Result.Success(match.Groups[groupName].Value.Trim()) : Result.Failure<string>(errorMsg);
		return match;
	}

	//Used in NetFiddle
	internal static Match GetMatch(string pattern, string part) //, string groupName)
	{
		var rgx = new Regex(pattern);
		var match = rgx.Match(" " + part);
		//BUG                ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
		//Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
		return match;
	}

	//Used in NetFiddle
	internal static Group GetMatchMainGroup(string pattern, string part) //, string groupName)
	{
		var rgx = new Regex(pattern);
		var match = rgx.Match(part.EnsureOneSingleSpaceAtBegin());
		//BUG                ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
		//Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
		return match.Groups[0];
	}

	//Used in NetFiddle
	internal static Group GetMatch(string pattern, string part, string groupName)
	{
		var rgx = new Regex(pattern);
		var match = rgx.Match(part.EnsureOneSingleSpaceAtBegin());
		//BUG                ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
		//Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
		return match.Groups[groupName];
	}

	//Not used anywhere
	internal static MatchCollection GetMatches(string pattern, string part)
	{
		var rgx = new Regex(pattern);
		var matches = rgx.Matches(part.EnsureOneSingleSpaceAtBegin());
		//BUG                    ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 		
		return matches;
	}

	internal static bool OutOfForbiddenZoneIfSamePart(string groupName, Match match, int startOfForbiddenZone, int endOfForbiddenZone)
	{
		return BeforeStartOfForbiddenZone(groupName, match, startOfForbiddenZone) && AfterEndOfForbiddenZone(groupName, match, endOfForbiddenZone);
	}

	private static bool BeforeStartOfForbiddenZone(string groupName, Match match, int startOfForbiddenZone)
	{
		return match.Groups[groupName].Index + match.Groups[groupName].Length - 1 < startOfForbiddenZone;
	}

	private static bool AfterEndOfForbiddenZone(string groupName, Match match, int endOfForbiddenZone)
	{
		return match.Groups[groupName].Index > endOfForbiddenZone;
	}

#endregion Common
#region Interval and Date
	public static string[] dubiousDDMMOrYYYY() => new string[]{"2001", "2002", "2003", "2004", "2005", "2006", "2007", "2008", "2009", "2010", "2011", "2012"};
	//https://stackoverflow.com/questions/62703152/convert-two-fields-month-and-year-into-a-yyyy-mm-dd-field
	public static string[] dubiousMMDDOrYYYY() => new string[]{""}; //??
	//public static Result<string> TreatIntervalComparingItWithDate(Result<string> interval, Result<string> fileDate)
	//{
	//    if (!fileDate.IsSuccess) return interval;
	//    if (interval.IsSuccess && fileDate.Value == interval.Value)
	//        return Result.Failure<string>("No interval date stamp in this file name");
	//    return interval;
	//}
	//TODO: maybe I should try to equalize years of interval dates, if they are not equal
	//OLD: TryEqualizeYearsOfIntervalDates
	internal static (Result<InNameDate> dateBegin, Result<InNameDate> dateEnd) TryCompareIntervalDates(string dateBegin, string dateEnd, CultureInfo cultureInfo, bool sameFrameIntervalIsAllowed = false)
	{
		var errorMsg = string.Empty;
		var isDDMM = cultureInfo.Name == "pt-BR";
		if (dateBegin.IsNumber() && dateEnd.IsNumber())
		{
			switch (dateEnd.Length)
			{
				case 8: //ddMMyyyy
					var formatEnd = isDDMM
						? DateFormat.ddMMyyyy
						: DateFormat.MMddyyyy;
					var dateEndIsDDMM = DateTime.TryParseExact(dateEnd, formatEnd.GetDescription(),
															   cultureInfo, DateTimeStyles.None, out var dateEnded);
					if (dateBegin.Length == 8) //ddMMyyyy
					{
						var date = InNameDate.CreateInstance(dateBegin, cultureInfo, 2025, false);
						//var (mask, format) = FormatForDDMMYYYYBasedOn(cultureInfo);
						var (mask, format) = (date.Mask.GetDescription(), date.Mask);
						var validDates = TryToParseDatesAsDDMM_MMDD(dateBegin, dateEnd, cultureInfo, mask);
						if (validDates.dateStarted != DateTime.MinValue && validDates.dateEnded != DateTime.MinValue)
						{
							if (IsDDMMBeginDateReallyBeforeEndDate(dateBegin, dateEnd, cultureInfo, DateFormat.ddMMyyyy,
																   sameFrameIntervalIsAllowed))
							{
								return (Result.Success(InNameDate.CreateInstance(dateBegin, validDates.dateStarted, format))
										, Result.Success(InNameDate.CreateInstance(dateEnd, validDates.dateEnded, format)));
							}
						}
					}
					else if (dateBegin.Length == 6) //almost impossible MMyyyy
					{
						throw new NotImplementedException("I did not implemented 'de MMyyyy até ddMMyyyy'");
					}
					else if (dateBegin.Length == 4) //ddmm
					{
						var dateBeginIsDDMM = DateTime.TryParseExact(dateBegin + dateEnded.Year, formatEnd.GetDescription(),
																	 cultureInfo, DateTimeStyles.None, out var ddMMBegin);
						if (IsBeginDateReallyBeforeEndDate(ddMMBegin, dateEnded, sameFrameIntervalIsAllowed))
						{
							return (Result.Success(InNameDate.CreateInstance(dateBegin + dateEnded.Year, ddMMBegin, formatEnd)), 
									Result.Success(InNameDate.CreateInstance(dateEnd, dateEnded, formatEnd))
								   );
						}
					}
					else if (dateBegin.Length == 2) //dd
					{
						var dayBegin = int.Parse(dateBegin); //dateBegin.Substring(0, 2);
						if ((dayBegin > 0 && dayBegin < dateEnded.Day) || ((dayBegin == dateEnded.Day) && sameFrameIntervalIsAllowed))
						{
							var dayInterval = Result.Success(InNameDate.CreateInstance(dateBegin,
																					   new DateTime(dateEnded.Year, dateEnded.Month, dayBegin), DateFormat.dd));
							return (dayInterval, 
									Result.Success(InNameDate.CreateInstance(dateEnd, dateEnded, formatEnd))
								   );
						}
					}
					break;
				case 6: //MMyyyy
					if (dateBegin.Length == 8) //almost impossible ddMMyyyy
					{
						throw new NotImplementedException("I did not implemented 'de ddMMyyyy até MMyyyy'");
					}
					else if (dateBegin.Length == 6) //MMyyyy
					{

					}
					else if (dateBegin.Length == 4) //almost impossible ddMM; I do not think about MMyy
					{
						throw new NotImplementedException("I did not implemented 'de ddMM até MMyyyy'");
					}
					else if (dateBegin.Length == 2) //MM
					{

					}
					break;
				case 4: //ddmm OR yyyy ???
					if (dateBegin.Length == 8) //almost impossible ddMMyyyy
					{

					}
					else if (dateBegin.Length == 6) //almost impossible MMyyyy
					{

					}
					else if (dateBegin.Length == 4)
					{
						//yyyy => dateEnd = yyyy
						//ddmm => dateEnd = ddmm;
						var result = DecideIfDateEndIsYYYYOrDDMM(dateBegin, dateEnd, cultureInfo, null, sameFrameIntervalIsAllowed: sameFrameIntervalIsAllowed);
						if (result.dateBegin.CertaintyAbout != CertaintyAboutElement.NonExisting)
						{
							return (Result.Success(result.dateBegin), Result.Success(result.dateEnd));
						}
					}
					else if (dateBegin.Length == 2) //dd OR MM
					{ // dateEnd = ddmm OR MMYY

					}
					break;

			}

		}
		//var dateEnd = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "dateend", errorMsg);
		//var dateBegin = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "datebegin", errorMsg);
		errorMsg = "No interval date stamp in this file name";
		return (Result.Failure<InNameDate>(errorMsg), Result.Failure<InNameDate>(errorMsg));
	}


	/// <summary>
	/// Decide if dateEnd.Length == 4 is YYYY or DDMM based or appropriate culture and maxPossibleYear.
	/// If both possibilities are valid, I'm betting that if you are not informing YYYY in two MMDD or DDMM interval,
	/// it should be YYYY instead
	/// </summary>
	/// <param name = "dateBeginToTest"></param>
	/// <param name = "dateEndToTest"></param>
	/// <param name = "cultureInfo"></param>
	/// <param name = "maxPossibleYear"></param>
	/// <param name = "minPossibleYear"></param>
	/// <param name = "sameFrameIntervalIsAllowed"></param>
	/// <returns></returns>
	internal static (InNameDate dateBegin, InNameDate dateEnd) DecideIfDateEndIsYYYYOrDDMM(string dateBeginToTest, string dateEndToTest, CultureInfo cultureInfo, int? maxPossibleYear, int minPossibleYear = 1990, bool sameFrameIntervalIsAllowed = false)
	{
		maxPossibleYear ??= InNameDate.GetCurrentYearPlus(3);
		var(isDateEndDubious, isDateBeginDubious, certaintyAboutYYYY) = DecideDegreeOfCertaintyAboutDates(dateBeginToTest, dateEndToTest, cultureInfo);
		var date = InNameDate.CreateInstance(dateBeginToTest, cultureInfo, 2025);
		//var (maskForDDMM, formatForDDMM) = FormatForDDMMBasedOn(cultureInfo);			
		var(maskForDDMM, formatForDDMM) = (date.Mask.GetDescription(), date.Mask);
		var dateBegin = InNameDate.NullDate;
		var dateBeginIsYYYY = false;
		var dateBeginIsDDMM = false;
		var dateEnd = InNameDate.NullDate;
		var dateEndIsYYYY = false;
		var dateEndIsDDMM = false;
		var(dateEnded, endDateMaybeYYYY) = TryToParseDateAsYYYY(dateEndToTest, cultureInfo);
		var(dateStarted, beginDateMaybeYYYY) = TryToParseDateAsYYYY(dateBeginToTest, cultureInfo);
		if (beginDateMaybeYYYY)
			endDateMaybeYYYY = IsValidEndDateYYYY(dateStarted, dateEnded, minPossibleYear, maxPossibleYear.Value, sameFrameIntervalIsAllowed);
		//If both possibilities are valid, I'm betting that if you are not informing YYYY in two MMDD or DDMM interval,
		//it should be YYYY instead, otherwise yyyy will get undetermined...
		(dateBeginIsYYYY, dateEndIsYYYY) = DetermineIfIntervalDatesShouldBeYYYY(isDateEndDubious, isDateBeginDubious, endDateMaybeYYYY, beginDateMaybeYYYY, dateEndIsYYYY, dateBeginIsYYYY);
		var beginCannotBeDDMMOrMMDD = !IsItPossibleToBeDDMMOrMMDD(dateBeginToTest, cultureInfo);
		if (beginCannotBeDDMMOrMMDD && !endDateMaybeYYYY)
		{
			if (dateStarted != dateEnded)
				return (InNameDate.NullDate, InNameDate.NullDate);
			//Below is by design; I do not allow interval like "between 2013 and 2013", unless for testing purposes
			if (dateStarted == dateEnded && !sameFrameIntervalIsAllowed)
				return (InNameDate.NullDate, InNameDate.NullDate);
		}

		if (dateBeginIsYYYY || beginCannotBeDDMMOrMMDD)
			(dateStarted, dateBeginIsYYYY) = TryToParseDateAsYYYY(dateBeginToTest, cultureInfo);
		else
			// The other way to do this is allow client to choose the YYYY if it is DDMM or MMDD, and allow bool forcePreviousYearInDateBeginIfNeeded = false or true
			// but this is more complicated, and implies that dateEnd.Length == 4 => 8 and,
			// if forcePreviousYearInDateBeginIfNeeded = true, maybe dateBegin.Length == 4 => 8 too...
			(dateBeginIsDDMM, dateStarted, dateEndIsDDMM, dateEnded) = TryToParseDatesAsDDMM_MMDD(dateBeginToTest, dateEndToTest, cultureInfo, maskForDDMM);
		if (dateBeginIsYYYY)
		{
			dateEndIsYYYY = DateTime.TryParseExact(dateEndToTest, DateFormat.yyyy.GetDescription(), cultureInfo, DateTimeStyles.None, out dateEnded);
			if (!dateEndIsYYYY)
				return (dateBegin, dateEnd);
			dateBegin = InNameDate.CreateInstance(dateBeginToTest, dateStarted, DateFormat.yyyy, certaintyAboutYYYY);
			dateEnd = InNameDate.CreateInstance(dateEndToTest, dateEnded, DateFormat.yyyy, certaintyAboutYYYY);
		}
		else if (dateBeginIsDDMM)
		{
			if (!dateEndIsDDMM || !IsDDMMBeginDateReallyBeforeEndDate(dateBeginToTest, dateEndToTest, cultureInfo, formatForDDMM, sameFrameIntervalIsAllowed))
				return (dateBegin, dateEnd);
			dateBegin = InNameDate.CreateInstance(dateBeginToTest, dateStarted, formatForDDMM, certaintyAboutYYYY);
			dateEnd = InNameDate.CreateInstance(dateEndToTest, dateEnded, formatForDDMM, certaintyAboutYYYY);
		}

		return (dateBegin, dateEnd);
	}

	private static (bool isDateEndDubious, bool isDateBeginDubious, CertaintyAboutElement certaintyAboutYYYY) DecideDegreeOfCertaintyAboutDates(string dateBeginToTest, string dateEndToTest, CultureInfo cultureInfo)
	{
		var dubiousDate = cultureInfo.Name == "pt-BR" ? dubiousDDMMOrYYYY() : dubiousMMDDOrYYYY();
		var isDateEndDubious = dubiousDate.Contains(dateEndToTest);
		var isDateBeginDubious = dubiousDate.Contains(dateBeginToTest);
		var certaintyAboutYYYY = isDateBeginDubious && isDateEndDubious ? CertaintyAboutElement.InformedGuess : CertaintyAboutElement.AbsolutelyCertain;
		return (isDateEndDubious, isDateBeginDubious, certaintyAboutYYYY);
	}

	private static (DateTime dateParsed, bool tryParseExact) TryToParseDateAsYYYY(string dateToTest, CultureInfo cultureInfo)
	{
		var tryParseExact = DateTime.TryParseExact(dateToTest, DateFormat.yyyy.ToString(), cultureInfo, DateTimeStyles.None, out var dateParsed);
		return (dateParsed, tryParseExact);
	}

	private static (bool dateBeginIsDDMM, DateTime dateStarted, bool dateEndIsDDMM, DateTime dateEnded) TryToParseDatesAsDDMM_MMDD(string dateBeginToTest, string dateEndToTest, CultureInfo cultureInfo, string maskForDDMM)
	{
		var dateBeginIsDDMM = DateTime.TryParseExact(dateBeginToTest, maskForDDMM, cultureInfo, DateTimeStyles.None, out var dateStarted);
		var dateEndIsDDMM = DateTime.TryParseExact(dateEndToTest, maskForDDMM, cultureInfo, DateTimeStyles.None, out var dateEnded);
		return (dateBeginIsDDMM, dateStarted, dateEndIsDDMM, dateEnded);
	}

	private static (bool dateBeginIsYYYY, bool dateEndIsYYYY) DetermineIfIntervalDatesShouldBeYYYY(bool isDateEndDubious, bool isDateBeginDubious, bool endDateMaybeYYYY, bool beginDateMaybeYYYY, bool dateEndIsYYYY, bool dateBeginIsYYYY)
	{
		if (IfNoDateIsDubious(isDateEndDubious, isDateBeginDubious))
			return (endDateMaybeYYYY, beginDateMaybeYYYY);
		if (AtLeastSomeDateIsDubiousAndBothDatesMaybeYYYY(endDateMaybeYYYY, beginDateMaybeYYYY))
			return (true, true);
		//AtLeastSomeDateIsDubious and only one date is maybe YYYY:
		return (dateBeginIsYYYY, dateEndIsYYYY);
	}

	private static bool AtLeastSomeDateIsDubiousAndBothDatesMaybeYYYY(bool endDateMaybeYYYY, bool beginDateMaybeYYYY)
	{
		return endDateMaybeYYYY && beginDateMaybeYYYY;
	}

	private static bool IfNoDateIsDubious(bool isDateEndDubious, bool isDateBeginDubious)
	{
		return !isDateEndDubious && !isDateBeginDubious;
	}

	internal static bool IsItPossibleToBeDDMMOrMMDD(string dateToTest, CultureInfo cultureInfo)
	{
		if (dateToTest.Length != 4)
			return false;
		return DateTime.TryParseExact(dateToTest, DateFormat.ddMM.GetDescription(), cultureInfo, DateTimeStyles.None, out _) || DateTime.TryParseExact(dateToTest, DateFormat.MMdd.GetDescription(), cultureInfo, DateTimeStyles.None, out _);
	}

	/// <summary>
	/// This function is used to decide if the dateBegin is really before dateEnd
	/// </summary>
	/// <param name = "dateBegin"></param>
	/// <param name = "dateEnd"></param>
	/// <param name = "cultureInfo"></param>
	/// <param name = "sameFrameIntervalIsAllowed"></param>
	/// <returns></returns>
	internal static bool IsDDMMBeginDateReallyBeforeEndDate(string dateBegin, string dateEnd, CultureInfo cultureInfo, DateFormat dateFormat, bool sameFrameIntervalIsAllowed = false)
	{
		//var maskForDDMM = MaskForDateParsing(cultureInfo, dateFormat);
		var beginDateValid = DateTime.TryParseExact(dateBegin, dateFormat.GetDescription(), cultureInfo, DateTimeStyles.None, out var beginDate);
		//var beginDate = DateTime.ParseExact(dateBegin, dateFormat.GetDescription(), cultureInfo);
		var endDateValid = DateTime.TryParseExact(dateEnd, dateFormat.GetDescription(), cultureInfo, DateTimeStyles.None, out var endDate);
		if (!beginDateValid || !endDateValid)
			return false;
		//var endDate = DateTime.ParseExact(dateEnd, dateFormat.GetDescription(), cultureInfo);
		return IsBeginDateReallyBeforeEndDate(beginDate, endDate, sameFrameIntervalIsAllowed);
	//sameFrameIntervalIsAllowed ? beginDate <= endDate : beginDate < endDate;
	}

	internal static bool IsBeginDateReallyBeforeEndDate(DateTime dateBegin, DateTime dateEnd, bool sameFrameIntervalIsAllowed) => sameFrameIntervalIsAllowed ? dateBegin <= dateEnd : dateBegin < dateEnd;
	internal static bool IsValidEndDateYYYY(DateTime dateBegin, DateTime dateEnd, int minPossibleYear, int maxPossibleYear, bool sameYearIntervalIsAllowed)
	{
		if (!IsBeginDateReallyBeforeEndDate(dateBegin, dateEnd, sameYearIntervalIsAllowed))
			return false;
		return dateEnd.Year >= minPossibleYear && dateEnd.Year <= maxPossibleYear;
	}

	//internal static (string mask, DateFormat dateFormat) FormatForDDMMBasedOn(CultureInfo cultureInfo)
	//{
	//	var isFormatLikeDDMM = cultureInfo.Name == "pt-BR";
	//	var maskForDDMM = isFormatLikeDDMM ? DateFormat.ddMM.GetDescription() : DateFormat.MMdd.GetDescription();
	//	var formatForDDMM = isFormatLikeDDMM ? DateFormat.ddMM : DateFormat.MMdd;
	//	return (maskForDDMM, formatForDDMM);
	//}
	//internal static (string mask, DateFormat dateFormat) FormatForDDMMYYYYBasedOn(CultureInfo cultureInfo)
	//{
	//	var isFormatLikeDDMM = cultureInfo.Name == "pt-BR";
	//	var maskForDDMM = isFormatLikeDDMM ? DateFormat.ddMMyyyy.GetDescription() : DateFormat.MMddyyyy.GetDescription();
	//	var formatForDDMM = isFormatLikeDDMM ? DateFormat.ddMMyyyy : DateFormat.MMddyyyy;
	//	return (maskForDDMM, formatForDDMM);
	//}
	//static int GetCurrentYearPlus(int toAddCurrent)
	//{
	//    return DateTime.Now.Year + toAddCurrent;
	//}
#endregion Interval and Date
#region GUID
	//public static string TreatPartWithGUID(string part, InNameGUID partHasGUID, DocPartElementsMount docNameElements, int numOfCharOfConnectorBefore = 1)
	//{         
	//    var connector = docNameElements.AddConnectorBeforeElement(WhichElementItIs.GUID,
	//        part.GetNumberOfCharsJustBeforeSubstring(partHasGUID.GUID, numOfCharOfConnectorBefore));
	//    return StripOffPart(part, partHasGUID.GUID, connector);
	//}
#endregion GUID
#region MedicinesAndDosage
#endregion MedicinesAndDosage
#region Version
	//public static bool CheckIfVersionIsFirst(string partToTest, Result<string> fileVersion, Result<string> fileDate)
	//{
	//    //By default, version always should be first, before date
	//    if (!fileVersion.IsSuccess || !fileDate.IsSuccess) return true;
	//    var whereVersion = partToTest.IndexOf(fileVersion.Value, StringComparison.CurrentCulture);
	//    var whereDate = partToTest.IndexOf(fileDate.Value, StringComparison.CurrentCulture);
	//    return whereVersion < whereDate;
	//}
#endregion Version
#region Dates
	/// <summary>
	/// 
	/// </summary>
	/// <param name = "dateWithoutSpace"></param>
	/// <param name = "testDate"></param>
	/// <param name = "cultureInfo"></param>
	/// <returns></returns>
	internal static bool DateWithNoYearTryParseExact(string dateWithNoYearAndWithoutSpace, string yearToAssume, out DateTime testDate, CultureInfo cultureInfo)
	{
		//Guard.ThrowIfStringNullOrEmptyOrNotString(dateWithNoYearAndWithoutSpace, nameof(dateWithNoYearAndWithoutSpace));
		ArgumentException.ThrowIfNullOrEmpty(dateWithNoYearAndWithoutSpace);
		//Guard.ThrowIfStringNullOrEmptyOrNotString(yearToAssume, nameof(yearToAssume));
		ArgumentException.ThrowIfNullOrEmpty(yearToAssume);
		return DateTryParseExact(dateWithNoYearAndWithoutSpace + yearToAssume, out testDate, cultureInfo);
	}

	/// <summary>
	/// TODO: internal open to Test
	/// </summary>
	/// <param name = "dateWithoutSpace"></param>
	/// <param name = "testDate"></param>
	/// <param name = "cultureInfo"></param>
	/// <returns></returns>
	internal static bool DateTryParseExact(string dateWithoutSpace, out DateTime testDate, CultureInfo cultureInfo, bool forceDDMM = false)
	{
		//https://dotnetfiddle.net/F6fGPt
		//https://learn.microsoft.com/en-us/dotnet/standard/base-types/parsing-datetime
		//https://stackoverflow.com/questions/10029099/datetime-parse2012-09-30t230000-0000000z-always-converts-to-datetimekind-l
		//Guard.ThrowIfStringNullOrEmptyOrNotString(dateWithoutSpace, nameof(dateWithoutSpace));
		ArgumentException.ThrowIfNullOrEmpty(dateWithoutSpace);
		var yyyy = forceDDMM ? string.Empty : DateFormat.yyyy.GetDescription();
		var isDDMM = cultureInfo.Name == "pt-BR";
		var ddMMyyyy = isDDMM ? DateFormat.ddMMyyyy.GetDescription() : DateFormat.MMddyyyy.GetDescription();
		var ddMMMyyyy = isDDMM ? DateFormat.ddMMMyyyy.GetDescription() : DateFormat.MMMddyyyy.GetDescription();
		var ddMMMMyyyy = isDDMM ? DateFormat.ddMMMMyyyy.GetDescription() : DateFormat.MMMMddyyyy.GetDescription();
		var ddMM = isDDMM ? DateFormat.ddMM.GetDescription() : DateFormat.MMdd.GetDescription();
		var ddMMM = isDDMM ? DateFormat.ddMMM.GetDescription() : DateFormat.MMMdd.GetDescription();
		var ddMMMM = isDDMM ? DateFormat.ddMMMM.GetDescription() : DateFormat.MMMMdd.GetDescription();
		var ddMMyyyyHHmmssWithSlash = isDDMM ? DateFormat.completeUpToSeconds.GetDescription() : DateFormat.completeUpToSecondsUS.GetDescription();
		return DateTime.TryParse(dateWithoutSpace, cultureInfo, DateTimeStyles.None, out testDate) || DateTime.TryParseExact(dateWithoutSpace, yyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, DateFormat.MMMMyyyy.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, DateFormat.MMMyyyy.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, DateFormat.MMyyyy.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, ddMMyyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, ddMMMyyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, ddMMMMyyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, ddMM, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, ddMMM, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, ddMMMM, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, ddMMyyyyHHmmssWithSlash, cultureInfo, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, DateFormat.universalSortable.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, DateFormat.sortable.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out testDate);
	//https://stackoverflow.com/questions/13457458/difference-between-universalsortabledatetimepattern-and-sortabledatetimepattern
	//https://stackoverflow.com/questions/3025361/c-sharp-datetime-to-yyyymmddhhmmss-format
	//// create date time 2008-03-09 16:05:07.123
	//            DateTime dt = new DateTime(2008, 3, 9, 16, 5, 7, 123);
	//            String.Format("{0:y yy yyy yyyy}",      dt);  // "8 08 008 2008"   year
	//            String.Format("{0:M MM MMM MMMM}",      dt);  // "3 03 Mar March"  month
	//            String.Format("{0:d dd ddd dddd}",      dt);  // "9 09 Sun Sunday" day
	//            String.Format("{0:h hh H HH}",          dt);  // "4 04 16 16"      hour 12/24
	//            String.Format("{0:m mm}",               dt);  // "5 05"            minute
	//            String.Format("{0:s ss}",               dt);  // "7 07"            second
	//            String.Format("{0:f ff fff ffff}",      dt);  // "1 12 123 1230"   sec.fraction
	//            String.Format("{0:F FF FFF FFFF}",      dt);  // "1 12 123 123"    without zeroes
	//            String.Format("{0:t tt}",               dt);  // "P PM"            A.M. or P.M.
	//            String.Format("{0:z zz zzz}",           dt);  // "-6 -06 -06:00"   time zone
	//// month/day numbers without/with leading zeroes
	//            String.Format("{0:M/d/yyyy}",           dt);  // "3/9/2008"
	//            String.Format("{0:MM/dd/yyyy}",         dt);  // "03/09/2008"
	//// day/month names
	//            String.Format("{0:ddd, MMM d, yyyy}",   dt);  // "Sun, Mar 9, 2008"
	//            String.Format("{0:dddd, MMMM d, yyyy}", dt);  // "Sunday, March 9, 2008"
	//// two/four digit year
	//            String.Format("{0:MM/dd/yy}",           dt);  // "03/09/08"
	//            String.Format("{0:MM/dd/yyyy}",         dt);  // "03/09/2008"
	}
//        public static IEnumerable<DocName> OrderDocsByDate(IEnumerable<DocName> docs)
//        {
//DONE put a field that merge Date and, if date is null, the Last part of interval
//return docs.OrderBy(x => x.HasDate ? x.GetDateTime() : x.GetLastPartOfIntervalTime() );
//            return docs.OrderBy(x => x.GetDateTimeOrLastPartOfIntervalForOrderDoc());
//        }
#endregion Dates
}

// ###################            ##################################      DocNameHelper      ##################################            ###################
// ###################            ##################################      InNameDate       ##################################            ###################
public class InNameDate : ValueObject
{
	public string DateText { get; }

	public DateTime DateTime { get; }

	public DateFormat Mask { get; }

	public CertaintyAboutElement CertaintyAbout { get; }

	private InNameDate(string dateText, DateTime dateTime, DateFormat mask, CertaintyAboutElement certaintyAbout)
	{
		DateText = dateText;
		DateTime = dateTime;
		Mask = mask;
		CertaintyAbout = certaintyAbout;
	}

	public static InNameDate NullDate => new(string.Empty, DateTime.MinValue, DateFormat.NoDate, CertaintyAboutElement.NonExisting);
	public static InNameDate ChangeMask(InNameDate date, DateFormat newMask)
	{
		return CreateInstance(date.DateText, date.DateTime, newMask);
	}

	public static InNameDate ChangeToYYYY(InNameDate date, DateFormat newMask)
	{
		if (date.DateText.Length != 4)
			throw new ArgumentException("Can only change mask of DDMM or MMDD to YYYY");
		return CreateInstance(date.DateText, date.DateTime, DateFormat.yyyy);
	}

	public static InNameDate ChangeToMMDD(InNameDate date, DateFormat newMask)
	{
		if (date.DateText.Length != 4)
			throw new ArgumentException("Can only change mask of DDMM or YYYY to MMDD");
		return CreateInstance(date.DateText, date.DateTime, DateFormat.MMdd);
	}

	public static InNameDate ChangeToDDMM(InNameDate date, DateFormat newMask)
	{
		if (date.DateText.Length != 4)
			throw new ArgumentException("Can only change mask of MMDD or YYYY to DDMM");
		return CreateInstance(date.DateText, date.DateTime, DateFormat.ddMM);
	}

	public static InNameDate CreateInstance(string dateText, DateTime dateTime, DateFormat mask, CertaintyAboutElement certaintyAbout = CertaintyAboutElement.AbsolutelyCertain)
	{
		return new InNameDate(dateText, dateTime, mask, certaintyAbout);
	}

	/// <summary>
	/// Create Instance Infering Mask and Format for Date Parsing
	/// </summary>
	public static InNameDate CreateInstance(string dateToParse, CultureInfo cultureInfo, int? maxPossibleYear, bool forceDDMMorMMDD = false, int minPossibleYear = 1990)
	{
		//TODO: decide with several if(TryParse) witch format should be; 
		maxPossibleYear ??= GetCurrentYearPlus(3);
		var maskForDateParsing = string.Empty;
		DateTime parsedDate = DateTime.MinValue;
		var isDDMM = cultureInfo.Name == "pt-BR";
		var dateFormatToTest = DateFormat.NoDate;
		var degreeOfCertainty = CertaintyAboutElement.AbsolutelyCertain;
		if (dateToParse.IsNumber())
		{
			if (dateToParse.Length == DateFormat.sortable.GetDescription().Length) //yyyyMMddHHmmss
			{
				dateFormatToTest = DateFormat.sortable;
			}
			else if (dateToParse.Length == 8) //ddmmyyyy or mmddyyyy
			{
				dateFormatToTest = isDDMM ? DateFormat.ddMMyyyy : DateFormat.MMddyyyy;
			}
			else if (dateToParse.Length == 6) //MMyyyy 
			{
				dateFormatToTest = DateFormat.MMyyyy;
			}
			else if (dateToParse.Length == 4) //ddMM OR MMdd OR yyyy
			{
				var yyyyToTestIfWithinAllowedRange = DateTime.MinValue;
				var maybeDDMMorMMDD = DateTime.TryParseExact(dateToParse, DateFormat.ddMM.GetDescription(), cultureInfo, DateTimeStyles.None, out _) || DateTime.TryParseExact(dateToParse, DateFormat.MMdd.GetDescription(), cultureInfo, DateTimeStyles.None, out _);
				var maybeYYYY = DateTime.TryParseExact(dateToParse, DateFormat.yyyy.GetDescription(), cultureInfo, DateTimeStyles.None, out yyyyToTestIfWithinAllowedRange);
				if ((maybeDDMMorMMDD && !maybeYYYY) || forceDDMMorMMDD)
					dateFormatToTest = isDDMM ? DateFormat.ddMM : DateFormat.MMdd;
				else if (!maybeDDMMorMMDD && maybeYYYY)
					dateFormatToTest = DateFormat.yyyy;
				else if (maybeDDMMorMMDD && maybeYYYY)
				{ //assume yyyy if possible ????
					degreeOfCertainty = CertaintyAboutElement.InformedGuess;
					if (yyyyToTestIfWithinAllowedRange >= new DateTime(minPossibleYear, 1, 1) && yyyyToTestIfWithinAllowedRange <= new DateTime(maxPossibleYear.Value, 1, 1))
						//https://stackoverflow.com/questions/3871299/asp-net-c-sharp-parse-int-as-datetime
						dateFormatToTest = DateFormat.yyyy;
					else
						dateFormatToTest = isDDMM ? DateFormat.ddMM : DateFormat.MMdd;
				}
				else if (maybeDDMMorMMDD && maybeYYYY)
				{
					dateFormatToTest = DateFormat.NoDate;
					degreeOfCertainty = CertaintyAboutElement.NonExisting;
				}
			}
			else if (dateToParse.Length == 2) //dd OR MM OR yy
			{
				throw new NotImplementedException("InferMaskAndFormatForDateParsing: dateToParse.Length == 2");
			}

			if (DateTime.TryParseExact(dateToParse, dateFormatToTest.GetDescription(), cultureInfo, DateTimeStyles.None, out parsedDate))
				return InNameDate.CreateInstance(dateToParse, parsedDate, dateFormatToTest, degreeOfCertainty);
		//return (dateFormatToTest.GetDescription(), dateFormatToTest, degreeOfCertainty);
		//[Description("dd/MM/yyyy HH:mm:ss")]
		//completeUpToSeconds,
		//[Description("MM/dd/yyyy HH:mm:ss")]
		//completeUpToSecondsUS,
		//[Description("yyyyMMddHHmmss")]
		//sortable,
		//[Description("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'")]
		//universalSortable				
		}
		else //if (!dateToParse.IsNumber()) MMM or MMMM or ddd or dd or tt
		{
		}

		return InNameDate.CreateInstance(dateToParse, parsedDate, dateFormatToTest, degreeOfCertainty);
	}

	internal static int GetCurrentYearPlus(int toAddCurrent) => DateTime.Now.Year + toAddCurrent;
#region Overrides of ValueObject
	protected override IEnumerable<object> GetEqualityComponents()
	{
		yield return DateText;
		yield return DateTime;
		yield return Mask;
		yield return CertaintyAbout;
	}
#endregion
}

// ###################            ##################################      InNameDate       ##################################            ###################
// ###################            ##################################      DateInSentence      ##################################            ###################
public static class DateInSentence
{
#region Public Constants
	public const string GrabDatesWithMonthsInLettersOrPureNumbersFromFile = @"(?<relationandinterval>(?<temporalrelation> em )?(?<=\W)(?<intervalordate>(?:\d{6,8}|\d{2,3}_{1,2})|(?:\b(0?[1-9]|[12][0-9]|3[01])*(?: de )?([JFMASONDjfmasond]([a-z0-9]+)([ç]{0,1})([a-z0-9]+)*)*(?: de )?(19|20)?[0-9]{2}\b)))";
	//https://regex101.com/r/ZuUZy3/9^^^^^^^^^^^^
	//https://stackoverflow.com/a/10033196/2752308 ^^^^^^ 
	public const string GrabDatesOrPureNumbersFromPartOfFile = @"(?<date>\d{6,8}|\d{2,3}_{1,2})";
	//https://regex101.com/r/DfGFk5/1   https://www.utctime.net/
	public const string GrabDatesUTC = @"(?<dateUTC>(?<year>-?(?:[1-9][0-9]*)?[0-9]{4})-(?<month>1[0-2]|0[1-9])-(?<day>3[01]|0[1-9]|[12][0-9])T(?<hour>2[0-3]|[01][0-9]):(?<minute>[0-5][0-9]):(?<second>[0-5][0-9])(\\.[0-9]+)?(?<zeroUTCoffse>Z)?|(?<year>(?:[1-9][0-9]*)?[0-9]{4})(?<month>1[0-2]|0[1-9])(?<day>3[01]|0[1-9]|[12][0-9])(?<hour>2[0-3]|[01][0-9])(?<minute>[0-5][0-9])(?<second>[0-5][0-9])(\\.[0-9]+)?(?<zeroUTCoffse>Z)?)";
	//Use it only to extract from PartOfName
	public const string GrabDateIntervalFromPartOfFile = @"(?<=\W)(?<interval>(?<starting>[ mçinícandouetr]+?)(?<datebegin>\d+)(?<link>[ eatéfimnldzou]+?)(?<=\W)(?<!\w-)(?<dateend>\d+))";
	//https://regex101.com/r/1UfbIM/1 ^^^^^^^^^^^^^^^^ 
	public const string GrabDateAndVersionDotAtEnd = @"(?<date>\d{6,8}|\d{2,3}_{1,2}) {1,2}(?<version>[vVersionão]+[\d@]+[\w@]*|[\d@]+[vVersionão]+[\w@]*).|(?<version>[vVersionão]+[\d@]+[\w@]*|[\d@]+[vVersionão]+[\w@]*) {1,2}(?<date>\d{6,8}|\d{2,3}_{1,2})\.|(?<date>\d{6,8}|\d{2,3}_{1,2})\.";
	//https://regex101.com/r/TpTA1n/2 ^^^^^^^^^^^^^^^^
	public const string WildCardForDate = "_";
#endregion Public Constants
	internal static Result<string> FilterAbsurdDates(Result<string> hasDate, CultureInfo cultureInfo, bool acceptWildCard = true, string errorMsg = "No date found", int numberOfYearsToConsiderAbsurd = 99)
	{
		if (hasDate.IsFailure)
			return hasDate;
		DateTime testDate = DateTime.MinValue;
		string dateWithoutSpace = string.Empty;
		if (hasDate.Value.DoesNotContainAnySpace())
		{
			dateWithoutSpace = hasDate.Value;
		}
		else
		{
			var dateCandidates = hasDate.Value.Split(' ');
			foreach (var element in dateCandidates)
			{
				if (element.Length > 3 && element.Length < 8)
				{
					dateWithoutSpace = element;
				}
			}
		}

		if (DocNameHelper.DateTryParseExact(dateWithoutSpace, out testDate, cultureInfo))
		//if (DateTime.TryParseExact(dateWithoutSpace, "yyyy", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out testDate) 	   )
		{
			if (testDate.IsThisDateNullOrDefault())
				return Result.Failure<string>(errorMsg);
			if (Math.Abs(testDate.YearsBetweenNowAndDate()) >= numberOfYearsToConsiderAbsurd)
				return Result.Failure<string>($"Cannot allow set date so many years ({testDate.YearsBetweenNowAndDate()}) far from today");
			return Result.Success(dateWithoutSpace);
		//Console.WriteLine("DateTryParseExact SUCCESS: " + testDate);
		}

		if (dateWithoutSpace.Contains(WildCardForDate))
		{
			return acceptWildCard ? Result.Success(dateWithoutSpace) : Result.Failure<string>($"Because WildCardForDate is not allowed, this is an invalid date resulting in {testDate.ToString()}");
		}

		//Console.WriteLine("DateTryParseExact FAILURE: " + testDate);
		return Result.Failure<string>($"Invalid date resulting in {testDate.ToString()}");
	}

	private static bool InTimeRangeAllowed(int numberOfYearsToConsiderAbsurd, DateTime testDate)
	{
		try
		{
			var tested = Math.Abs(testDate.YearsBetweenNowAndDate());
			return tested < numberOfYearsToConsiderAbsurd;
		}
		catch (Exception)
		{
			return false;
		}
	}

	public static Result<string> GetDate(string partToTest, CultureInfo cultureInfo, (int start, int end) forbiddenZoneCoordinates, bool acceptWildCard = true)
	//public static Result<string> GetDate(string partToTest, DocNamePart partName, InNameGUID partHasGUID)	
	{
		if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest))
			return Result.Failure<string>("No date stamp in this file name");
		var hasDate = ReturnResult(GrabDatesUTC, partToTest, "dateUTC", "No date stamp in this file name", cultureInfo, forbiddenZoneCoordinates);
		//"No date stamp in this file name", partName, partHasGUID);
		if (hasDate.IsFailure)
		{
			hasDate = ReturnResult(GrabDatesOrPureNumbersFromPartOfFile, partToTest, "date", "No date stamp in this file name", cultureInfo, forbiddenZoneCoordinates);
		//"No date stamp in this file name", partName, partHasGUID);				
		}

		if (hasDate.IsFailure)
		{
			hasDate = ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "intervalordate", "No date stamp in this file name", cultureInfo, forbiddenZoneCoordinates);
		//"No date stamp in this file name", partName, partHasGUID);				
		}

		if (hasDate.IsSuccess)
		{
			hasDate = FilterAbsurdDates(hasDate, cultureInfo, acceptWildCard, "No date stamp in this file name");
		}

		return hasDate;
	}

	public static Result<string> ReturnResult(string pattern, string part, string groupName, string errorMsg, CultureInfo cultureInfo, (int start, int end) forbiddenZoneCoordinates)
	{
		Result<string> result;
		var match = DocNameHelper.GetMatch(pattern, part, groupName, errorMsg, out result);
		if (!result.IsFailure && DocNameHelper.OutOfForbiddenZoneIfSamePart(groupName, match, forbiddenZoneCoordinates.start, forbiddenZoneCoordinates.end))
			return result;
		//https://stackoverflow.com/questions/38948394/datetime-tryparse-fails-at-yyyy-only
		if (DocNameHelper.DateTryParseExact(part, out var testDate, cultureInfo))
			result = !testDate.IsThisDateNullOrDefault() ? Result.Success(part) : Result.Failure<string>(errorMsg);
		return result;
	}
}

// ###################            ##################################      DateInSentence      ##################################            ###################
// ###################            ##################################      IntervalInSentence      ##################################            ###################
public static class IntervalInSentence
{
#region Public Constants
	public const string GrabDatesWithMonthsInLettersOrPureNumbersFromFile = @"(?<relationandinterval>(?<temporalrelation> em )?(?<=\W)(?<intervalordate>(?:\d{6,8}|\d{2,3}_{1,2})|(?:\b(0?[1-9]|[12][0-9]|3[01])*(?: de )?([JFMASONDjfmasond]([a-z0-9]+)([ç]{0,1})([a-z0-9]+)*)*(?: de )?(19|20)?[0-9]{2}\b)))";
	//https://regex101.com/r/ZuUZy3/9^^^^^^^^^^^^
	//https://stackoverflow.com/a/10033196/2752308 ^^^^^^ 
	//Use it only to extract from PartOfName
	public const string GrabDateIntervalFromPartOfFile = @"(?<=\W)(?<interval>(?<starting>[ mçinícandouetr]+?)(?<datebegin>\d+)(?<link>[ eatéfimnldzou]+?)(?<=\W)(?<!\w-)(?<dateend>\d+))";
	//https://regex101.com/r/1UfbIM/1 ^^^^^^^^^^^^^^^^ 
#endregion Public Constants
	public static Result<string> GetInterval(string partToTest, InNameGUID partHasGUID)
	//public static Result<string> GetInterval(string partToTest, DocNamePart partName, InNameGUID partHasGUID)	
	{
		var errorMsg = "No interval date stamp in this file name";
		if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest))
			return Result.Failure<string>(errorMsg);
		var hasInterval = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "interval", errorMsg);
		if (hasInterval.IsSuccess)
		{
			//var year 
			return IsIntervalValid(partToTest, errorMsg) ? hasInterval : Result.Failure<string>(errorMsg);
		}

		//"No interval date stamp in this file name", partName, partHasGUID);			
		if (hasInterval.IsFailure)
		{
			var match = DocNameHelper.GetMatch(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "relationandinterval", errorMsg, out var result);
			hasInterval = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "intervalordate", errorMsg);
			if (result.Equals(hasInterval))
				return Result.Failure<string>(errorMsg);
		}

		return hasInterval;
	}

	internal static bool IsIntervalValid(string partToTest, string errorMsg)
	{
		var(dateBegin, dateEnd) = GetIntervalDates(partToTest, errorMsg);
		//BUG very tough to predict all dd-mm possibilities and tell them from only yyyy
		// example de 1208 a 2009 is one in which EndDate maybe dd-mm or yyyy, but not the first
		// but how can I tell de 2107 a 2009 ??? comparing as dd-mm, interval is valid, but as yyyy, it is not valid
		// maybe assuming certain yyyy are valids, but I do not know for sure
		var validBeginInterval = DocNameHelper.DateTryParseExact(dateBegin.Value, out var beginInterval, CultureInfo.CurrentCulture);
		var validEndInterval = DocNameHelper.DateTryParseExact(dateEnd.Value, out var endInterval, CultureInfo.CurrentCulture);
		var isValid = beginInterval < endInterval;
		return isValid;
	}

	internal static (Result<string> dateBegin, Result<string> dateEnd) GetIntervalDates(string partToTest, string errorMsg)
	{
		var dateEnd = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "dateend", errorMsg);
		var dateBegin = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "datebegin", errorMsg);
		return (dateBegin, dateEnd);
	}
}

// ###################            ##################################      IntervalInSentence      ##################################            ###################
// ###################            ##################################      InNameGUID       ##################################            ###################
public class InNameGUID : ValueObject
{
	private const string Grab_GUID_treated = @"(?<GUID>[0-9a-f]{8}<>[0-9a-f]{4}<>[0-9a-f]{4}<>[0-9a-f]{4}<>[0-9a-f]{12})";
	private InNameGUID(int start, int end, DocNamePart part, string guid)
	{
		Start = start;
		End = end;
		Part = part;
		GUID = guid;
	}

	public static InNameGUID CreateInstance(int start, int end, DocNamePart part, string guid)
	{
		return new InNameGUID(start, end, part, guid);
	}

	public bool NoGUID => string.IsNullOrEmpty(GUID);
	public static InNameGUID NullGUID() => new(-1, -1, DocNamePart.NoPart, string.Empty);
	public static InNameGUID GetGUID(string part, DocNamePart namePart)
	{
		var rgx = new Regex(Grab_GUID_treated);
		var match = rgx.Match(part);
		//Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
		//BUG end is not end; end is Length...and length of treated GUID, with <> instead of -
		var result = match.Success ? CreateInstance(match.Groups["GUID"].Index, match.Groups["GUID"].Length - 1, namePart, match.Groups["GUID"].Value) : NullGUID();
		//      1  	2			
		//  0   1	2	3	4	5
		//? Result.Success(match.Groups["GUID"].Value.Trim())
		//: Result.Failure<string>("No GUID in this part");
		return result;
	}

	public int Start { get; private set; }

	public int End { get; private set; }

	public DocNamePart Part { get; private set; }

	public string GUID { get; private set; }

	protected override IEnumerable<object> GetEqualityComponents()
	{
		yield return Part;
		yield return End;
		yield return Start;
		yield return GUID;
		yield return NoGUID;
	}
}

// ###################            ##################################      InNameGUID       ##################################            ###################
// ###################            ##################################      DateTimeExtensions      ##################################            ###################
public static partial class DateTimeExtensions
{
	public static int YearsBetweenNowAndDate(this DateTime @this) => Math.Abs(DateTime.Now.HowOld(@this, out _, out _));
	public static int YearsBetweenDates(this DateTime @this, DateTime that) => Math.Abs(that.HowOld(@this, out _, out _));
	public static int HowOld(this DateTime initialDay, DateTime dayToCalculate, out int days, out int months)
	{
		//https://stackoverflow.com/a/3055445/2752308
		//LukeH: essentially right
		months = dayToCalculate.Month - initialDay.Month;
		int years = dayToCalculate.Year - initialDay.Year;
		if (dayToCalculate.Day < initialDay.Day)
		{
			months--;
		}

		if (months < 0)
		{
			years--;
			months += 12;
		}

		days = (dayToCalculate - initialDay.AddMonths((years * 12) + months)).Days;
		//Console.WriteLine(
		//	$@"{years} year{((years == 1) ? "" : "s")}, {months} month{((months == 1) ? "" : "s")} and {days} day{((days == 1) ? "" : "s")}");
		return years;
	}

	public static string HowYearsOldToday(this DateTime birthday, bool allowNegativeAge = false)
	{
		var howManyYears = birthday.HowOld(DateTime.Now, out var howManyDays, out var howManyMonths);
		if (allowNegativeAge || howManyYears >= 0)
			return $"{howManyYears} ano{((howManyYears == 1) ? "" : "s")}";
		return "Cannot calculate age";
	}

	public static string HowYearsOldAtDate(this DateTime birthday, DateTime atDate, bool allowNegativeAge = false)
	{
		var howManyYears = birthday.HowOld(atDate, out var howManyDays, out var howManyMonths);
		if (allowNegativeAge || howManyYears >= 0)
			return $"{howManyYears} ano{((howManyYears == 1) ? "" : "s")}";
		return "Cannot calculate age";
	}

	public static string HowYearsMonthsOldToday(this DateTime birthday, bool allowNegativeAge = false)
	{
		var howManyYears = birthday.HowOld(DateTime.Now, out var howManyDays, out var howManyMonths);
		if (allowNegativeAge || howManyYears >= 0)
			return $"{howManyYears} ano{((howManyYears == 1) ? "" : "s")}" + $", {howManyMonths} {((howManyMonths == 1) ? "mês" : "meses")} ";
		return "Cannot calculate age";
	}

	public static string HowYearsMonthsOldAtDate(this DateTime birthday, DateTime atDate, bool allowNegativeAge = false)
	{
		var howManyYears = birthday.HowOld(atDate, out var howManyDays, out var howManyMonths);
		if (allowNegativeAge || howManyYears >= 0)
			return $"{howManyYears} ano{((howManyYears == 1) ? "" : "s")}" + $", {howManyMonths} {((howManyMonths == 1) ? "mês" : "meses")} ";
		return "Cannot calculate age";
	}

	public static string HowYearsMonthsDaysOldToday(this DateTime birthday, bool allowNegativeAge = false)
	{
		var howManyYears = birthday.HowOld(DateTime.Now, out var howManyDays, out var howManyMonths);
		if (allowNegativeAge || howManyYears >= 0)
			return $"{howManyYears} ano{((howManyYears == 1) ? "" : "s")}" + $", {howManyMonths} {((howManyMonths == 1) ? "mês" : "meses")} " + $"e {howManyDays} dia{((howManyDays == 1) ? "" : "s")}";
		return "Cannot calculate age";
	}

	public static string HowYearsMonthsDaysOldAtDatey(this DateTime birthday, DateTime atDate, bool allowNegativeAge = false)
	{
		var howManyYears = birthday.HowOld(atDate, out var howManyDays, out var howManyMonths);
		if (allowNegativeAge || howManyYears >= 0)
			return $"{howManyYears} ano{((howManyYears == 1) ? "" : "s")}" + $", {howManyMonths} {((howManyMonths == 1) ? "mês" : "meses")} " + $"e {howManyDays} dia{((howManyDays == 1) ? "" : "s")}";
		return "Cannot calculate age";
	}

	public static DateTime MinimumWinFormDateTime(this DateTime @this) => Convert.ToDateTime("1/1/1753 00:00:00"); // ApplicationServices.GetMinDateTime();
	public static DateTime NullOutlookDateTime(this DateTime @this) => Convert.ToDateTime("1/1/4501 00:00:00"); // ApplicationServices.OutlookNullDate;
	public static DateTime OutlookDefaultDateForInvalidEntry(this DateTime @this) => Convert.ToDateTime("30/12/1899 00:00:00"); // ApplicationServices.OutlookDefaultDateForInvalid;
	public static DateTime OutlookEarliestDateThatDoesNotProvokeError(this DateTime @this) => Convert.ToDateTime("01/04/1601 00:00:00"); // ApplicationServices.OutlookEarliestDateThatDoesntProvokeError;
	public static DateTime ThisDateOrAppropriateMinimalDateTime(this DateTime @this) => (DateTime)(@this < @this.MinimumWinFormDateTime() || @this == NullOutlookDateTime(@this) ? @this.MinimumWinFormDateTime() : @this);
	public static bool IsThisDateNullOrDefault(this DateTime @this) => @this == @this.MinimumWinFormDateTime() || @this == NullOutlookDateTime(@this) || @this == DateTime.MaxValue || @this == DateTime.MinValue || @this == @this.OutlookDefaultDateForInvalidEntry() || @this < @this.OutlookEarliestDateThatDoesNotProvokeError();
	public static DateTime ThisDateCandidateOrDateTimeMinimal(this string stringToBeParsed)
	{
		DateTime @this = default;
		if (stringToBeParsed == null || !DateTime.TryParse(stringToBeParsed, out @this))
			return DateTime.MinValue;
		return @this;
	}

	public static DateTime ThisDateCandidateOrAppropriateMinimalDateTime(this string stringToBeParsed)
	{
		DateTime @this = default;
		if (stringToBeParsed == null || !DateTime.TryParse(stringToBeParsed, out @this))
			return @this.MinimumWinFormDateTime();
		return (DateTime)(@this < @this.MinimumWinFormDateTime() || @this == NullOutlookDateTime(@this) ? @this.MinimumWinFormDateTime() : @this);
	}

	/// <summary>
	/// Return the older or the ancient of two dates
	/// </summary>
	/// <param name = "d1"></param>
	/// <param name = "d2"></param>
	/// <returns></returns>
	public static DateTime ReturnAnteriorBetweenDates(this DateTime d1, DateTime d2) => d1 < d2 ? d1 : d2;
	/// <summary>
	/// Return the most near Now() date
	/// </summary>
	/// <param name = "d1"></param>
	/// <param name = "d2"></param>
	/// <returns></returns>
	public static DateTime ReturnPosteriorBetweenDates(this DateTime d1, DateTime d2) => d1 < d2 ? d1 : d2;
	public static DateTime AllowPastOrNowTimeButNotFuture(this DateTime? ToTest, DateTime? ToCompare = null)
	{
		if (ToCompare == null)
		{
			ToCompare = DateTime.Now;
		}

		return ToTest switch
		{
			var value when value == null => DateTime.Now,
			var value when value < ToCompare => (DateTime)ToTest,
			var value when value > ToCompare => throw new ArgumentOutOfRangeException("Date cannot be in the future..."),
			_ => default,
		};
	}

	public static DateTime AllowOnlyFuture(this DateTime? ToTest, double numberOfHoursToAdd = 1, DateTime? ToCompare = null)
	{
		if (ToCompare == null)
		{
			ToCompare = DateTime.Now;
		}

		return ToTest switch
		{
			var value when value == null => DateTime.Now.AddHours(numberOfHoursToAdd),
			var value when value > ToCompare => (DateTime)ToTest,
			var value when value < ToCompare => throw new ArgumentOutOfRangeException("Date cannot be in the past or even now..."),
			_ => default,
		};
	//var timeOnlyInFuture = DateTime.MaxValue;
	//switch (ToTest)
	//{
	//    case var value when value == null:
	//        timeOnlyInFuture = DateTime.Now.AddHours(numberOfHoursToAdd);
	//        break;
	//    case var value when value > ToCompare:
	//        timeOnlyInFuture = (DateTime)ToTest;
	//        break;
	//    case var value when value < ToCompare:
	//        throw new ArgumentOutOfRangeException("Date cannot be in the past or even now...");
	//    default:
	//        break;                    
	//}
	//return timeOnlyInFuture;
	}
}

// ###################            ##################################      DateTimeExtensions      ##################################            ###################
// ###################            ##################################      StringTextExtensions      ##################################            ###################
public static class StringTextExtensions
{
	private const char OneBlankSpace = ' ';
	public static string RemoveUnnecessarySpaces(this string textToTrim)
	{
		return Regex.Replace(textToTrim, @"\s+", " ").Trim();
	}

	public static string RemoveAllSpaces(this string textToTrim)
	{
		return textToTrim.Replace(" ", string.Empty);
	}

	public static string RemoveAllPunctuation(this string textToTrim)
	{
		//https://stackoverflow.com/questions/421616/how-can-i-strip-punctuation-from-a-string
		return new string (textToTrim.Where(c => !char.IsPunctuation(c)).Where(c => !char.IsSymbol(c)).ToArray());
	//return Regex.Replace(textToTrim, @"[a-zA-ZçÇ à-úÀ-Ú]+", string.Empty).Trim();
	//return Regex.Replace(textToTrim, @"\p{P}+", string.Empty).Trim();
	//^^^^^cuidado! @"\p{P}+" ou "\\p{P}+": nunca @"\\p{P}+"
	}

	public static string GetRidOfNonLetterCharsInKeyOrPairElements(this string rawString) => rawString.RemoveAllPunctuation().RemoveAllSpaces().RemoveBrackets();
	public static string GetNumberOfCharsJustBeforeSubstring(this string text, string beforeThis, int numberOfChars = 1)
	{
		try
		{
			var txtBefore = text.GetUntilOrEmpty(beforeThis);
			return text.GetUntilOrEmpty(beforeThis).Substring(txtBefore.Length - numberOfChars);
		}
		catch (Exception ex)
		{
			Console.WriteLine(ex.Message);
			return string.Empty;
		}
	}

	public static string GetUntilOrEmpty(this string text, string stopAt = "-")
	{
		if (!string.IsNullOrWhiteSpace(text))
		{
			int charLocation = text.IndexOf(stopAt, StringComparison.Ordinal);
			if (charLocation > 0)
			{
				return text.Substring(0, charLocation);
			}
		}

		return string.Empty;
	}

	public static string GetAfterOrEmpty(this string text, string stopAt = "-")
	{
		if (!string.IsNullOrWhiteSpace(text))
		{
			int charLocation = text.IndexOf(stopAt, StringComparison.Ordinal);
			if (charLocation > 0)
			{
				return text.Substring(charLocation + stopAt.Length, text.Length - charLocation - stopAt.Length);
			}
		}

		return string.Empty;
	}

	public static string GetMiddleString(this string inputString, char separator = OneBlankSpace)
	{
		//this is assuming that your tokens only happens one time in the string
		//https://stackoverflow.com/questions/2449561/retrieve-string-from-the-middle-of-a-string
		var input = inputString.Split(separator);
		var firstToken = input[0];
		var lastToken = input[input.Length - 1];
		var pos1 = inputString.IndexOf(firstToken) + firstToken.Length;
		var pos2 = inputString.IndexOf(lastToken);
		var result = inputString.Substring(pos1, pos2 - pos1).Trim() ?? string.Empty;
		return result;
	}

	public static (string textBefore, string textAfter) GetTextBeforeAndAfterSubstring(this string textToExtract, string stringToSearchFor, int desiredLengthToCut, int indexToSearchedString)
	{
		//var indexToSearchedString = textToExtract.IndexOf(stringToSearchFor, StringComparison.Ordinal);
		var textBefore = textToExtract.Substring(indexToSearchedString - desiredLengthToCut < 0 ? 0 : indexToSearchedString - desiredLengthToCut, indexToSearchedString - desiredLengthToCut > 0 ? desiredLengthToCut : indexToSearchedString);
		var textAfter = textToExtract.Substring(indexToSearchedString + stringToSearchFor.Length, DecideHowMuchItCanCutAfter(textToExtract.Length, indexToSearchedString + stringToSearchFor.Length, desiredLengthToCut));
		return (textBefore, textAfter);
		static int DecideHowMuchItCanCutAfter(int totalLength, int beginCut, int lengthToCut)
		{
			if (beginCut + lengthToCut < totalLength)
				return lengthToCut;
			if (beginCut + lengthToCut >= totalLength)
				return totalLength - beginCut;
			return 0;
		}
	}

	public static string RemoveDiacritics(this string s)
	{
		string normalizedString = s.Normalize(NormalizationForm.FormD);
		StringBuilder stringBuilder = new StringBuilder();
		for (int i = 0; i < normalizedString.Length; i++)
		{
			char c = normalizedString[i];
			if (CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
				stringBuilder.Append(c);
		}

		return stringBuilder.ToString();
	}

	public static string RemoveBrackets(this string s)
	{
		return s.Replace("[", string.Empty).Replace("]", string.Empty);
	}

	public static string SurroundWithDoubleQuotes(this string text)
	{
		return SurroundWith(text, "\"");
	}

	public static string SurroundWith(this string text, string ends)
	{
		return ends + text + ends;
	}

	public static string EscapeSingleQuote(this string text)
	{
		return text.Replace("'", @"\'");
	}

	public static string AddSingleQuoteAsEscapeCharacter(this string text)
	{
		//https://docs.microsoft.com/pt-br/dotnet/api/microsoft.office.interop.outlook._items.find?view=outlook-pia
		return text.Replace("'", @"''");
	}

	public static string EnsureOneSingleSpaceAtBegin(this string text)
	{
		return OneBlankSpace + text.TrimStart();
	}

	public static string CapitalizeFirstLetter(this string value)
	{
		//In Case if the entire string is in UpperCase then convert it into lower
		value = value.ToLower();
		char[] array = value.ToCharArray();
		// Handle the first letter in the string.
		if (array.Length >= 1)
		{
			if (char.IsLower(array[0]))
			{
				array[0] = char.ToUpper(array[0]);
			}
		}

		// Scan through the letters, checking for spaces.
		// ... Uppercase the lowercase letters following spaces.
		for (int i = 1; i < array.Length; i++)
		{
			if (array[i - 1] == ' ')
			{
				if (char.IsLower(array[i]))
				{
					array[i] = char.ToUpper(array[i]);
				}
			}
		}

		return new string (array);
	}

	/// <summary>
	/// Split a string on each occurrence of a capital (assumed to be a word)
	/// e.g. MyBigToe returns "My Big Toe"
	/// </summary>
	public static string SplitCapitalizedWords(this string source)
	{
		if (String.IsNullOrEmpty(source))
			return String.Empty;
		var newText = new StringBuilder(source.Length * 2);
		newText.Append(source[0]);
		for (int i = 1; i < source.Length; i++)
		{
			if (char.IsUpper(source[i]))
				newText.Append(' ');
			newText.Append(source[i]);
		}

		return newText.ToString();
	}

	/// <summary>
	/// https://stackoverflow.com/questions/6865419/indexof-for-multiple-results
	/// https://stackoverflow.com/questions/15993357/how-to-get-all-indexof-instances-of-string-in-another-string-c-sharp
	/// </summary>
	/// <param name = "str"></param>
	/// <param name = "searchString"></param>
	/// <returns></returns>
	public static IEnumerable<int> AllIndexesOf(this string str, string searchString)
	{
		int minIndex = str.IndexOf(searchString, StringComparison.Ordinal);
		while (minIndex != -1)
		{
			yield return minIndex;
			minIndex = str.IndexOf(searchString, minIndex + searchString.Length, StringComparison.Ordinal);
		}
	}

	/// <summary>
	///     A string extension method that query if '@this' contains any values.
	/// </summary>
	/// <param name = "this">The @this to act on.</param>
	/// <param name = "values">A variable-length parameters list containing values.</param>
	/// <returns>true if it contains any values, otherwise false.</returns>
	public static bool ContainsAny(this string @this, params string[] values)
	{
		foreach (string value in values)
		{
			if (@this.IndexOf(value) != -1)
			{
				return true;
			}
		}

		return false;
	}

	/// <summary>
	///     A string extension method that query if '@this' contains any values.
	/// </summary>
	/// <param name = "this">The @this to act on.</param>
	/// <param name = "comparisonType">Type of the comparison.</param>
	/// <param name = "values">A variable-length parameters list containing values.</param>
	/// <returns>true if it contains any values, otherwise false.</returns>
	public static bool ContainsAny(this string @this, StringComparison comparisonType, params string[] values)
	{
		foreach (string value in values)
		{
			if (@this.IndexOf(value, comparisonType) != -1)
			{
				return true;
			}
		}

		return false;
	}

	public static bool DoesNotContainAnySpace(this string @this) => !@this.Any(char.IsWhiteSpace);
	//https://stackoverflow.com/questions/3293295/string-contains-only-a-given-set-of-characters
	public static bool ContainsOnly(this string @this, string allowedChars) => @this.All(allowedChars.Contains);
	public static bool StringHasOnlyNumbers(this string @this) => @this.ReturnOnlyNumbers().Length == @this.Length;
	//https://stackoverflow.com/questions/4734116/find-and-extract-a-number-from-a-string	
	public static List<string> ReturnOnlyInvalidChars(this string @this, string allowedChars) => (
		from c in @this
		where !allowedChars.Contains(c.ToString())select c.ToString()).ToList();
	//https://stackoverflow.com/questions/4734116/find-and-extract-a-number-from-a-string
	public static string ReturnOnlyNumbers(this string @this) => new(@this.Where(char.IsDigit).ToArray());
	public static int? ReturnOnlyNumbersAsInt(this string @this)
	{
		int.TryParse(@this.ReturnOnlyNumbers(), out var result);
		return result;
	}

	public static string ReturnOnlyNonNumericCharacters(this string @this) => Regex.Replace(@this, @"[\d-]", string.Empty);
	/// <summary>
	/// https://stackoverflow.com/a/10042595/2752308
	/// </summary>
	/// <param name = "this"></param>
	/// <returns></returns>
	public static int[] ReturnOnlyNumbersToArray(this string @this) => Regex.Matches(@this, "(-?[0-9]+)").OfType<Match>().Select(m => int.Parse(m.Value)).ToArray();
	public static int GetSingleDigitAtPositionInFilteredStrOnlyNumbers(this string @this, int position1Based)
	{
		if (position1Based < 1 || position1Based > @this.Length - 1)
		{
			throw new ArgumentOutOfRangeException(nameof(position1Based), $"{nameof(position1Based)} cannot be outer of string limits");
		}

		return int.Parse(@this.ReturnOnlyNumbers()[position1Based - 1].ToString());
	}

	public static string FormatPhoneNumber(this long number, string mask) => number.ToString(mask);
	//https://pt.stackoverflow.com/questions/283609/formatar-uma-string-para-formato-de-telefone
	public static string FormatPhoneNumber(this string number)
	{
		var mask = number.ReturnOnlyNumbers().Length switch
		{
			15 => @"0 000 (00) 00000-0000",
			13 => @"+00 (00) 00000-0000",
			11 => @"(00) 00000-0000",
			10 => @"(00) 0000-0000",
			_ => throw new ArgumentOutOfRangeException(nameof(FormatPhoneNumber), "FormatPhoneNumber only accepts certain ranges of phone numbers"),
		};
		//var mask = string.Empty;
		//switch (number.ReturnOnlyNumbers().Length)
		//{
		//    case 15:
		//        mask = @"0 000 (00) 00000-0000";
		//        break;
		//    case 13:
		//        mask = @"+00 (00) 00000-0000";
		//        break;
		//    case 11:
		//        mask = @"(00) 00000-0000";
		//        break;
		//    case 10:
		//        mask = @"(00) 0000-0000";
		//        break;
		//    default:
		//        throw new ArgumentOutOfRangeException(nameof(FormatPhoneNumber), "FormatPhoneNumber only accepts certain ranges of phone numbers");        
		//}
		return long.Parse(number.ReturnOnlyNumbers()).FormatPhoneNumber(mask);
	}

	public static bool IsDate(this string @this, out DateTime date) => DateTime.TryParse(@this, out date);
	public static bool IsDate(this string @this) => DateTime.TryParse(@this, out var date);
	public static bool IsNumber(this string @this) => int.TryParse(@this, out var number);
	public static string ReturnParentFolder(this string pathSource)
	{
		//https://stackoverflow.com/a/30902714/2752308
		return Path.GetFullPath(Path.Combine(pathSource, @"..\"));
	}

	/// <summary>
	/// Extension to use with Root path, adding distal path as argument
	/// </summary>
	/// <param name = "pathWithRoot"></param>
	/// <param name = "pathDistal"></param>
	/// <returns></returns>
	public static string CombinePaths(this string pathWithRoot, string pathDistal)
	{
		var networkFolder = !pathWithRoot.Contains(":");
		var pathOne = pathWithRoot.Split(@"\".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
		var pathTwo = pathDistal.Split(@"\".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
		var pathFinal = pathOne.Concat(pathTwo);
		var preFinalPath = Path.Combine(pathFinal.ToArray());
		if (networkFolder)
			return "\\\\" + preFinalPath;
		return preFinalPath.Contains(":\\") ? preFinalPath : preFinalPath.Replace(":", ":\\");
	}
}

// ###################            ##################################      StringTextExtensions      ##################################            ###################
// ###################            ##################################      ObjectTextExtensions      ##################################            ###################
public static class ObjectTextExtensions
{
	public static T ObjToEnum<T>(this object o, int unknown = 0)
	{
		try
		{
			if (o != null)
			{
				T enumVal = (T)Enum.Parse(typeof(T), o.ToString());
				return enumVal;
			}
		}
		catch (Exception)
		{
			return (T)Enum.ToObject(typeof(T), unknown);
		}

		return (T)Enum.ToObject(typeof(T), unknown); //0 é o valor que estou dando para todos os enum Desconhecidos
	}

	//        public static T LookupItemExToEnum<T>(this object o, int unknown = 0)
	//        {
	//        }
	/// <summary>
	/// Returns true if Enum value exists
	/// </summary>
	/// <param name = "value"></param>
	/// <returns></returns>
	public static bool IsDefined(this System.Enum value)
	{
		return Enum.IsDefined(value.GetType(), value);
	}

	//       public static LookupItemEx EnumTo<TValue>(this TValue value) where TValue : System.Enum =>
	//            LookupItemEx.Create(value.EnumToInt(), value.ToString(), value.GetDescription());
	public static int EnumToInt<TValue>(this TValue value)
		where TValue : System.Enum => (int)(object)value;
	public static TValue IntToEnum<TValue>(this int value)
		where TValue : System.Enum => (TValue)(object)value;
	//=> (TValue)Convert.ChangeType(value, typeof(TValue));
	//(T)Convert.ChangeType(Email.FromString("m", WhichContactType.PERSONAL), typeof(T)), 
	public static T GetEnumValue<T>(this string value)
		where T : struct
	{
		Type t = typeof(T);
		if (!t.IsEnum)
			throw new Exception("T must be an enum");
		else
		{
			if (Enum.IsDefined(t, value))
				return (T)Enum.Parse(t, value);
			else
				return default(T);
		}
	}

	//https://stackoverflow.com/questions/483794/convert-enum-to-string/17034624#17034624
	public static T GetValueFromDescription<T>(this string description, bool throwException = true)
		where T : Enum
	{
		//https://stackoverflow.com/questions/4367723/get-enum-from-description-attribute
		foreach (var field in typeof(T).GetFields())
		{
			if (Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute))is DescriptionAttribute attribute)
			{
				if (attribute.Description == description)
					return (T)field.GetValue(null);
			}
			else
			{
				if (field.Name == description)
					return (T)field.GetValue(null);
			}
		}

		if (throwException)
		{
			throw new ArgumentException("Not found.", nameof(description));
		}

		return default(T);
	}

	public static string GetDescription(this Enum value)
	{
		//https://stackoverflow.com/questions/4367723/get-enum-from-description-attribute
		//https://stackoverflow.com/a/479417/2752308
		FieldInfo field = value.GetType().GetField(value.ToString());
		DescriptionAttribute attribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;
		return attribute == null ? value.ToString() : attribute.Description;
	}

	public static string GetDescription(this object e, Type enumType)
	{
		//var fields = Enum.GetValues(enumType).Cast<object>();
		//var fieldsName =
		//from o in fields
		//    where o.ToString() == e.ToString()
		//        select o.ToString();
		//var fieldValue = enumType.GetField(fieldsName.FirstOrDefault()).ToString();
		var fieldValue = enumType.GetField(Enum.GetValues(enumType).Cast<object>().Where(o => o.ToString() == e.ToString()).Select(o => o.ToString()).FirstOrDefault()).ToString();
		FieldInfo field = enumType.GetField(fieldValue.Contains(" ") ? fieldValue.Split().Last() : fieldValue);
		DescriptionAttribute attribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;
		return attribute == null ? e.ToString() : attribute.Description;
	}

	/// <summary>
	/// De um valor apenas, pega o Dictionary; meio estranho
	/// </summary>
	/// <typeparam name = "TValue"></typeparam>
	/// <param name = "value"></param>
	/// <returns></returns>
	public static Dictionary<int, TValue> EnumToDictionary<TValue>(this TValue value)
		where TValue : System.Enum
	{
		Type enumType = typeof(TValue);
		var allEnumValues = enumType.GetEnumValues().Cast<TValue>();
		var enumDL = new Dictionary<int, TValue>();
		foreach (TValue val in allEnumValues.ToList())
		{
			enumDL.Add(val.EnumToInt(), val);
		}

		return enumDL;
	}

	public static Dictionary<int, Enum> EnumToDictionaryNotGeneric(this Enum @enum)
	//where T : struct, Enum
	{
		Type enumType = @enum.GetType(); //typeof(@enum);
		var allEnumValues = Enum.GetValues(@enum.GetType()).Cast<Enum>();
		var enumDL = new Dictionary<int, Enum>();
		foreach (var val in allEnumValues.ToList())
		{
			enumDL.Add(val.EnumToInt(), val);
		}

		return enumDL;
	}

	/// <summary>
	/// Pega o Dictionary; a assinatura é muito estranha
	/// </summary>
	/// <typeparam name = "T"></typeparam>
	/// <returns></returns>
	public static Dictionary<int, T> EnumToDictionary<T>(this Type enumType)
		where T : Enum
	{
		//Type enumType = typeof(T);
		//var allEnumDescriptions = enumType.GetEnumNames();
		//non-generic equivalent:          ^^^^^^^^^^ Enum.GetValues<WhichGender>()
		var allEnumValues = enumType.GetEnumValues().Cast<T>();
		var converter = new EnumConverter(enumType);
		// Can't use generic type constraints on value types,
		// so have to do check like this
		//if (enumType.BaseType != typeof(Enum))
		//    throw new ArgumentException("T must be of type System.Enum");
		var enumDL = new Dictionary<int, T>();
		foreach (T val in allEnumValues.ToList())
		{
			enumDL.Add(val.EnumToInt(), val);
		}

		return enumDL;
	}

	//https://stackoverflow.com/a/972323/2752308
	public static IReadOnlyList<T> GetValues<T>()
	{
		return (T[])Enum.GetValues(typeof(T));
	}
/// <summary>
/// https://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum
/// Only after 7.3
/// see too: https://stackoverflow.com/questions/5005931/listing-values-within-enums-using-reflection-in-c-sharp
/// Use this instead of EnumPatient.GetAllValues()
/// </summary>
/// <returns></returns>
 //        public static Dictionary<int, string> GetAllValuesByEnumType(this EnumPatient.Enums whichType)
//        {
//        }
}// ###################            ##################################      ObjectTextExtensions      ##################################            ###################

​x
 
using System;
using System.IO;
using System.Text;
using System.Collections.Generic;
using System.Linq;
using System.Globalization;
using System.Collections;
using CSharpFunctionalExtensions;
using System.Text.RegularExpressions;
using System.ComponentModel;
using System.Reflection;
​
public class Program
{
    public static void Main()
    {
        var culture = SetCulture();
        Console.WriteLine($"________________________________________________________________________________________________________");
        Console.WriteLine();
        //string[] datesToTest = { /**/
        //  "03132002",
        //  "23132002",
        //  "03121980",
        //  "03112002",
        //  "1800",
        //  "2239",
        //  "2007",
        //  "2021",
        //  "052016",
        //  "122019",
        //  "23122022",
        //  "2017",
        //  "10122022",
        //  "20__",
        //  "23122019",
        //  "29122022",
        //  "21122022",
        //  "20122012",
        //  "20122011",
        //  "20/12/2011",
        //  "20-12-2011",
        //  "12/2019",
        //  "12-2019",
        //  "December2001",
        //  "Dezembro2019",
        //  "Dezembro/2001",
        //  "04 de Dezembro de 2001",
        //  "06Dezembro2001",
        //  "06Dez2001",
        //  "06Dec2001",
        //  "20230605161406"
        //};        
        string[] datesToTest = { /**/
            "03132002",
            "23132002",
            "03121980",
            "03112002",
            "1800",
            "2239",
            "2007",
            "2021",
            "052016",
            "122019",
            "23122022",
            "2017",
            "10122022",
            "20__",
            "23122019",
            "29122022",
            "21122022",
            "20122012",
            "20122011",
            "20/12/2011",
            "20-12-2011",
            "12/2019",
            "12-2019",
            "December2001",
            "Dezembro2019",
            "Dezembro/2001",
            "04 de Dezembro de 2001",
            "06Dezembro2001",
            "06Dez2001",
            "06Dec2001",
            "20230605161406"
        };
        TestDates(datesToTest, culture);
        Console.WriteLine();
        TestDates(datesToTest, new CultureInfo("en-US"));
        Console.WriteLine($"________________________________________________________________________________________________________");
        Console.WriteLine();
        Console.WriteLine($"-----------------------Testing Intervals-------------------------------------------------");
        //string[] intervalsToTest = {
        //  (" entre 2022 e 2021"), 
        //  (" entre 2013 e 2021"), 
        //  ("entre 2013 e 2021"), 
        //  (" entre 19092007 e 12092022"), 
        //  (" entre 09192007 e 09122022"), 
        //  (" entre 19092022 e 12092022"), 
        //  (" entre 09192022 e 09122022"), 
        //  (" de 092017 até 102018"), 
        //  ("de 092019 até 102018"), 
        //  (" de 2017 a 2018"), 
        //  (" de 1017 a 2318")
        //  };
        //      
        (string date, bool forceBeginDatePreviousYearIfReasonable)[] intervalsToTest = {
            (" entre 2022 e 2021", false), 
            (" entre 2013 e 2021", false), 
            ("entre 2013 e 2021", false), 
            (" entre 19092007 e 12092022", false), 
            (" entre 09192007 e 09122022", false), 
            (" entre 19092022 e 12092022", false), 
            (" entre 09192022 e 09122022", false), 
            (" de 092017 até 102018", false), 
            ("de 092019 até 102018", false), 
            (" de 2017 a 2018", false), 
            (" de 1017 a 2318", false),
            ("de 2109 até 21102022", false), // err: 2109 interpreted as yyyy
            ("de 2111 até 21102022", false),
            ("de 2111 até 21102022", true),
            ("de 21 até 23102022", false)
        };
        TestInterval(intervalsToTest, culture);
        Console.WriteLine();
        TestInterval(intervalsToTest, new CultureInfo("en-US"));
        Console.WriteLine();
        Console.WriteLine($"-----------------------Testing Dates-------------------------------------------------");
        var pattern = @"\b(?<datewithoutday>(?<month>0[1-9]|1[012])(?<year>19|20[0-9]{2}))|(?<datewithday>(?<day>0[1-9]|[12][0-9]|3[01])(?<month>0[1-9]|1[012])(?<year>19[0-9]{2}|20[0-9]{2}|21[0-9]{2}))|(?<dateonlyyear>(?<year>19[0-9]{2}|20[0-9]{2}|21[0-9]{2}))\b";
        // https://stackoverflow.com/questions/20490884/how-to-create-an-array-of-tuples
        //(string date, string replacePattern, string mask, bool acceptWildCard)[] datesWithMaskToTest = {
        //      ("20__", string.Empty, "yyyy", true),
        //      ("20__", string.Empty, "yyyy", false),
        //      ("2006", string.Empty, "yyyy", false),
        //      ("2138", string.Empty, "yyyy", false),
        //      ("9238", string.Empty, "yyyy", false),
        //      ("092006", @"$2/$3", "MM/yyyy", false),
        //      ("122006", @"$2/$3", "MM/yyyy", false),
        //      ("129238", @"$2/$3", "MM/yyyy", false),
        //      ("122138", @"$2/$3", "MM/yyyy", false),
        //      ("12-2138", @"$2$3", "MM-yyyy", false),
        //      ("03032020", @"$5/$2/$3", "dd/MM/yyyy", false),
        //      ("12092006", @"$5/$2/$3", "dd/MM/yyyy", false),
        //      ("12-01-2138", @"$5$2$3", "dd-MM-yyyy", false)
        //  };      
        (string date, string replacePattern, string mask, bool acceptWildCard)[] datesWithMaskToTest = {
            ("20__", string.Empty, "yyyy", true),
            ("20__", string.Empty, "yyyy", false),
            ("2006", string.Empty, "yyyy", false),
            ("2138", string.Empty, "yyyy", false),
            ("9238", string.Empty, "yyyy", false),
            ("092006", @"$2/$3", "MM/yyyy", false),
            ("122006", @"$2/$3", "MM/yyyy", false),
            ("129238", @"$2/$3", "MM/yyyy", false),
            ("122138", @"$2/$3", "MM/yyyy", false),
            ("12-2138", @"$2$3", "MM-yyyy", false),
            ("03032020", @"$5/$2/$3", "dd/MM/yyyy", false),
            ("12092006", @"$5/$2/$3", "dd/MM/yyyy", false),
            ("12-01-2138", @"$5$2$3", "dd-MM-yyyy", false)
        };
        foreach (var d in datesWithMaskToTest)
        {
            TestDate(d.date, pattern, d.replacePattern, d.mask, culture, d.acceptWildCard);
            var result = DateInSentence.FilterAbsurdDates(Result.Success(d.date), culture, d.acceptWildCard);
            //Console.WriteLine($"This date is {(result.returnedDate.IsSuccess ? "valid" : "not valid: " + result.returnedDate.Error)}");
            Console.WriteLine($"This date is {(result.IsSuccess ? "valid" : "not valid: " + result.Error)}");
            Console.WriteLine("#################################################################################");
        }
​
        ;
        const string GrabDatesUTC = @"(?<dateUTC>(?<year>-?(?:[1-9][0-9]*)?[0-9]{4})-(?<month>1[0-2]|0[1-9])-(?<day>3[01]|0[1-9]|[12][0-9])T(?<hour>2[0-3]|[01][0-9]):(?<minute>[0-5][0-9]):(?<second>[0-5][0-9])(\\.[0-9]+)?(?<zeroUTCoffse>Z)?|(?<year>(?:[1-9][0-9]*)?[0-9]{4})(?<month>1[0-2]|0[1-9])(?<day>3[01]|0[1-9]|[12][0-9])(?<hour>2[0-3]|[01][0-9])(?<minute>[0-5][0-9])(?<second>[0-5][0-9])(\\.[0-9]+)?(?<zeroUTCoffse>Z)?)";
        TestDate("20230605161406", GrabDatesUTC, string.Empty, "yyyyMMddHHmmss", culture, false);
    }
​
    static CultureInfo SetCulture()
    {
        // Get the current UI culture
        //CultureInfo uiCulture = CultureInfo.CurrentUICulture;
        //Console.WriteLine($"The current UI culture is {uiCulture.Name}");
        // Set the current UI culture
        //CultureInfo.CurrentUICulture = new CultureInfo("pt-BR");      
        // https://phrase.com/blog/posts/all-you-need-to-know-about-cultureinfo-in-net-applications/
        CultureInfo culture = CultureInfo.CurrentCulture;
        Console.WriteLine($"The current culture DisplayName is {culture.DisplayName}");
        Console.WriteLine($"The current culture NativeName is {culture.NativeName}");
        Console.WriteLine($"The current culture IsNeutralCulture? {culture.IsNeutralCulture}");
        //var culture = CultureInfo.InvariantCulture; //= en-US
        // Set the current culture
        culture = new CultureInfo("pt-BR"); //("en-US");        
        Console.WriteLine($"After setting, CultureInfo is {culture.Name.ToString()}");
        Console.WriteLine($"After setting, CultureInfo DisplayName is {culture.DisplayName}");
        Console.WriteLine($"After setting, CultureInfo NativeName is {culture.NativeName}");
        Console.WriteLine($"The current culture IsNeutralCulture? {culture.IsNeutralCulture}");
        CultureInfo.CurrentCulture = culture;
        return culture;
    }
​
    static void TestDates(string[] datesToTest, CultureInfo culture)
    {
        DateTime dateToTest = DateTime.MinValue;
        Console.WriteLine($"################################################ Dates ({culture.Name.ToString()}) ################################################");
        var orderedDates = new List<(DateTime date, string rawDate)>();
        foreach (var date in datesToTest)
        {
            var isDate = DocNameHelper.DateTryParseExact(date, out dateToTest, culture);
            var result = DateInSentence.FilterAbsurdDates(Result.Success(date), culture);
            //Console.WriteLine($"This date is {(result.IsSuccess ? "valid" : "not valid: " + result.Error )}");            
            //dateToTest = result.returnedDate.IsSuccess ? dateToTest : DateTime.MinValue;
            dateToTest = result.IsSuccess ? dateToTest : DateTime.MinValue;
            orderedDates.Add((dateToTest, date));
        }
​
        orderedDates.Sort();
        foreach (var(date, rawDate)in orderedDates)
        {
            Console.WriteLine($"------------------------------------------------------------------------");
            var isDate = date != DateTime.MinValue;
            Console.WriteLine(@$"{rawDate, 25} é data? {isDate}{(isDate ? ": " + date.ToString() : "")}");
        //if (isDate) Console.WriteLine($"{rawDate}");          
        }
    }
​
    static void TestInterval((string date, bool forceBeginDatePreviousYearIfReasonable)[] intervalsToTest, CultureInfo culture)
    {
        const string GrabDateIntervalFromPartOfFile = @"(?<=\W)(?<interval>(?<starting>[ mçinícandouetr]+?)(?<datebegin>\d+)(?<link>[ eatéfimnldzou]+?)(?<=\W)(?<!\w-)(?<dateend>\d+))";
        Console.WriteLine($"################################################ Intervals ({culture.Name.ToString()}) ################################################");
        foreach (var interval in intervalsToTest)
        {
            var (begin, end) = GetInterval(interval.date, GrabDateIntervalFromPartOfFile);
            var result = DateInSentence.FilterAbsurdDates(Result.Success(begin), culture);
            //######//######### From TestingIntervalWithCombinationsOfYearInDates_IfBeginDateEarlierThanEndDate_ShouldPass          
            var (dateBegin, dateEnd) = IntervalInSentence.GetIntervalDates(interval.date, string.Empty);
            var beginIsDDMM = DocNameHelper.IsItPossibleToBeDDMMOrMMDD(dateBegin.Value, CultureInfo.CurrentCulture);
            //Assert.True(beginIsDDMM);
            var endIsDDMM = DocNameHelper.IsItPossibleToBeDDMMOrMMDD(dateEnd.Value, CultureInfo.CurrentCulture);
            //Assert.False(endIsDDMM);
            var validEndInterval = DocNameHelper.DateTryParseExact(dateEnd.Value, out var endInterval, CultureInfo.CurrentCulture, endIsDDMM);
            bool validBeginInterval = false;
            DateTime beginInterval = default;
            bool intervalInvalidBecauseBeginDateAfterEndDate = false;
            var dateParsed = InNameDate.CreateInstance(dateEnd.Value, CultureInfo.CurrentCulture, 2025);
    //
    //      bool beginDDMMDateIsInPreviousYear = false;
    //      
    //      
    //      var formatForDDMM = dateParsed.Mask;
    //      beginDDMMDateIsInPreviousYear =
    //          !DocNameHelper.IsDDMMBeginDateReallyBeforeEndDate(dateBegin.Value, endDateDDMM,
    //              CultureInfo.CurrentCulture, formatForDDMM);
    //      if (beginDDMMDateIsInPreviousYear && forcePreviousYearInDateBeginIfNeeded)
    //      {
    //          validBeginInterval =
    //              DocNameHelper.DateWithNoYearTryParseExact(dateBegin.Value, out beginInterval,
    //                  CultureInfo.CurrentCulture, (endInterval.Year - 1).ToString());
    //      }
    //      else
    //      {
    //          validBeginInterval =
    //              DocNameHelper.DateWithNoYearTryParseExact(dateBegin.Value, out beginInterval,
    //                  CultureInfo.CurrentCulture, endInterval.Year.ToString());
    //      }
    //  }
​
        //if (validBeginInterval && validEndInterval && !beginDDMMDateIsInPreviousYear)
        //  Assert.Equal((beginInterval < endInterval), isValid);
        //if (beginDDMMDateIsInPreviousYear && !forcePreviousYearInDateBeginIfNeeded)
        //  Assert.True(beginInterval > endInterval);
​
            intervalInvalidBecauseBeginDateAfterEndDate =// false;
                    !DocNameHelper.IsDDMMBeginDateReallyBeforeEndDate(dateBegin.Value, dateEnd.Value,
                                                                      CultureInfo.CurrentCulture, dateParsed.Mask);
            validBeginInterval = DocNameHelper.DateTryParseExact(dateBegin.Value, out beginInterval, CultureInfo.CurrentCulture, beginIsDDMM);
            var errorMsgBeginDateAfterEndDate = intervalInvalidBecauseBeginDateAfterEndDate ? " because BeginDate is After EndDate" : string.Empty;
            var errorMsgInvalidBeginDateOrEndDate = result.IsFailure ? " because of BeginDate and/or EndDate are not valid" : string.Empty;
            Console.WriteLine($"Interval is {(intervalInvalidBecauseBeginDateAfterEndDate || result.IsFailure ? "INVALID" + errorMsgBeginDateAfterEndDate + errorMsgInvalidBeginDateOrEndDate : "Valid")}");
            //######//######### From TestingIntervalWithCombinationsOfYearInDates_IfBeginDateEarlierThanEndDate_ShouldPass                      
            Console.WriteLine($"Begin date ({begin}) is {(result.IsSuccess ? "valid" : "not valid: " + result.Error)}. Mask: {dateParsed.Mask}.");
            result = DateInSentence.FilterAbsurdDates(Result.Success(end), culture);
            //Console.WriteLine($"End date ({end}) is {(result.returnedDate.IsSuccess ? "valid" : "not valid: " + result.returnedDate.Error)}");
            Console.WriteLine($"End date ({end}) is {(result.IsSuccess ? "valid" : "not valid: " + result.Error)}");
            Console.WriteLine("#################################################################################");
        }
    }
    static (string begin, string end) GetInterval(string rawInterval, string pattern)
    {
        //  Comparecimentos em sessões de fisioterapia em 2012 e 2015
        //Prontuário Itaú entre 19092007 e 12092022
        //Receitas ortopédicas entre 2013 e 2021
        // entre 2013 e 2021    
        var match = DocNameHelper.GetMatch(pattern, rawInterval); //, "dateend");
        Console.WriteLine($"##interval: {DocNameHelper.GetMatchMainGroup(pattern, rawInterval).Value}-------------------------------------------------"); // == match.Groups[0].Value.Dump("interval");
        Console.WriteLine($"starting: {DocNameHelper.GetMatch(pattern, rawInterval, "starting").Value}");
        Console.WriteLine($"datebegin: {match.Groups["datebegin"].Value}");
        Console.WriteLine($"link: {match.Groups["link"].Value}");
        Console.WriteLine($"dateend: {match.Groups["dateend"].Value}");
        return (match.Groups["datebegin"].Value, match.Groups["dateend"].Value);
    //var matches = GetMatches(pattern, " entre 2013 e 2021");
    //matches.Dump(); //"matches"
    }
​
    static void TestDate(string rawDate, string pattern, string replacePattern, string toTryParseExact, CultureInfo culture, bool acceptWildCard)
    {
        Console.WriteLine($"{rawDate}:");
        DateTime date = DateTime.MinValue;
        //var matches = Regex.Matches(rawDate, pattern);
        //matches.Dump();
        var dateFormatted = string.Empty;
        if (string.IsNullOrEmpty(replacePattern))
        {
            dateFormatted = rawDate;
        }
        else
        {
            dateFormatted = Regex.Replace(rawDate, pattern, replacePattern);
        }
​
        Console.WriteLine($"      dateFormatted {dateFormatted}:");
        dateFormatted.Dump();
        Console.WriteLine($"      TryParseExact with {toTryParseExact}:");
        DateTime.TryParseExact(dateFormatted, toTryParseExact // error if dd/mm or dd/mmm 
        , null, DateTimeStyles.AssumeLocal, out date);
        date.Dump();
        Console.WriteLine($"      TryParse:");
        DateTime.TryParse(dateFormatted, null, DateTimeStyles.AssumeLocal, out date);
        date.Dump();
        Console.WriteLine($"      FilterAbsurdDates with acceptWildCard = {acceptWildCard}:");
        var filter = DateInSentence.FilterAbsurdDates(Result.Success(dateFormatted), culture, acceptWildCard);
        filter.Dump();
    }
//
//Excised methods were here
//  
}
​
// ###################            ##################################      Enums      ##################################            ###################
public enum DateFormat
{
        NoDate = -1,
        yyyy = 0,
        MMyyyy,
        MMMyyyy,
        MMMMyyyy,
​
        MMdd,
        MMMdd,
        MMMMdd,
        MMddyyyy,
        MMMddyyyy,
        MMMMddyyyy,
​
        ddMM,
        ddMMM,
        ddMMMM,
        ddMMyyyy,
        ddMMMyyyy,
        ddMMMMyyyy,
​
        dd,
        MM,
        MMM,
        MMMM,
​
        yyyyMM,
        yyyyMMM,
        yyyyMMMM,
        yyyyMMdd,
        [Description("dd/MM/yyyy HH:mm:ss")]
        completeUpToSeconds,
        [Description("MM/dd/yyyy HH:mm:ss")]
        completeUpToSecondsUS,
        [Description("yyyyMMddHHmmss")]
        sortable,
        [Description("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'")]
        universalSortable
}
​
public enum CertaintyAboutElement
{
    NonExisting = -1,
    AbsolutelyCertain = 0,
    InformedGuess,
    InformedByUser,
    NotSure
}
​
public enum DocNamePart
{
    NoPart = 0,
    First,
    Middle,
    Last,
    Extension
}
​
public enum ElementRelativePosition
{
    DoesNotExist = 0,
    First,
    Middle,
    Last,
//Second,
//Third,
//Fourth,
//Fifty
}
​
public enum WhichElementItIs
{
    DoesNotExist = 0,
    WhicheverVersion,
    VersionNumberOnly,
    VersionWithPrefix,
    FileNameDate,
    FileNameInterval,
    GUID,
    DrugNameDose
}
​
// ###################            ##################################      Enums      ##################################            ###################
// ###################            ##################################      DocNameHelper      ##################################            ###################
public static class DocNameHelper
{
#region Public Constants
    public const string GrabNameAndExtension = @"(?<fullname>.+?)(\.(?<extension>[^.]*)$|$)"; //https://regex101.com/r/ThSD20/1
    public const string GrabPartsOfName = @"([\w _<>+;.,']*)*"; //https://regex101.com/r/mduYnK/2
    public const string GrabDelimiterWithSpaceAround = @"( - )";
    public const string GrabFakeDelimiterWithoutAnySpaceAround = @"(?<before>[\d\w' -.]*)(?<=\w)(?<FakeDelimiter>[-˗–])(?=\w)(?<after>[\d\w -.]*)";
    //https://regex101.com/r/dMMzEW/2
    public const string TemporarySubstitutionForFakeDelimiter = @"${before}<>${after}";
    public const string GrabTemporarySubstitutionForFakeDelimiter = @"(?<before>[\d\w -.]*)(?<=\w)(?<FakeDelimiter>\<\>)(?=\w)(?<after>[\d\w -.]*)";
    public const string RestorePreviousStateBeforeFakeDelimiter = @"${before}-${after}";
#endregion Public Constants
#region Common
    //        public static string StripOffDateIntervalVersionAndDrug(string partToBeStrippedOff, DocPartElementsMount docNameElements
    //            , string date = "", string version = "", string interval = "", string medicineAndDose = "")
    //        {
    //        }
    //        public static string StripOffPartWithConnector(string partToBeStrippedOff, string partToStrip
    //            , WhichElementItIs whichElementItIs, DocPartElementsMount docNameElements)
    //        {
    //
    //        }
    public static string StripOffPart(string partToBeStrippedOff, string partToRemove, string connectorBefore)
    {
        if (!string.IsNullOrEmpty(connectorBefore) && !string.IsNullOrWhiteSpace(connectorBefore))
            partToRemove = connectorBefore + partToRemove;
        if (!string.IsNullOrWhiteSpace(partToRemove))
            partToBeStrippedOff = partToBeStrippedOff.Replace(partToRemove.Trim(), string.Empty);
        return partToBeStrippedOff = partToBeStrippedOff.Trim();
    }
​
    public static bool DifficultyToTestPart(string partToTest)
    {
        return partToTest.Length > 10 && partToTest.DoesNotContainAnySpace();
    }
​
    public static Result<string> ReturnResult(string pattern, string part, string groupName, string errorMsg)
    {
        _ = GetMatch(pattern, part, groupName, errorMsg, out var result);
        //if ((!result.IsFailure && OutOfForbiddenZoneIfSamePart(groupName, partName, match, partHasGUID)) || !isDate) return result;
        //if (!result.IsFailure && OutOfForbiddenZoneIfSamePart(groupName, match, partHasGUID) || !isDate) return result;
        return result;
    }
​
    //GetMatch is a poor name...
    //Used in App
    internal static Match GetMatch(string pattern, string part, string groupName, string errorMsg, out Result<string> result)
    {
        var rgx = new Regex(pattern);
        var match = rgx.Match(" " + part.TrimStart());
        //BUG                     ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
        //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
        result = match.Success ? Result.Success(match.Groups[groupName].Value.Trim()) : Result.Failure<string>(errorMsg);
        return match;
    }
​
    //Used in NetFiddle
    internal static Match GetMatch(string pattern, string part) //, string groupName)
    {
        var rgx = new Regex(pattern);
        var match = rgx.Match(" " + part);
        //BUG                ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
        //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
        return match;
    }
​
    //Used in NetFiddle
    internal static Group GetMatchMainGroup(string pattern, string part) //, string groupName)
    {
        var rgx = new Regex(pattern);
        var match = rgx.Match(part.EnsureOneSingleSpaceAtBegin());
        //BUG                ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
        //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
        return match.Groups[0];
    }
​
    //Used in NetFiddle
    internal static Group GetMatch(string pattern, string part, string groupName)
    {
        var rgx = new Regex(pattern);
        var match = rgx.Match(part.EnsureOneSingleSpaceAtBegin());
        //BUG                ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
        //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
        return match.Groups[groupName];
    }
​
    //Not used anywhere
    internal static MatchCollection GetMatches(string pattern, string part)
    {
        var rgx = new Regex(pattern);
        var matches = rgx.Matches(part.EnsureOneSingleSpaceAtBegin());
        //BUG                    ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015"      
        return matches;
    }
​
    internal static bool OutOfForbiddenZoneIfSamePart(string groupName, Match match, int startOfForbiddenZone, int endOfForbiddenZone)
    {
        return BeforeStartOfForbiddenZone(groupName, match, startOfForbiddenZone) && AfterEndOfForbiddenZone(groupName, match, endOfForbiddenZone);
    }
​
    private static bool BeforeStartOfForbiddenZone(string groupName, Match match, int startOfForbiddenZone)
    {
        return match.Groups[groupName].Index + match.Groups[groupName].Length - 1 < startOfForbiddenZone;
    }
​
    private static bool AfterEndOfForbiddenZone(string groupName, Match match, int endOfForbiddenZone)
    {
        return match.Groups[groupName].Index > endOfForbiddenZone;
    }
​
#endregion Common
#region Interval and Date
    public static string[] dubiousDDMMOrYYYY() => new string[]{"2001", "2002", "2003", "2004", "2005", "2006", "2007", "2008", "2009", "2010", "2011", "2012"};
    //https://stackoverflow.com/questions/62703152/convert-two-fields-month-and-year-into-a-yyyy-mm-dd-field
    public static string[] dubiousMMDDOrYYYY() => new string[]{""}; //??
    //public static Result<string> TreatIntervalComparingItWithDate(Result<string> interval, Result<string> fileDate)
    //{
    //    if (!fileDate.IsSuccess) return interval;
    //    if (interval.IsSuccess && fileDate.Value == interval.Value)
    //        return Result.Failure<string>("No interval date stamp in this file name");
    //    return interval;
    //}
    //TODO: maybe I should try to equalize years of interval dates, if they are not equal
    //OLD: TryEqualizeYearsOfIntervalDates
    internal static (Result<InNameDate> dateBegin, Result<InNameDate> dateEnd) TryCompareIntervalDates(string dateBegin, string dateEnd, CultureInfo cultureInfo, bool sameFrameIntervalIsAllowed = false)
    {
        var errorMsg = string.Empty;
        var isDDMM = cultureInfo.Name == "pt-BR";
        if (dateBegin.IsNumber() && dateEnd.IsNumber())
        {
            switch (dateEnd.Length)
            {
                case 8: //ddMMyyyy
                    var formatEnd = isDDMM
                        ? DateFormat.ddMMyyyy
                        : DateFormat.MMddyyyy;
                    var dateEndIsDDMM = DateTime.TryParseExact(dateEnd, formatEnd.GetDescription(),
                                                               cultureInfo, DateTimeStyles.None, out var dateEnded);
                    if (dateBegin.Length == 8) //ddMMyyyy
                    {
                        var date = InNameDate.CreateInstance(dateBegin, cultureInfo, 2025, false);
                        //var (mask, format) = FormatForDDMMYYYYBasedOn(cultureInfo);
                        var (mask, format) = (date.Mask.GetDescription(), date.Mask);
                        var validDates = TryToParseDatesAsDDMM_MMDD(dateBegin, dateEnd, cultureInfo, mask);
                        if (validDates.dateStarted != DateTime.MinValue && validDates.dateEnded != DateTime.MinValue)
                        {
                            if (IsDDMMBeginDateReallyBeforeEndDate(dateBegin, dateEnd, cultureInfo, DateFormat.ddMMyyyy,
                                                                   sameFrameIntervalIsAllowed))
                            {
                                return (Result.Success(InNameDate.CreateInstance(dateBegin, validDates.dateStarted, format))
                                        , Result.Success(InNameDate.CreateInstance(dateEnd, validDates.dateEnded, format)));
                            }
                        }
                    }
                    else if (dateBegin.Length == 6) //almost impossible MMyyyy
                    {
                        throw new NotImplementedException("I did not implemented 'de MMyyyy até ddMMyyyy'");
                    }
                    else if (dateBegin.Length == 4) //ddmm
                    {
                        var dateBeginIsDDMM = DateTime.TryParseExact(dateBegin + dateEnded.Year, formatEnd.GetDescription(),
                                                                     cultureInfo, DateTimeStyles.None, out var ddMMBegin);
                        if (IsBeginDateReallyBeforeEndDate(ddMMBegin, dateEnded, sameFrameIntervalIsAllowed))
                        {
                            return (Result.Success(InNameDate.CreateInstance(dateBegin + dateEnded.Year, ddMMBegin, formatEnd)), 
                                    Result.Success(InNameDate.CreateInstance(dateEnd, dateEnded, formatEnd))
                                   );
                        }
                    }
                    else if (dateBegin.Length == 2) //dd
                    {
                        var dayBegin = int.Parse(dateBegin); //dateBegin.Substring(0, 2);
                        if ((dayBegin > 0 && dayBegin < dateEnded.Day) || ((dayBegin == dateEnded.Day) && sameFrameIntervalIsAllowed))
                        {
                            var dayInterval = Result.Success(InNameDate.CreateInstance(dateBegin,
                                                                                       new DateTime(dateEnded.Year, dateEnded.Month, dayBegin), DateFormat.dd));
                            return (dayInterval, 
                                    Result.Success(InNameDate.CreateInstance(dateEnd, dateEnded, formatEnd))
                                   );
                        }
                    }
                    break;
                case 6: //MMyyyy
                    if (dateBegin.Length == 8) //almost impossible ddMMyyyy
                    {
                        throw new NotImplementedException("I did not implemented 'de ddMMyyyy até MMyyyy'");
                    }
                    else if (dateBegin.Length == 6) //MMyyyy
                    {
​
                    }
                    else if (dateBegin.Length == 4) //almost impossible ddMM; I do not think about MMyy
                    {
                        throw new NotImplementedException("I did not implemented 'de ddMM até MMyyyy'");
                    }
                    else if (dateBegin.Length == 2) //MM
                    {
​
                    }
                    break;
                case 4: //ddmm OR yyyy ???
                    if (dateBegin.Length == 8) //almost impossible ddMMyyyy
                    {
​
                    }
                    else if (dateBegin.Length == 6) //almost impossible MMyyyy
                    {
​
                    }
                    else if (dateBegin.Length == 4)
                    {
                        //yyyy => dateEnd = yyyy
                        //ddmm => dateEnd = ddmm;
                        var result = DecideIfDateEndIsYYYYOrDDMM(dateBegin, dateEnd, cultureInfo, null, sameFrameIntervalIsAllowed: sameFrameIntervalIsAllowed);
                        if (result.dateBegin.CertaintyAbout != CertaintyAboutElement.NonExisting)
                        {
                            return (Result.Success(result.dateBegin), Result.Success(result.dateEnd));
                        }
                    }
                    else if (dateBegin.Length == 2) //dd OR MM
                    { // dateEnd = ddmm OR MMYY
​
                    }
                    break;
​
            }
​
        }
        //var dateEnd = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "dateend", errorMsg);
        //var dateBegin = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "datebegin", errorMsg);
        errorMsg = "No interval date stamp in this file name";
        return (Result.Failure<InNameDate>(errorMsg), Result.Failure<InNameDate>(errorMsg));
    }
​
​
    /// <summary>
    /// Decide if dateEnd.Length == 4 is YYYY or DDMM based or appropriate culture and maxPossibleYear.
    /// If both possibilities are valid, I'm betting that if you are not informing YYYY in two MMDD or DDMM interval,
    /// it should be YYYY instead
    /// </summary>
    /// <param name = "dateBeginToTest"></param>
    /// <param name = "dateEndToTest"></param>
    /// <param name = "cultureInfo"></param>
    /// <param name = "maxPossibleYear"></param>
    /// <param name = "minPossibleYear"></param>
    /// <param name = "sameFrameIntervalIsAllowed"></param>
    /// <returns></returns>
    internal static (InNameDate dateBegin, InNameDate dateEnd) DecideIfDateEndIsYYYYOrDDMM(string dateBeginToTest, string dateEndToTest, CultureInfo cultureInfo, int? maxPossibleYear, int minPossibleYear = 1990, bool sameFrameIntervalIsAllowed = false)
    {
        maxPossibleYear ??= InNameDate.GetCurrentYearPlus(3);
        var(isDateEndDubious, isDateBeginDubious, certaintyAboutYYYY) = DecideDegreeOfCertaintyAboutDates(dateBeginToTest, dateEndToTest, cultureInfo);
        var date = InNameDate.CreateInstance(dateBeginToTest, cultureInfo, 2025);
        //var (maskForDDMM, formatForDDMM) = FormatForDDMMBasedOn(cultureInfo);         
        var(maskForDDMM, formatForDDMM) = (date.Mask.GetDescription(), date.Mask);
        var dateBegin = InNameDate.NullDate;
        var dateBeginIsYYYY = false;
        var dateBeginIsDDMM = false;
        var dateEnd = InNameDate.NullDate;
        var dateEndIsYYYY = false;
        var dateEndIsDDMM = false;
        var(dateEnded, endDateMaybeYYYY) = TryToParseDateAsYYYY(dateEndToTest, cultureInfo);
        var(dateStarted, beginDateMaybeYYYY) = TryToParseDateAsYYYY(dateBeginToTest, cultureInfo);
        if (beginDateMaybeYYYY)
            endDateMaybeYYYY = IsValidEndDateYYYY(dateStarted, dateEnded, minPossibleYear, maxPossibleYear.Value, sameFrameIntervalIsAllowed);
        //If both possibilities are valid, I'm betting that if you are not informing YYYY in two MMDD or DDMM interval,
        //it should be YYYY instead, otherwise yyyy will get undetermined...
        (dateBeginIsYYYY, dateEndIsYYYY) = DetermineIfIntervalDatesShouldBeYYYY(isDateEndDubious, isDateBeginDubious, endDateMaybeYYYY, beginDateMaybeYYYY, dateEndIsYYYY, dateBeginIsYYYY);
        var beginCannotBeDDMMOrMMDD = !IsItPossibleToBeDDMMOrMMDD(dateBeginToTest, cultureInfo);
        if (beginCannotBeDDMMOrMMDD && !endDateMaybeYYYY)
        {
            if (dateStarted != dateEnded)
                return (InNameDate.NullDate, InNameDate.NullDate);
            //Below is by design; I do not allow interval like "between 2013 and 2013", unless for testing purposes
            if (dateStarted == dateEnded && !sameFrameIntervalIsAllowed)
                return (InNameDate.NullDate, InNameDate.NullDate);
        }
​
        if (dateBeginIsYYYY || beginCannotBeDDMMOrMMDD)
            (dateStarted, dateBeginIsYYYY) = TryToParseDateAsYYYY(dateBeginToTest, cultureInfo);
        else
            // The other way to do this is allow client to choose the YYYY if it is DDMM or MMDD, and allow bool forcePreviousYearInDateBeginIfNeeded = false or true
            // but this is more complicated, and implies that dateEnd.Length == 4 => 8 and,
            // if forcePreviousYearInDateBeginIfNeeded = true, maybe dateBegin.Length == 4 => 8 too...
            (dateBeginIsDDMM, dateStarted, dateEndIsDDMM, dateEnded) = TryToParseDatesAsDDMM_MMDD(dateBeginToTest, dateEndToTest, cultureInfo, maskForDDMM);
        if (dateBeginIsYYYY)
        {
            dateEndIsYYYY = DateTime.TryParseExact(dateEndToTest, DateFormat.yyyy.GetDescription(), cultureInfo, DateTimeStyles.None, out dateEnded);
            if (!dateEndIsYYYY)
                return (dateBegin, dateEnd);
            dateBegin = InNameDate.CreateInstance(dateBeginToTest, dateStarted, DateFormat.yyyy, certaintyAboutYYYY);
            dateEnd = InNameDate.CreateInstance(dateEndToTest, dateEnded, DateFormat.yyyy, certaintyAboutYYYY);
        }
        else if (dateBeginIsDDMM)
        {
            if (!dateEndIsDDMM || !IsDDMMBeginDateReallyBeforeEndDate(dateBeginToTest, dateEndToTest, cultureInfo, formatForDDMM, sameFrameIntervalIsAllowed))
                return (dateBegin, dateEnd);
            dateBegin = InNameDate.CreateInstance(dateBeginToTest, dateStarted, formatForDDMM, certaintyAboutYYYY);
            dateEnd = InNameDate.CreateInstance(dateEndToTest, dateEnded, formatForDDMM, certaintyAboutYYYY);
        }
​
        return (dateBegin, dateEnd);
    }
​
    private static (bool isDateEndDubious, bool isDateBeginDubious, CertaintyAboutElement certaintyAboutYYYY) DecideDegreeOfCertaintyAboutDates(string dateBeginToTest, string dateEndToTest, CultureInfo cultureInfo)
    {
        var dubiousDate = cultureInfo.Name == "pt-BR" ? dubiousDDMMOrYYYY() : dubiousMMDDOrYYYY();
        var isDateEndDubious = dubiousDate.Contains(dateEndToTest);
        var isDateBeginDubious = dubiousDate.Contains(dateBeginToTest);
        var certaintyAboutYYYY = isDateBeginDubious && isDateEndDubious ? CertaintyAboutElement.InformedGuess : CertaintyAboutElement.AbsolutelyCertain;
        return (isDateEndDubious, isDateBeginDubious, certaintyAboutYYYY);
    }
​
    private static (DateTime dateParsed, bool tryParseExact) TryToParseDateAsYYYY(string dateToTest, CultureInfo cultureInfo)
    {
        var tryParseExact = DateTime.TryParseExact(dateToTest, DateFormat.yyyy.ToString(), cultureInfo, DateTimeStyles.None, out var dateParsed);
        return (dateParsed, tryParseExact);
    }
​
    private static (bool dateBeginIsDDMM, DateTime dateStarted, bool dateEndIsDDMM, DateTime dateEnded) TryToParseDatesAsDDMM_MMDD(string dateBeginToTest, string dateEndToTest, CultureInfo cultureInfo, string maskForDDMM)
    {
        var dateBeginIsDDMM = DateTime.TryParseExact(dateBeginToTest, maskForDDMM, cultureInfo, DateTimeStyles.None, out var dateStarted);
        var dateEndIsDDMM = DateTime.TryParseExact(dateEndToTest, maskForDDMM, cultureInfo, DateTimeStyles.None, out var dateEnded);
        return (dateBeginIsDDMM, dateStarted, dateEndIsDDMM, dateEnded);
    }
​
    private static (bool dateBeginIsYYYY, bool dateEndIsYYYY) DetermineIfIntervalDatesShouldBeYYYY(bool isDateEndDubious, bool isDateBeginDubious, bool endDateMaybeYYYY, bool beginDateMaybeYYYY, bool dateEndIsYYYY, bool dateBeginIsYYYY)
    {
        if (IfNoDateIsDubious(isDateEndDubious, isDateBeginDubious))
            return (endDateMaybeYYYY, beginDateMaybeYYYY);
        if (AtLeastSomeDateIsDubiousAndBothDatesMaybeYYYY(endDateMaybeYYYY, beginDateMaybeYYYY))
            return (true, true);
        //AtLeastSomeDateIsDubious and only one date is maybe YYYY:
        return (dateBeginIsYYYY, dateEndIsYYYY);
    }
​
    private static bool AtLeastSomeDateIsDubiousAndBothDatesMaybeYYYY(bool endDateMaybeYYYY, bool beginDateMaybeYYYY)
    {
        return endDateMaybeYYYY && beginDateMaybeYYYY;
    }
​
    private static bool IfNoDateIsDubious(bool isDateEndDubious, bool isDateBeginDubious)
    {
        return !isDateEndDubious && !isDateBeginDubious;
    }
​
    internal static bool IsItPossibleToBeDDMMOrMMDD(string dateToTest, CultureInfo cultureInfo)
    {
        if (dateToTest.Length != 4)
            return false;
        return DateTime.TryParseExact(dateToTest, DateFormat.ddMM.GetDescription(), cultureInfo, DateTimeStyles.None, out _) || DateTime.TryParseExact(dateToTest, DateFormat.MMdd.GetDescription(), cultureInfo, DateTimeStyles.None, out _);
    }
​
    /// <summary>
    /// This function is used to decide if the dateBegin is really before dateEnd
    /// </summary>
    /// <param name = "dateBegin"></param>
    /// <param name = "dateEnd"></param>
    /// <param name = "cultureInfo"></param>
    /// <param name = "sameFrameIntervalIsAllowed"></param>
    /// <returns></returns>
    internal static bool IsDDMMBeginDateReallyBeforeEndDate(string dateBegin, string dateEnd, CultureInfo cultureInfo, DateFormat dateFormat, bool sameFrameIntervalIsAllowed = false)
    {
        //var maskForDDMM = MaskForDateParsing(cultureInfo, dateFormat);
        var beginDateValid = DateTime.TryParseExact(dateBegin, dateFormat.GetDescription(), cultureInfo, DateTimeStyles.None, out var beginDate);
        //var beginDate = DateTime.ParseExact(dateBegin, dateFormat.GetDescription(), cultureInfo);
        var endDateValid = DateTime.TryParseExact(dateEnd, dateFormat.GetDescription(), cultureInfo, DateTimeStyles.None, out var endDate);
        if (!beginDateValid || !endDateValid)
            return false;
        //var endDate = DateTime.ParseExact(dateEnd, dateFormat.GetDescription(), cultureInfo);
        return IsBeginDateReallyBeforeEndDate(beginDate, endDate, sameFrameIntervalIsAllowed);
    //sameFrameIntervalIsAllowed ? beginDate <= endDate : beginDate < endDate;
    }
​
    internal static bool IsBeginDateReallyBeforeEndDate(DateTime dateBegin, DateTime dateEnd, bool sameFrameIntervalIsAllowed) => sameFrameIntervalIsAllowed ? dateBegin <= dateEnd : dateBegin < dateEnd;
    internal static bool IsValidEndDateYYYY(DateTime dateBegin, DateTime dateEnd, int minPossibleYear, int maxPossibleYear, bool sameYearIntervalIsAllowed)
    {
        if (!IsBeginDateReallyBeforeEndDate(dateBegin, dateEnd, sameYearIntervalIsAllowed))
            return false;
        return dateEnd.Year >= minPossibleYear && dateEnd.Year <= maxPossibleYear;
    }
​
    //internal static (string mask, DateFormat dateFormat) FormatForDDMMBasedOn(CultureInfo cultureInfo)
    //{
    //  var isFormatLikeDDMM = cultureInfo.Name == "pt-BR";
    //  var maskForDDMM = isFormatLikeDDMM ? DateFormat.ddMM.GetDescription() : DateFormat.MMdd.GetDescription();
    //  var formatForDDMM = isFormatLikeDDMM ? DateFormat.ddMM : DateFormat.MMdd;
    //  return (maskForDDMM, formatForDDMM);
    //}
    //internal static (string mask, DateFormat dateFormat) FormatForDDMMYYYYBasedOn(CultureInfo cultureInfo)
    //{
    //  var isFormatLikeDDMM = cultureInfo.Name == "pt-BR";
    //  var maskForDDMM = isFormatLikeDDMM ? DateFormat.ddMMyyyy.GetDescription() : DateFormat.MMddyyyy.GetDescription();
    //  var formatForDDMM = isFormatLikeDDMM ? DateFormat.ddMMyyyy : DateFormat.MMddyyyy;
    //  return (maskForDDMM, formatForDDMM);
    //}
    //static int GetCurrentYearPlus(int toAddCurrent)
    //{
    //    return DateTime.Now.Year + toAddCurrent;
    //}
#endregion Interval and Date
#region GUID
    //public static string TreatPartWithGUID(string part, InNameGUID partHasGUID, DocPartElementsMount docNameElements, int numOfCharOfConnectorBefore = 1)
    //{         
    //    var connector = docNameElements.AddConnectorBeforeElement(WhichElementItIs.GUID,
    //        part.GetNumberOfCharsJustBeforeSubstring(partHasGUID.GUID, numOfCharOfConnectorBefore));
    //    return StripOffPart(part, partHasGUID.GUID, connector);
    //}
#endregion GUID
#region MedicinesAndDosage
#endregion MedicinesAndDosage
#region Version
    //public static bool CheckIfVersionIsFirst(string partToTest, Result<string> fileVersion, Result<string> fileDate)
    //{
    //    //By default, version always should be first, before date
    //    if (!fileVersion.IsSuccess || !fileDate.IsSuccess) return true;
    //    var whereVersion = partToTest.IndexOf(fileVersion.Value, StringComparison.CurrentCulture);
    //    var whereDate = partToTest.IndexOf(fileDate.Value, StringComparison.CurrentCulture);
    //    return whereVersion < whereDate;
    //}
#endregion Version
#region Dates
    /// <summary>
    /// 
    /// </summary>
    /// <param name = "dateWithoutSpace"></param>
    /// <param name = "testDate"></param>
    /// <param name = "cultureInfo"></param>
    /// <returns></returns>
    internal static bool DateWithNoYearTryParseExact(string dateWithNoYearAndWithoutSpace, string yearToAssume, out DateTime testDate, CultureInfo cultureInfo)
    {
        //Guard.ThrowIfStringNullOrEmptyOrNotString(dateWithNoYearAndWithoutSpace, nameof(dateWithNoYearAndWithoutSpace));
        ArgumentException.ThrowIfNullOrEmpty(dateWithNoYearAndWithoutSpace);
        //Guard.ThrowIfStringNullOrEmptyOrNotString(yearToAssume, nameof(yearToAssume));
        ArgumentException.ThrowIfNullOrEmpty(yearToAssume);
        return DateTryParseExact(dateWithNoYearAndWithoutSpace + yearToAssume, out testDate, cultureInfo);
    }
​
    /// <summary>
    /// TODO: internal open to Test
    /// </summary>
    /// <param name = "dateWithoutSpace"></param>
    /// <param name = "testDate"></param>
    /// <param name = "cultureInfo"></param>
    /// <returns></returns>
    internal static bool DateTryParseExact(string dateWithoutSpace, out DateTime testDate, CultureInfo cultureInfo, bool forceDDMM = false)
    {
        //https://dotnetfiddle.net/F6fGPt
        //https://learn.microsoft.com/en-us/dotnet/standard/base-types/parsing-datetime
        //https://stackoverflow.com/questions/10029099/datetime-parse2012-09-30t230000-0000000z-always-converts-to-datetimekind-l
        //Guard.ThrowIfStringNullOrEmptyOrNotString(dateWithoutSpace, nameof(dateWithoutSpace));
        ArgumentException.ThrowIfNullOrEmpty(dateWithoutSpace);
        var yyyy = forceDDMM ? string.Empty : DateFormat.yyyy.GetDescription();
        var isDDMM = cultureInfo.Name == "pt-BR";
        var ddMMyyyy = isDDMM ? DateFormat.ddMMyyyy.GetDescription() : DateFormat.MMddyyyy.GetDescription();
        var ddMMMyyyy = isDDMM ? DateFormat.ddMMMyyyy.GetDescription() : DateFormat.MMMddyyyy.GetDescription();
        var ddMMMMyyyy = isDDMM ? DateFormat.ddMMMMyyyy.GetDescription() : DateFormat.MMMMddyyyy.GetDescription();
        var ddMM = isDDMM ? DateFormat.ddMM.GetDescription() : DateFormat.MMdd.GetDescription();
        var ddMMM = isDDMM ? DateFormat.ddMMM.GetDescription() : DateFormat.MMMdd.GetDescription();
        var ddMMMM = isDDMM ? DateFormat.ddMMMM.GetDescription() : DateFormat.MMMMdd.GetDescription();
        var ddMMyyyyHHmmssWithSlash = isDDMM ? DateFormat.completeUpToSeconds.GetDescription() : DateFormat.completeUpToSecondsUS.GetDescription();
        return DateTime.TryParse(dateWithoutSpace, cultureInfo, DateTimeStyles.None, out testDate) || DateTime.TryParseExact(dateWithoutSpace, yyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, DateFormat.MMMMyyyy.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, DateFormat.MMMyyyy.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, DateFormat.MMyyyy.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, ddMMyyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, ddMMMyyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, ddMMMMyyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, ddMM, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, ddMMM, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, ddMMMM, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, ddMMyyyyHHmmssWithSlash, cultureInfo, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, DateFormat.universalSortable.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out testDate) || DateTime.TryParseExact(dateWithoutSpace, DateFormat.sortable.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out testDate);
    //https://stackoverflow.com/questions/13457458/difference-between-universalsortabledatetimepattern-and-sortabledatetimepattern
    //https://stackoverflow.com/questions/3025361/c-sharp-datetime-to-yyyymmddhhmmss-format
    //// create date time 2008-03-09 16:05:07.123
    //            DateTime dt = new DateTime(2008, 3, 9, 16, 5, 7, 123);
    //            String.Format("{0:y yy yyy yyyy}",      dt);  // "8 08 008 2008"   year
    //            String.Format("{0:M MM MMM MMMM}",      dt);  // "3 03 Mar March"  month
    //            String.Format("{0:d dd ddd dddd}",      dt);  // "9 09 Sun Sunday" day
    //            String.Format("{0:h hh H HH}",          dt);  // "4 04 16 16"      hour 12/24
    //            String.Format("{0:m mm}",               dt);  // "5 05"            minute
    //            String.Format("{0:s ss}",               dt);  // "7 07"            second
    //            String.Format("{0:f ff fff ffff}",      dt);  // "1 12 123 1230"   sec.fraction
    //            String.Format("{0:F FF FFF FFFF}",      dt);  // "1 12 123 123"    without zeroes
    //            String.Format("{0:t tt}",               dt);  // "P PM"            A.M. or P.M.
    //            String.Format("{0:z zz zzz}",           dt);  // "-6 -06 -06:00"   time zone
    //// month/day numbers without/with leading zeroes
    //            String.Format("{0:M/d/yyyy}",           dt);  // "3/9/2008"
    //            String.Format("{0:MM/dd/yyyy}",         dt);  // "03/09/2008"
    //// day/month names
    //            String.Format("{0:ddd, MMM d, yyyy}",   dt);  // "Sun, Mar 9, 2008"
    //            String.Format("{0:dddd, MMMM d, yyyy}", dt);  // "Sunday, March 9, 2008"
    //// two/four digit year
    //            String.Format("{0:MM/dd/yy}",           dt);  // "03/09/08"
    //            String.Format("{0:MM/dd/yyyy}",         dt);  // "03/09/2008"
    }
//        public static IEnumerable<DocName> OrderDocsByDate(IEnumerable<DocName> docs)
//        {
//DONE put a field that merge Date and, if date is null, the Last part of interval
//return docs.OrderBy(x => x.HasDate ? x.GetDateTime() : x.GetLastPartOfIntervalTime() );
//            return docs.OrderBy(x => x.GetDateTimeOrLastPartOfIntervalForOrderDoc());
//        }
#endregion Dates
}
​
// ###################            ##################################      DocNameHelper      ##################################            ###################
// ###################            ##################################      InNameDate       ##################################            ###################
public class InNameDate : ValueObject
{
    public string DateText { get; }
​
    public DateTime DateTime { get; }
​
    public DateFormat Mask { get; }
​
    public CertaintyAboutElement CertaintyAbout { get; }
​
    private InNameDate(string dateText, DateTime dateTime, DateFormat mask, CertaintyAboutElement certaintyAbout)
    {
        DateText = dateText;
        DateTime = dateTime;
        Mask = mask;
        CertaintyAbout = certaintyAbout;
    }
​
    public static InNameDate NullDate => new(string.Empty, DateTime.MinValue, DateFormat.NoDate, CertaintyAboutElement.NonExisting);
    public static InNameDate ChangeMask(InNameDate date, DateFormat newMask)
    {
        return CreateInstance(date.DateText, date.DateTime, newMask);
    }
​
    public static InNameDate ChangeToYYYY(InNameDate date, DateFormat newMask)
    {
        if (date.DateText.Length != 4)
            throw new ArgumentException("Can only change mask of DDMM or MMDD to YYYY");
        return CreateInstance(date.DateText, date.DateTime, DateFormat.yyyy);
    }
​
    public static InNameDate ChangeToMMDD(InNameDate date, DateFormat newMask)
    {
        if (date.DateText.Length != 4)
            throw new ArgumentException("Can only change mask of DDMM or YYYY to MMDD");
        return CreateInstance(date.DateText, date.DateTime, DateFormat.MMdd);
    }
​
    public static InNameDate ChangeToDDMM(InNameDate date, DateFormat newMask)
    {
        if (date.DateText.Length != 4)
            throw new ArgumentException("Can only change mask of MMDD or YYYY to DDMM");
        return CreateInstance(date.DateText, date.DateTime, DateFormat.ddMM);
    }
​
    public static InNameDate CreateInstance(string dateText, DateTime dateTime, DateFormat mask, CertaintyAboutElement certaintyAbout = CertaintyAboutElement.AbsolutelyCertain)
    {
        return new InNameDate(dateText, dateTime, mask, certaintyAbout);
    }
​
    /// <summary>
    /// Create Instance Infering Mask and Format for Date Parsing
    /// </summary>
    public static InNameDate CreateInstance(string dateToParse, CultureInfo cultureInfo, int? maxPossibleYear, bool forceDDMMorMMDD = false, int minPossibleYear = 1990)
    {
        //TODO: decide with several if(TryParse) witch format should be; 
        maxPossibleYear ??= GetCurrentYearPlus(3);
        var maskForDateParsing = string.Empty;
        DateTime parsedDate = DateTime.MinValue;
        var isDDMM = cultureInfo.Name == "pt-BR";
        var dateFormatToTest = DateFormat.NoDate;
        var degreeOfCertainty = CertaintyAboutElement.AbsolutelyCertain;
        if (dateToParse.IsNumber())
        {
            if (dateToParse.Length == DateFormat.sortable.GetDescription().Length) //yyyyMMddHHmmss
            {
                dateFormatToTest = DateFormat.sortable;
            }
            else if (dateToParse.Length == 8) //ddmmyyyy or mmddyyyy
            {
                dateFormatToTest = isDDMM ? DateFormat.ddMMyyyy : DateFormat.MMddyyyy;
            }
            else if (dateToParse.Length == 6) //MMyyyy 
            {
                dateFormatToTest = DateFormat.MMyyyy;
            }
            else if (dateToParse.Length == 4) //ddMM OR MMdd OR yyyy
            {
                var yyyyToTestIfWithinAllowedRange = DateTime.MinValue;
                var maybeDDMMorMMDD = DateTime.TryParseExact(dateToParse, DateFormat.ddMM.GetDescription(), cultureInfo, DateTimeStyles.None, out _) || DateTime.TryParseExact(dateToParse, DateFormat.MMdd.GetDescription(), cultureInfo, DateTimeStyles.None, out _);
                var maybeYYYY = DateTime.TryParseExact(dateToParse, DateFormat.yyyy.GetDescription(), cultureInfo, DateTimeStyles.None, out yyyyToTestIfWithinAllowedRange);
                if ((maybeDDMMorMMDD && !maybeYYYY) || forceDDMMorMMDD)
                    dateFormatToTest = isDDMM ? DateFormat.ddMM : DateFormat.MMdd;
                else if (!maybeDDMMorMMDD && maybeYYYY)
                    dateFormatToTest = DateFormat.yyyy;
                else if (maybeDDMMorMMDD && maybeYYYY)
                { //assume yyyy if possible ????
                    degreeOfCertainty = CertaintyAboutElement.InformedGuess;
                    if (yyyyToTestIfWithinAllowedRange >= new DateTime(minPossibleYear, 1, 1) && yyyyToTestIfWithinAllowedRange <= new DateTime(maxPossibleYear.Value, 1, 1))
                        //https://stackoverflow.com/questions/3871299/asp-net-c-sharp-parse-int-as-datetime
                        dateFormatToTest = DateFormat.yyyy;
                    else
                        dateFormatToTest = isDDMM ? DateFormat.ddMM : DateFormat.MMdd;
                }
                else if (maybeDDMMorMMDD && maybeYYYY)
                {
                    dateFormatToTest = DateFormat.NoDate;
                    degreeOfCertainty = CertaintyAboutElement.NonExisting;
                }
            }
            else if (dateToParse.Length == 2) //dd OR MM OR yy
            {
                throw new NotImplementedException("InferMaskAndFormatForDateParsing: dateToParse.Length == 2");
            }
​
            if (DateTime.TryParseExact(dateToParse, dateFormatToTest.GetDescription(), cultureInfo, DateTimeStyles.None, out parsedDate))
                return InNameDate.CreateInstance(dateToParse, parsedDate, dateFormatToTest, degreeOfCertainty);
        //return (dateFormatToTest.GetDescription(), dateFormatToTest, degreeOfCertainty);
        //[Description("dd/MM/yyyy HH:mm:ss")]
        //completeUpToSeconds,
        //[Description("MM/dd/yyyy HH:mm:ss")]
        //completeUpToSecondsUS,
        //[Description("yyyyMMddHHmmss")]
        //sortable,
        //[Description("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'")]
        //universalSortable             
        }
        else //if (!dateToParse.IsNumber()) MMM or MMMM or ddd or dd or tt
        {
        }
​
        return InNameDate.CreateInstance(dateToParse, parsedDate, dateFormatToTest, degreeOfCertainty);
    }
​
    internal static int GetCurrentYearPlus(int toAddCurrent) => DateTime.Now.Year + toAddCurrent;
#region Overrides of ValueObject
    protected override IEnumerable<object> GetEqualityComponents()
    {
        yield return DateText;
        yield return DateTime;
        yield return Mask;
        yield return CertaintyAbout;
    }
#endregion
}
​
// ###################            ##################################      InNameDate       ##################################            ###################
// ###################            ##################################      DateInSentence      ##################################            ###################
public static class DateInSentence
{
#region Public Constants
    public const string GrabDatesWithMonthsInLettersOrPureNumbersFromFile = @"(?<relationandinterval>(?<temporalrelation> em )?(?<=\W)(?<intervalordate>(?:\d{6,8}|\d{2,3}_{1,2})|(?:\b(0?[1-9]|[12][0-9]|3[01])*(?: de )?([JFMASONDjfmasond]([a-z0-9]+)([ç]{0,1})([a-z0-9]+)*)*(?: de )?(19|20)?[0-9]{2}\b)))";
    //https://regex101.com/r/ZuUZy3/9^^^^^^^^^^^^
    //https://stackoverflow.com/a/10033196/2752308 ^^^^^^ 
    public const string GrabDatesOrPureNumbersFromPartOfFile = @"(?<date>\d{6,8}|\d{2,3}_{1,2})";
    //https://regex101.com/r/DfGFk5/1   https://www.utctime.net/
    public const string GrabDatesUTC = @"(?<dateUTC>(?<year>-?(?:[1-9][0-9]*)?[0-9]{4})-(?<month>1[0-2]|0[1-9])-(?<day>3[01]|0[1-9]|[12][0-9])T(?<hour>2[0-3]|[01][0-9]):(?<minute>[0-5][0-9]):(?<second>[0-5][0-9])(\\.[0-9]+)?(?<zeroUTCoffse>Z)?|(?<year>(?:[1-9][0-9]*)?[0-9]{4})(?<month>1[0-2]|0[1-9])(?<day>3[01]|0[1-9]|[12][0-9])(?<hour>2[0-3]|[01][0-9])(?<minute>[0-5][0-9])(?<second>[0-5][0-9])(\\.[0-9]+)?(?<zeroUTCoffse>Z)?)";
    //Use it only to extract from PartOfName
    public const string GrabDateIntervalFromPartOfFile = @"(?<=\W)(?<interval>(?<starting>[ mçinícandouetr]+?)(?<datebegin>\d+)(?<link>[ eatéfimnldzou]+?)(?<=\W)(?<!\w-)(?<dateend>\d+))";
    //https://regex101.com/r/1UfbIM/1 ^^^^^^^^^^^^^^^^ 
    public const string GrabDateAndVersionDotAtEnd = @"(?<date>\d{6,8}|\d{2,3}_{1,2}) {1,2}(?<version>[vVersionão]+[\d@]+[\w@]*|[\d@]+[vVersionão]+[\w@]*).|(?<version>[vVersionão]+[\d@]+[\w@]*|[\d@]+[vVersionão]+[\w@]*) {1,2}(?<date>\d{6,8}|\d{2,3}_{1,2})\.|(?<date>\d{6,8}|\d{2,3}_{1,2})\.";
    //https://regex101.com/r/TpTA1n/2 ^^^^^^^^^^^^^^^^
    public const string WildCardForDate = "_";
#endregion Public Constants
    internal static Result<string> FilterAbsurdDates(Result<string> hasDate, CultureInfo cultureInfo, bool acceptWildCard = true, string errorMsg = "No date found", int numberOfYearsToConsiderAbsurd = 99)
    {
        if (hasDate.IsFailure)
            return hasDate;
        DateTime testDate = DateTime.MinValue;
        string dateWithoutSpace = string.Empty;
        if (hasDate.Value.DoesNotContainAnySpace())
        {
            dateWithoutSpace = hasDate.Value;
        }
        else
        {
            var dateCandidates = hasDate.Value.Split(' ');
            foreach (var element in dateCandidates)
            {
                if (element.Length > 3 && element.Length < 8)
                {
                    dateWithoutSpace = element;
                }
            }
        }
​
        if (DocNameHelper.DateTryParseExact(dateWithoutSpace, out testDate, cultureInfo))
        //if (DateTime.TryParseExact(dateWithoutSpace, "yyyy", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out testDate)     )
        {
            if (testDate.IsThisDateNullOrDefault())
                return Result.Failure<string>(errorMsg);
            if (Math.Abs(testDate.YearsBetweenNowAndDate()) >= numberOfYearsToConsiderAbsurd)
                return Result.Failure<string>($"Cannot allow set date so many years ({testDate.YearsBetweenNowAndDate()}) far from today");
            return Result.Success(dateWithoutSpace);
        //Console.WriteLine("DateTryParseExact SUCCESS: " + testDate);
        }
​
        if (dateWithoutSpace.Contains(WildCardForDate))
        {
            return acceptWildCard ? Result.Success(dateWithoutSpace) : Result.Failure<string>($"Because WildCardForDate is not allowed, this is an invalid date resulting in {testDate.ToString()}");
        }
​
        //Console.WriteLine("DateTryParseExact FAILURE: " + testDate);
        return Result.Failure<string>($"Invalid date resulting in {testDate.ToString()}");
    }
​
    private static bool InTimeRangeAllowed(int numberOfYearsToConsiderAbsurd, DateTime testDate)
    {
        try
        {
            var tested = Math.Abs(testDate.YearsBetweenNowAndDate());
            return tested < numberOfYearsToConsiderAbsurd;
        }
        catch (Exception)
        {
            return false;
        }
    }
​
    public static Result<string> GetDate(string partToTest, CultureInfo cultureInfo, (int start, int end) forbiddenZoneCoordinates, bool acceptWildCard = true)
    //public static Result<string> GetDate(string partToTest, DocNamePart partName, InNameGUID partHasGUID) 
    {
        if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest))
            return Result.Failure<string>("No date stamp in this file name");
        var hasDate = ReturnResult(GrabDatesUTC, partToTest, "dateUTC", "No date stamp in this file name", cultureInfo, forbiddenZoneCoordinates);
        //"No date stamp in this file name", partName, partHasGUID);
        if (hasDate.IsFailure)
        {
            hasDate = ReturnResult(GrabDatesOrPureNumbersFromPartOfFile, partToTest, "date", "No date stamp in this file name", cultureInfo, forbiddenZoneCoordinates);
        //"No date stamp in this file name", partName, partHasGUID);                
        }
​
        if (hasDate.IsFailure)
        {
            hasDate = ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "intervalordate", "No date stamp in this file name", cultureInfo, forbiddenZoneCoordinates);
        //"No date stamp in this file name", partName, partHasGUID);                
        }
​
        if (hasDate.IsSuccess)
        {
            hasDate = FilterAbsurdDates(hasDate, cultureInfo, acceptWildCard, "No date stamp in this file name");
        }
​
        return hasDate;
    }
​
    public static Result<string> ReturnResult(string pattern, string part, string groupName, string errorMsg, CultureInfo cultureInfo, (int start, int end) forbiddenZoneCoordinates)
    {
        Result<string> result;
        var match = DocNameHelper.GetMatch(pattern, part, groupName, errorMsg, out result);
        if (!result.IsFailure && DocNameHelper.OutOfForbiddenZoneIfSamePart(groupName, match, forbiddenZoneCoordinates.start, forbiddenZoneCoordinates.end))
            return result;
        //https://stackoverflow.com/questions/38948394/datetime-tryparse-fails-at-yyyy-only
        if (DocNameHelper.DateTryParseExact(part, out var testDate, cultureInfo))
            result = !testDate.IsThisDateNullOrDefault() ? Result.Success(part) : Result.Failure<string>(errorMsg);
        return result;
    }
}
​
// ###################            ##################################      DateInSentence      ##################################            ###################
// ###################            ##################################      IntervalInSentence      ##################################            ###################
public static class IntervalInSentence
{
#region Public Constants
    public const string GrabDatesWithMonthsInLettersOrPureNumbersFromFile = @"(?<relationandinterval>(?<temporalrelation> em )?(?<=\W)(?<intervalordate>(?:\d{6,8}|\d{2,3}_{1,2})|(?:\b(0?[1-9]|[12][0-9]|3[01])*(?: de )?([JFMASONDjfmasond]([a-z0-9]+)([ç]{0,1})([a-z0-9]+)*)*(?: de )?(19|20)?[0-9]{2}\b)))";
    //https://regex101.com/r/ZuUZy3/9^^^^^^^^^^^^
    //https://stackoverflow.com/a/10033196/2752308 ^^^^^^ 
    //Use it only to extract from PartOfName
    public const string GrabDateIntervalFromPartOfFile = @"(?<=\W)(?<interval>(?<starting>[ mçinícandouetr]+?)(?<datebegin>\d+)(?<link>[ eatéfimnldzou]+?)(?<=\W)(?<!\w-)(?<dateend>\d+))";
    //https://regex101.com/r/1UfbIM/1 ^^^^^^^^^^^^^^^^ 
#endregion Public Constants
    public static Result<string> GetInterval(string partToTest, InNameGUID partHasGUID)
    //public static Result<string> GetInterval(string partToTest, DocNamePart partName, InNameGUID partHasGUID) 
    {
        var errorMsg = "No interval date stamp in this file name";
        if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest))
            return Result.Failure<string>(errorMsg);
        var hasInterval = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "interval", errorMsg);
        if (hasInterval.IsSuccess)
        {
            //var year 
            return IsIntervalValid(partToTest, errorMsg) ? hasInterval : Result.Failure<string>(errorMsg);
        }
​
        //"No interval date stamp in this file name", partName, partHasGUID);           
        if (hasInterval.IsFailure)
        {
            var match = DocNameHelper.GetMatch(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "relationandinterval", errorMsg, out var result);
            hasInterval = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "intervalordate", errorMsg);
            if (result.Equals(hasInterval))
                return Result.Failure<string>(errorMsg);
        }
​
        return hasInterval;
    }
​
    internal static bool IsIntervalValid(string partToTest, string errorMsg)
    {
        var(dateBegin, dateEnd) = GetIntervalDates(partToTest, errorMsg);
        //BUG very tough to predict all dd-mm possibilities and tell them from only yyyy
        // example de 1208 a 2009 is one in which EndDate maybe dd-mm or yyyy, but not the first
        // but how can I tell de 2107 a 2009 ??? comparing as dd-mm, interval is valid, but as yyyy, it is not valid
        // maybe assuming certain yyyy are valids, but I do not know for sure
        var validBeginInterval = DocNameHelper.DateTryParseExact(dateBegin.Value, out var beginInterval, CultureInfo.CurrentCulture);
        var validEndInterval = DocNameHelper.DateTryParseExact(dateEnd.Value, out var endInterval, CultureInfo.CurrentCulture);
        var isValid = beginInterval < endInterval;
        return isValid;
    }
​
    internal static (Result<string> dateBegin, Result<string> dateEnd) GetIntervalDates(string partToTest, string errorMsg)
    {
        var dateEnd = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "dateend", errorMsg);
        var dateBegin = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "datebegin", errorMsg);
        return (dateBegin, dateEnd);
    }
}
​
// ###################            ##################################      IntervalInSentence      ##################################            ###################
// ###################            ##################################      InNameGUID       ##################################            ###################
public class InNameGUID : ValueObject
{
    private const string Grab_GUID_treated = @"(?<GUID>[0-9a-f]{8}<>[0-9a-f]{4}<>[0-9a-f]{4}<>[0-9a-f]{4}<>[0-9a-f]{12})";
    private InNameGUID(int start, int end, DocNamePart part, string guid)
    {
        Start = start;
        End = end;
        Part = part;
        GUID = guid;
    }
​
    public static InNameGUID CreateInstance(int start, int end, DocNamePart part, string guid)
    {
        return new InNameGUID(start, end, part, guid);
    }
​
    public bool NoGUID => string.IsNullOrEmpty(GUID);
    public static InNameGUID NullGUID() => new(-1, -1, DocNamePart.NoPart, string.Empty);
    public static InNameGUID GetGUID(string part, DocNamePart namePart)
    {
        var rgx = new Regex(Grab_GUID_treated);
        var match = rgx.Match(part);
        //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
        //BUG end is not end; end is Length...and length of treated GUID, with <> instead of -
        var result = match.Success ? CreateInstance(match.Groups["GUID"].Index, match.Groups["GUID"].Length - 1, namePart, match.Groups["GUID"].Value) : NullGUID();
        //      1   2           
        //  0   1   2   3   4   5
        //? Result.Success(match.Groups["GUID"].Value.Trim())
        //: Result.Failure<string>("No GUID in this part");
        return result;
    }
​
    public int Start { get; private set; }
​
    public int End { get; private set; }
​
    public DocNamePart Part { get; private set; }
​
    public string GUID { get; private set; }
​
    protected override IEnumerable<object> GetEqualityComponents()
    {
        yield return Part;
        yield return End;
        yield return Start;
        yield return GUID;
        yield return NoGUID;
    }
}
​
// ###################            ##################################      InNameGUID       ##################################            ###################
// ###################            ##################################      DateTimeExtensions      ##################################            ###################
public static partial class DateTimeExtensions
{
    public static int YearsBetweenNowAndDate(this DateTime @this) => Math.Abs(DateTime.Now.HowOld(@this, out _, out _));
    public static int YearsBetweenDates(this DateTime @this, DateTime that) => Math.Abs(that.HowOld(@this, out _, out _));
    public static int HowOld(this DateTime initialDay, DateTime dayToCalculate, out int days, out int months)
    {
        //https://stackoverflow.com/a/3055445/2752308
        //LukeH: essentially right
        months = dayToCalculate.Month - initialDay.Month;
        int years = dayToCalculate.Year - initialDay.Year;
        if (dayToCalculate.Day < initialDay.Day)
        {
            months--;
        }
​
        if (months < 0)
        {
            years--;
            months += 12;
        }
​
        days = (dayToCalculate - initialDay.AddMonths((years * 12) + months)).Days;
        //Console.WriteLine(
        //  $@"{years} year{((years == 1) ? "" : "s")}, {months} month{((months == 1) ? "" : "s")} and {days} day{((days == 1) ? "" : "s")}");
        return years;
    }
​
    public static string HowYearsOldToday(this DateTime birthday, bool allowNegativeAge = false)
    {
        var howManyYears = birthday.HowOld(DateTime.Now, out var howManyDays, out var howManyMonths);
        if (allowNegativeAge || howManyYears >= 0)
            return $"{howManyYears} ano{((howManyYears == 1) ? "" : "s")}";
        return "Cannot calculate age";
    }
​
    public static string HowYearsOldAtDate(this DateTime birthday, DateTime atDate, bool allowNegativeAge = false)
    {
        var howManyYears = birthday.HowOld(atDate, out var howManyDays, out var howManyMonths);
        if (allowNegativeAge || howManyYears >= 0)
            return $"{howManyYears} ano{((howManyYears == 1) ? "" : "s")}";
        return "Cannot calculate age";
    }
​
    public static string HowYearsMonthsOldToday(this DateTime birthday, bool allowNegativeAge = false)
    {
        var howManyYears = birthday.HowOld(DateTime.Now, out var howManyDays, out var howManyMonths);
        if (allowNegativeAge || howManyYears >= 0)
            return $"{howManyYears} ano{((howManyYears == 1) ? "" : "s")}" + $", {howManyMonths} {((howManyMonths == 1) ? "mês" : "meses")} ";
        return "Cannot calculate age";
    }
​
    public static string HowYearsMonthsOldAtDate(this DateTime birthday, DateTime atDate, bool allowNegativeAge = false)
    {
        var howManyYears = birthday.HowOld(atDate, out var howManyDays, out var howManyMonths);
        if (allowNegativeAge || howManyYears >= 0)
            return $"{howManyYears} ano{((howManyYears == 1) ? "" : "s")}" + $", {howManyMonths} {((howManyMonths == 1) ? "mês" : "meses")} ";
        return "Cannot calculate age";
    }
​
    public static string HowYearsMonthsDaysOldToday(this DateTime birthday, bool allowNegativeAge = false)
    {
        var howManyYears = birthday.HowOld(DateTime.Now, out var howManyDays, out var howManyMonths);
        if (allowNegativeAge || howManyYears >= 0)
            return $"{howManyYears} ano{((howManyYears == 1) ? "" : "s")}" + $", {howManyMonths} {((howManyMonths == 1) ? "mês" : "meses")} " + $"e {howManyDays} dia{((howManyDays == 1) ? "" : "s")}";
        return "Cannot calculate age";
    }
​
    public static string HowYearsMonthsDaysOldAtDatey(this DateTime birthday, DateTime atDate, bool allowNegativeAge = false)
    {
        var howManyYears = birthday.HowOld(atDate, out var howManyDays, out var howManyMonths);
        if (allowNegativeAge || howManyYears >= 0)
            return $"{howManyYears} ano{((howManyYears == 1) ? "" : "s")}" + $", {howManyMonths} {((howManyMonths == 1) ? "mês" : "meses")} " + $"e {howManyDays} dia{((howManyDays == 1) ? "" : "s")}";
        return "Cannot calculate age";
    }
​
    public static DateTime MinimumWinFormDateTime(this DateTime @this) => Convert.ToDateTime("1/1/1753 00:00:00"); // ApplicationServices.GetMinDateTime();
    public static DateTime NullOutlookDateTime(this DateTime @this) => Convert.ToDateTime("1/1/4501 00:00:00"); // ApplicationServices.OutlookNullDate;
    public static DateTime OutlookDefaultDateForInvalidEntry(this DateTime @this) => Convert.ToDateTime("30/12/1899 00:00:00"); // ApplicationServices.OutlookDefaultDateForInvalid;
    public static DateTime OutlookEarliestDateThatDoesNotProvokeError(this DateTime @this) => Convert.ToDateTime("01/04/1601 00:00:00"); // ApplicationServices.OutlookEarliestDateThatDoesntProvokeError;
    public static DateTime ThisDateOrAppropriateMinimalDateTime(this DateTime @this) => (DateTime)(@this < @this.MinimumWinFormDateTime() || @this == NullOutlookDateTime(@this) ? @this.MinimumWinFormDateTime() : @this);
    public static bool IsThisDateNullOrDefault(this DateTime @this) => @this == @this.MinimumWinFormDateTime() || @this == NullOutlookDateTime(@this) || @this == DateTime.MaxValue || @this == DateTime.MinValue || @this == @this.OutlookDefaultDateForInvalidEntry() || @this < @this.OutlookEarliestDateThatDoesNotProvokeError();
    public static DateTime ThisDateCandidateOrDateTimeMinimal(this string stringToBeParsed)
    {
        DateTime @this = default;
        if (stringToBeParsed == null || !DateTime.TryParse(stringToBeParsed, out @this))
            return DateTime.MinValue;
        return @this;
    }
​
    public static DateTime ThisDateCandidateOrAppropriateMinimalDateTime(this string stringToBeParsed)
    {
        DateTime @this = default;
        if (stringToBeParsed == null || !DateTime.TryParse(stringToBeParsed, out @this))
            return @this.MinimumWinFormDateTime();
        return (DateTime)(@this < @this.MinimumWinFormDateTime() || @this == NullOutlookDateTime(@this) ? @this.MinimumWinFormDateTime() : @this);
    }
​
    /// <summary>
    /// Return the older or the ancient of two dates
    /// </summary>
    /// <param name = "d1"></param>
    /// <param name = "d2"></param>
    /// <returns></returns>
    public static DateTime ReturnAnteriorBetweenDates(this DateTime d1, DateTime d2) => d1 < d2 ? d1 : d2;
    /// <summary>
    /// Return the most near Now() date
    /// </summary>
    /// <param name = "d1"></param>
    /// <param name = "d2"></param>
    /// <returns></returns>
    public static DateTime ReturnPosteriorBetweenDates(this DateTime d1, DateTime d2) => d1 < d2 ? d1 : d2;
    public static DateTime AllowPastOrNowTimeButNotFuture(this DateTime? ToTest, DateTime? ToCompare = null)
    {
        if (ToCompare == null)
        {
            ToCompare = DateTime.Now;
        }
​
        return ToTest switch
        {
            var value when value == null => DateTime.Now,
            var value when value < ToCompare => (DateTime)ToTest,
            var value when value > ToCompare => throw new ArgumentOutOfRangeException("Date cannot be in the future..."),
            _ => default,
        };
    }
​
    public static DateTime AllowOnlyFuture(this DateTime? ToTest, double numberOfHoursToAdd = 1, DateTime? ToCompare = null)
    {
        if (ToCompare == null)
        {
            ToCompare = DateTime.Now;
        }
​
        return ToTest switch
        {
            var value when value == null => DateTime.Now.AddHours(numberOfHoursToAdd),
            var value when value > ToCompare => (DateTime)ToTest,
            var value when value < ToCompare => throw new ArgumentOutOfRangeException("Date cannot be in the past or even now..."),
            _ => default,
        };
    //var timeOnlyInFuture = DateTime.MaxValue;
    //switch (ToTest)
    //{
    //    case var value when value == null:
    //        timeOnlyInFuture = DateTime.Now.AddHours(numberOfHoursToAdd);
    //        break;
    //    case var value when value > ToCompare:
    //        timeOnlyInFuture = (DateTime)ToTest;
    //        break;
    //    case var value when value < ToCompare:
    //        throw new ArgumentOutOfRangeException("Date cannot be in the past or even now...");
    //    default:
    //        break;                    
    //}
    //return timeOnlyInFuture;
    }
}
​
// ###################            ##################################      DateTimeExtensions      ##################################            ###################
// ###################            ##################################      StringTextExtensions      ##################################            ###################
public static class StringTextExtensions
{
    private const char OneBlankSpace = ' ';
    public static string RemoveUnnecessarySpaces(this string textToTrim)
    {
        return Regex.Replace(textToTrim, @"\s+", " ").Trim();
    }
​
    public static string RemoveAllSpaces(this string textToTrim)
    {
        return textToTrim.Replace(" ", string.Empty);
    }
​
    public static string RemoveAllPunctuation(this string textToTrim)
    {
        //https://stackoverflow.com/questions/421616/how-can-i-strip-punctuation-from-a-string
        return new string (textToTrim.Where(c => !char.IsPunctuation(c)).Where(c => !char.IsSymbol(c)).ToArray());
    //return Regex.Replace(textToTrim, @"[a-zA-ZçÇ à-úÀ-Ú]+", string.Empty).Trim();
    //return Regex.Replace(textToTrim, @"\p{P}+", string.Empty).Trim();
    //^^^^^cuidado! @"\p{P}+" ou "\\p{P}+": nunca @"\\p{P}+"
    }
​
    public static string GetRidOfNonLetterCharsInKeyOrPairElements(this string rawString) => rawString.RemoveAllPunctuation().RemoveAllSpaces().RemoveBrackets();
    public static string GetNumberOfCharsJustBeforeSubstring(this string text, string beforeThis, int numberOfChars = 1)
    {
        try
        {
            var txtBefore = text.GetUntilOrEmpty(beforeThis);
            return text.GetUntilOrEmpty(beforeThis).Substring(txtBefore.Length - numberOfChars);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
            return string.Empty;
        }
    }
​
    public static string GetUntilOrEmpty(this string text, string stopAt = "-")
    {
        if (!string.IsNullOrWhiteSpace(text))
        {
            int charLocation = text.IndexOf(stopAt, StringComparison.Ordinal);
            if (charLocation > 0)
            {
                return text.Substring(0, charLocation);
            }
        }
​
        return string.Empty;
    }
​
    public static string GetAfterOrEmpty(this string text, string stopAt = "-")
    {
        if (!string.IsNullOrWhiteSpace(text))
        {
            int charLocation = text.IndexOf(stopAt, StringComparison.Ordinal);
            if (charLocation > 0)
            {
                return text.Substring(charLocation + stopAt.Length, text.Length - charLocation - stopAt.Length);
            }
        }
​
        return string.Empty;
    }
​
    public static string GetMiddleString(this string inputString, char separator = OneBlankSpace)
    {
        //this is assuming that your tokens only happens one time in the string
        //https://stackoverflow.com/questions/2449561/retrieve-string-from-the-middle-of-a-string
        var input = inputString.Split(separator);
        var firstToken = input[0];
        var lastToken = input[input.Length - 1];
        var pos1 = inputString.IndexOf(firstToken) + firstToken.Length;
        var pos2 = inputString.IndexOf(lastToken);
        var result = inputString.Substring(pos1, pos2 - pos1).Trim() ?? string.Empty;
        return result;
    }
​
    public static (string textBefore, string textAfter) GetTextBeforeAndAfterSubstring(this string textToExtract, string stringToSearchFor, int desiredLengthToCut, int indexToSearchedString)
    {
        //var indexToSearchedString = textToExtract.IndexOf(stringToSearchFor, StringComparison.Ordinal);
        var textBefore = textToExtract.Substring(indexToSearchedString - desiredLengthToCut < 0 ? 0 : indexToSearchedString - desiredLengthToCut, indexToSearchedString - desiredLengthToCut > 0 ? desiredLengthToCut : indexToSearchedString);
        var textAfter = textToExtract.Substring(indexToSearchedString + stringToSearchFor.Length, DecideHowMuchItCanCutAfter(textToExtract.Length, indexToSearchedString + stringToSearchFor.Length, desiredLengthToCut));
        return (textBefore, textAfter);
        static int DecideHowMuchItCanCutAfter(int totalLength, int beginCut, int lengthToCut)
        {
            if (beginCut + lengthToCut < totalLength)
                return lengthToCut;
            if (beginCut + lengthToCut >= totalLength)
                return totalLength - beginCut;
            return 0;
        }
    }
​
    public static string RemoveDiacritics(this string s)
    {
        string normalizedString = s.Normalize(NormalizationForm.FormD);
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < normalizedString.Length; i++)
        {
            char c = normalizedString[i];
            if (CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
                stringBuilder.Append(c);
        }
​
        return stringBuilder.ToString();
    }
​
    public static string RemoveBrackets(this string s)
    {
        return s.Replace("[", string.Empty).Replace("]", string.Empty);
    }
​
    public static string SurroundWithDoubleQuotes(this string text)
    {
        return SurroundWith(text, "\"");
    }
​
    public static string SurroundWith(this string text, string ends)
    {
        return ends + text + ends;
    }
​
    public static string EscapeSingleQuote(this string text)
    {
        return text.Replace("'", @"\'");
    }
​
    public static string AddSingleQuoteAsEscapeCharacter(this string text)
    {
        //https://docs.microsoft.com/pt-br/dotnet/api/microsoft.office.interop.outlook._items.find?view=outlook-pia
        return text.Replace("'", @"''");
    }
​
    public static string EnsureOneSingleSpaceAtBegin(this string text)
    {
        return OneBlankSpace + text.TrimStart();
    }
​
    public static string CapitalizeFirstLetter(this string value)
    {
        //In Case if the entire string is in UpperCase then convert it into lower
        value = value.ToLower();
        char[] array = value.ToCharArray();
        // Handle the first letter in the string.
        if (array.Length >= 1)
        {
            if (char.IsLower(array[0]))
            {
                array[0] = char.ToUpper(array[0]);
            }
        }
​
        // Scan through the letters, checking for spaces.
        // ... Uppercase the lowercase letters following spaces.
        for (int i = 1; i < array.Length; i++)
        {
            if (array[i - 1] == ' ')
            {
                if (char.IsLower(array[i]))
                {
                    array[i] = char.ToUpper(array[i]);
                }
            }
        }
​
        return new string (array);
    }
​
    /// <summary>
    /// Split a string on each occurrence of a capital (assumed to be a word)
    /// e.g. MyBigToe returns "My Big Toe"
    /// </summary>
    public static string SplitCapitalizedWords(this string source)
    {
        if (String.IsNullOrEmpty(source))
            return String.Empty;
        var newText = new StringBuilder(source.Length * 2);
        newText.Append(source[0]);
        for (int i = 1; i < source.Length; i++)
        {
            if (char.IsUpper(source[i]))
                newText.Append(' ');
            newText.Append(source[i]);
        }
​
        return newText.ToString();
    }
​
    /// <summary>
    /// https://stackoverflow.com/questions/6865419/indexof-for-multiple-results
    /// https://stackoverflow.com/questions/15993357/how-to-get-all-indexof-instances-of-string-in-another-string-c-sharp
    /// </summary>
    /// <param name = "str"></param>
    /// <param name = "searchString"></param>
    /// <returns></returns>
    public static IEnumerable<int> AllIndexesOf(this string str, string searchString)
    {
        int minIndex = str.IndexOf(searchString, StringComparison.Ordinal);
        while (minIndex != -1)
        {
            yield return minIndex;
            minIndex = str.IndexOf(searchString, minIndex + searchString.Length, StringComparison.Ordinal);
        }
    }
​
    /// <summary>
    ///     A string extension method that query if '@this' contains any values.
    /// </summary>
    /// <param name = "this">The @this to act on.</param>
    /// <param name = "values">A variable-length parameters list containing values.</param>
    /// <returns>true if it contains any values, otherwise false.</returns>
    public static bool ContainsAny(this string @this, params string[] values)
    {
        foreach (string value in values)
        {
            if (@this.IndexOf(value) != -1)
            {
                return true;
            }
        }
​
        return false;
    }
​
    /// <summary>
    ///     A string extension method that query if '@this' contains any values.
    /// </summary>
    /// <param name = "this">The @this to act on.</param>
    /// <param name = "comparisonType">Type of the comparison.</param>
    /// <param name = "values">A variable-length parameters list containing values.</param>
    /// <returns>true if it contains any values, otherwise false.</returns>
    public static bool ContainsAny(this string @this, StringComparison comparisonType, params string[] values)
    {
        foreach (string value in values)
        {
            if (@this.IndexOf(value, comparisonType) != -1)
            {
                return true;
            }
        }
​
        return false;
    }
​
    public static bool DoesNotContainAnySpace(this string @this) => !@this.Any(char.IsWhiteSpace);
    //https://stackoverflow.com/questions/3293295/string-contains-only-a-given-set-of-characters
    public static bool ContainsOnly(this string @this, string allowedChars) => @this.All(allowedChars.Contains);
    public static bool StringHasOnlyNumbers(this string @this) => @this.ReturnOnlyNumbers().Length == @this.Length;
    //https://stackoverflow.com/questions/4734116/find-and-extract-a-number-from-a-string   
    public static List<string> ReturnOnlyInvalidChars(this string @this, string allowedChars) => (
        from c in @this
        where !allowedChars.Contains(c.ToString())select c.ToString()).ToList();
    //https://stackoverflow.com/questions/4734116/find-and-extract-a-number-from-a-string
    public static string ReturnOnlyNumbers(this string @this) => new(@this.Where(char.IsDigit).ToArray());
    public static int? ReturnOnlyNumbersAsInt(this string @this)
    {
        int.TryParse(@this.ReturnOnlyNumbers(), out var result);
        return result;
    }
​
    public static string ReturnOnlyNonNumericCharacters(this string @this) => Regex.Replace(@this, @"[\d-]", string.Empty);
    /// <summary>
    /// https://stackoverflow.com/a/10042595/2752308
    /// </summary>
    /// <param name = "this"></param>
    /// <returns></returns>
    public static int[] ReturnOnlyNumbersToArray(this string @this) => Regex.Matches(@this, "(-?[0-9]+)").OfType<Match>().Select(m => int.Parse(m.Value)).ToArray();
    public static int GetSingleDigitAtPositionInFilteredStrOnlyNumbers(this string @this, int position1Based)
    {
        if (position1Based < 1 || position1Based > @this.Length - 1)
        {
            throw new ArgumentOutOfRangeException(nameof(position1Based), $"{nameof(position1Based)} cannot be outer of string limits");
        }
​
        return int.Parse(@this.ReturnOnlyNumbers()[position1Based - 1].ToString());
    }
​
    public static string FormatPhoneNumber(this long number, string mask) => number.ToString(mask);
    //https://pt.stackoverflow.com/questions/283609/formatar-uma-string-para-formato-de-telefone
    public static string FormatPhoneNumber(this string number)
    {
        var mask = number.ReturnOnlyNumbers().Length switch
        {
            15 => @"0 000 (00) 00000-0000",
            13 => @"+00 (00) 00000-0000",
            11 => @"(00) 00000-0000",
            10 => @"(00) 0000-0000",
            _ => throw new ArgumentOutOfRangeException(nameof(FormatPhoneNumber), "FormatPhoneNumber only accepts certain ranges of phone numbers"),
        };
        //var mask = string.Empty;
        //switch (number.ReturnOnlyNumbers().Length)
        //{
        //    case 15:
        //        mask = @"0 000 (00) 00000-0000";
        //        break;
        //    case 13:
        //        mask = @"+00 (00) 00000-0000";
        //        break;
        //    case 11:
        //        mask = @"(00) 00000-0000";
        //        break;
        //    case 10:
        //        mask = @"(00) 0000-0000";
        //        break;
        //    default:
        //        throw new ArgumentOutOfRangeException(nameof(FormatPhoneNumber), "FormatPhoneNumber only accepts certain ranges of phone numbers");        
        //}
        return long.Parse(number.ReturnOnlyNumbers()).FormatPhoneNumber(mask);
    }
​
    public static bool IsDate(this string @this, out DateTime date) => DateTime.TryParse(@this, out date);
    public static bool IsDate(this string @this) => DateTime.TryParse(@this, out var date);
    public static bool IsNumber(this string @this) => int.TryParse(@this, out var number);
    public static string ReturnParentFolder(this string pathSource)
    {
        //https://stackoverflow.com/a/30902714/2752308
        return Path.GetFullPath(Path.Combine(pathSource, @"..\"));
    }
​
    /// <summary>
    /// Extension to use with Root path, adding distal path as argument
    /// </summary>
    /// <param name = "pathWithRoot"></param>
    /// <param name = "pathDistal"></param>
    /// <returns></returns>
    public static string CombinePaths(this string pathWithRoot, string pathDistal)
    {
        var networkFolder = !pathWithRoot.Contains(":");
        var pathOne = pathWithRoot.Split(@"\".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
        var pathTwo = pathDistal.Split(@"\".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
        var pathFinal = pathOne.Concat(pathTwo);
        var preFinalPath = Path.Combine(pathFinal.ToArray());
        if (networkFolder)
            return "\\\\" + preFinalPath;
        return preFinalPath.Contains(":\\") ? preFinalPath : preFinalPath.Replace(":", ":\\");
    }
}
​
// ###################            ##################################      StringTextExtensions      ##################################            ###################
// ###################            ##################################      ObjectTextExtensions      ##################################            ###################
public static class ObjectTextExtensions
{
    public static T ObjToEnum<T>(this object o, int unknown = 0)
    {
        try
        {
            if (o != null)
            {
                T enumVal = (T)Enum.Parse(typeof(T), o.ToString());
                return enumVal;
            }
        }
        catch (Exception)
        {
            return (T)Enum.ToObject(typeof(T), unknown);
        }
​
        return (T)Enum.ToObject(typeof(T), unknown); //0 é o valor que estou dando para todos os enum Desconhecidos
    }
​
    //        public static T LookupItemExToEnum<T>(this object o, int unknown = 0)
    //        {
    //        }
    /// <summary>
    /// Returns true if Enum value exists
    /// </summary>
    /// <param name = "value"></param>
    /// <returns></returns>
    public static bool IsDefined(this System.Enum value)
    {
        return Enum.IsDefined(value.GetType(), value);
    }
​
    //       public static LookupItemEx EnumTo<TValue>(this TValue value) where TValue : System.Enum =>
    //            LookupItemEx.Create(value.EnumToInt(), value.ToString(), value.GetDescription());
    public static int EnumToInt<TValue>(this TValue value)
        where TValue : System.Enum => (int)(object)value;
    public static TValue IntToEnum<TValue>(this int value)
        where TValue : System.Enum => (TValue)(object)value;
    //=> (TValue)Convert.ChangeType(value, typeof(TValue));
    //(T)Convert.ChangeType(Email.FromString("m", WhichContactType.PERSONAL), typeof(T)), 
    public static T GetEnumValue<T>(this string value)
        where T : struct
    {
        Type t = typeof(T);
        if (!t.IsEnum)
            throw new Exception("T must be an enum");
        else
        {
            if (Enum.IsDefined(t, value))
                return (T)Enum.Parse(t, value);
            else
                return default(T);
        }
    }
​
    //https://stackoverflow.com/questions/483794/convert-enum-to-string/17034624#17034624
    public static T GetValueFromDescription<T>(this string description, bool throwException = true)
        where T : Enum
    {
        //https://stackoverflow.com/questions/4367723/get-enum-from-description-attribute
        foreach (var field in typeof(T).GetFields())
        {
            if (Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute))is DescriptionAttribute attribute)
            {
                if (attribute.Description == description)
                    return (T)field.GetValue(null);
            }
            else
            {
                if (field.Name == description)
                    return (T)field.GetValue(null);
            }
        }
​
        if (throwException)
        {
            throw new ArgumentException("Not found.", nameof(description));
        }
​
        return default(T);
    }
​
    public static string GetDescription(this Enum value)
    {
        //https://stackoverflow.com/questions/4367723/get-enum-from-description-attribute
        //https://stackoverflow.com/a/479417/2752308
        FieldInfo field = value.GetType().GetField(value.ToString());
        DescriptionAttribute attribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;
        return attribute == null ? value.ToString() : attribute.Description;
    }
​
    public static string GetDescription(this object e, Type enumType)
    {
        //var fields = Enum.GetValues(enumType).Cast<object>();
        //var fieldsName =
        //from o in fields
        //    where o.ToString() == e.ToString()
        //        select o.ToString();
        //var fieldValue = enumType.GetField(fieldsName.FirstOrDefault()).ToString();
        var fieldValue = enumType.GetField(Enum.GetValues(enumType).Cast<object>().Where(o => o.ToString() == e.ToString()).Select(o => o.ToString()).FirstOrDefault()).ToString();
        FieldInfo field = enumType.GetField(fieldValue.Contains(" ") ? fieldValue.Split().Last() : fieldValue);
        DescriptionAttribute attribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;
        return attribute == null ? e.ToString() : attribute.Description;
    }
​
    /// <summary>
    /// De um valor apenas, pega o Dictionary; meio estranho
    /// </summary>
    /// <typeparam name = "TValue"></typeparam>
    /// <param name = "value"></param>
    /// <returns></returns>
    public static Dictionary<int, TValue> EnumToDictionary<TValue>(this TValue value)
        where TValue : System.Enum
    {
        Type enumType = typeof(TValue);
        var allEnumValues = enumType.GetEnumValues().Cast<TValue>();
        var enumDL = new Dictionary<int, TValue>();
        foreach (TValue val in allEnumValues.ToList())
        {
            enumDL.Add(val.EnumToInt(), val);
        }
​
        return enumDL;
    }
​
    public static Dictionary<int, Enum> EnumToDictionaryNotGeneric(this Enum @enum)
    //where T : struct, Enum
    {
        Type enumType = @enum.GetType(); //typeof(@enum);
        var allEnumValues = Enum.GetValues(@enum.GetType()).Cast<Enum>();
        var enumDL = new Dictionary<int, Enum>();
        foreach (var val in allEnumValues.ToList())
        {
            enumDL.Add(val.EnumToInt(), val);
        }
​
        return enumDL;
    }
​
    /// <summary>
    /// Pega o Dictionary; a assinatura é muito estranha
    /// </summary>
    /// <typeparam name = "T"></typeparam>
    /// <returns></returns>
    public static Dictionary<int, T> EnumToDictionary<T>(this Type enumType)
        where T : Enum
    {
        //Type enumType = typeof(T);
        //var allEnumDescriptions = enumType.GetEnumNames();
        //non-generic equivalent:          ^^^^^^^^^^ Enum.GetValues<WhichGender>()
        var allEnumValues = enumType.GetEnumValues().Cast<T>();
        var converter = new EnumConverter(enumType);
        // Can't use generic type constraints on value types,
        // so have to do check like this
        //if (enumType.BaseType != typeof(Enum))
        //    throw new ArgumentException("T must be of type System.Enum");
        var enumDL = new Dictionary<int, T>();
        foreach (T val in allEnumValues.ToList())
        {
            enumDL.Add(val.EnumToInt(), val);
        }
​
        return enumDL;
    }
​
    //https://stackoverflow.com/a/972323/2752308
    public static IReadOnlyList<T> GetValues<T>()
    {
        return (T[])Enum.GetValues(typeof(T));
    }
/// <summary>
/// https://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum
/// Only after 7.3
/// see too: https://stackoverflow.com/questions/5005931/listing-values-within-enums-using-reflection-in-c-sharp
/// Use this instead of EnumPatient.GetAllValues()
/// </summary>
/// <returns></returns>
 //        public static Dictionary<int, string> GetAllValuesByEnumType(this EnumPatient.Enums whichType)
//        {
//        }
}// ###################            ##################################      ObjectTextExtensions      ##################################            ###################
​

View IL Code