DocNameAnalyzer with strong type string Value CSF 2.40 | C# Online Compiler

DocNameAnalyzer with strong type string Value CSF 2.40 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;
using System.Diagnostics;

//using PatientManagerMD.ResourceCentral.ExtensionMethods;
//using PatientManagerMD.ResourceCentral.Support;
//using System.Collections.Generic;
//using System.Linq;
//using Microsoft.Toolkit.Uwp.Notifications;
public class Program
{
	public static void Main()
	{
		//Console.WriteLine("Hello World");
		// Set the current culture
		//var culture = new CultureInfo("pt-BR"); //("en-US");		
		var culture = new CultureInfo("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}");
		Console.WriteLine("------------------------------------------------------------------------------------");
		CultureInfo.CurrentCulture = culture;		
		CanCreate_DocNameElementsMount();
	}

	public static void CanCreate_DocNameElementsMount()
	{
var nameToParse = "US abdominal-cisto hepático_5f9a739a-0b2e-4fcc-9228-81035e6e50ea da internação de 2803 até 03062022 - 23122022 v3.docx";
	var docElements = new List<ElementDescription>();
	//"------------------------------------------------------------------------------------"
	var elementGuid = InNameGUID.CreateInstance(nameToParse, DocNamePart.Middle);
	docElements.Add(ElementDescription.CreateInstance(elementGuid, DocNamePart.Middle, ElementRelativePosition.First, -1));
	nameToParse = nameToParse.Replace(elementGuid.GUID, string.Empty);
	//"------------------------------------------------------------------------------------"
	var elementVer = VersionInSentence.CreateInstance(nameToParse); //"Junk before v2");
	docElements.Add(ElementDescription.CreateInstance(elementVer, DocNamePart.Last, ElementRelativePosition.First, -1));
	nameToParse = nameToParse.Replace(elementVer.Version, string.Empty);
	//"------------------------------------------------------------------------------------"
	var cultureInfo = new CultureInfo("pt-BR");
	var elementInt = IntervalInSentence.CreateInstance(nameToParse /*"de 2804 até 03052022"*/, cultureInfo);
	docElements.Add(ElementDescription.CreateInstance(elementInt, DocNamePart.Middle, ElementRelativePosition.Last, -1));
	nameToParse = nameToParse.Replace(elementInt.Interval.Value, string.Empty);
	//"------------------------------------------------------------------------------------"
	var elementDate = DateInSentence.CreateInstance(nameToParse /*"052022"*/, cultureInfo, null);
	docElements.Add(ElementDescription.CreateInstance(elementDate, DocNamePart.Last, ElementRelativePosition.First, -1));
	//"------------------------------------------------------------------------------------"
	//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})";
	//const string Grab_GUID_BEFOREparsing = @"(?<GUID>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})";
	//var rgx = new Regex(Grab_GUID_BEFOREparsing);
	//var originalText = $"Junk before {Guid.NewGuid()} junk after"; //
	//var match = rgx.Match(nameToParse);
	//Console.WriteLine($" {originalText}");
	//match.Dump();
	//"------------------------------------------------------------------------------------"
	foreach (var docElement in docElements)
	{
		Console.WriteLine(docElement);
		Console.WriteLine("------------------------------------------------------------------------------------");
	}
	//docNameElements.Element.Add(ElementDescription.CreateInstance(WhichElementItIs.FileNameDate, "052022", DocNamePart.Last, ElementRelativePosition.Last, -1));
	//docNameElements.Element.Add(ElementDescription.CreateInstance(WhichElementItIs.FileNameInterval, "de 2804 até 03052022", DocNamePart.Middle, ElementRelativePosition.Last, -1));
	//docNameElements.Element.Add(ElementDescription.CreateInstance(WhichElementItIs.VersionWithPrefix, "v2", DocNamePart.Last, ElementRelativePosition.First, -1));
	//var count = docNameElements.Element.Count == numberElem ? string.Empty : ($": it should be {numberElem} instead of {docNameElements.Element.Count}");
	//Console.WriteLine($"-----------------------Testing docNameElements.Element.Count-------------------------------------------------");
	//Console.WriteLine($"docNameElements.Element.Count = {numberElem}: {docNameElements.Element.Count == numberElem} {count}");
	//Console.WriteLine($"-----------------------Testing docNameElements.Element.Count-------------------------------------------------");
	//Console.WriteLine($"{WhichElementItIs.FileNameInterval.ToString()} = Middle: {interval.FirstOrDefault() == DocNamePart.Middle}");
	// (from x in Items where x.Id == 123 select x).FirstOrDefault();
	// var item1 = Items.FirstOrDefault(x => x.Id == 123);
	//Console.WriteLine($"{WhichElementItIs.FileNameInterval.ToString()} is in position 1: {elemInterval.FirstOrDefault() == docNameElements.Element[1]}");
	}
}

// ###################            ##################################      Enums      ##################################            ###################
public enum DateFormat
{
	Unknown = -99,
	[Description("ano(s)")]
	NumYears = -4,
	[Description("mês/meses")]
	NumMonths = -3,
	[Description("dia(s)")]
	NumDays = -2,
	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
}

// Primitives or References
public enum TypeOfElement
{
	@Null = -1,
	@Unclassified = 0,
	@String = 1,
	@Int,
	@Float,
	@DateTime,
	//Above primitives
	//Below References
	@VersionNumberOnly,
	@VersionWithPrefix,
	@Date,
	@Interval,
	@GUID,
	@DrugNameDose
}

// ###################            ##################################      Enums      ##################################            ###################
// ###################            ##################################  NOT USED  Element      ##################################            ###################
// ###################            ##################################   NOT USED  Element      ##################################            ###################
// ###################            ##################################   Interface and Base      ##################################            ###################
public interface IElementType : IComparable
{
//public ElementType ElemValue { get; set; }
//public TypeOfElement TypeOfElem { get; }
}

public class BaseElement : ValueObject
{
	public int StartIndex { get; set; } = -1;
	public string ConnectorBefore { get; set; } = string.Empty;
	/// <summary>
	/// Text where the element was extracted from
	/// </summary>
	public string OriginalText { get; private protected set; } = string.Empty;
	public Result<string> ElementValue { get; set; } = Result.Failure<string>("No value");
#region Overrides of ValueObject
	protected override IEnumerable<IComparable> GetEqualityComponents()
	{
		yield return StartIndex;
		yield return ConnectorBefore;
		yield return OriginalText;
	}
#endregion
}

// ###################            ##################################   Interface and Base      ##################################            ###################
// ###################            ##################################      ElementDescription      ##################################            ###################
// https://stackoverflow.com/questions/10712933/how-do-i-correctly-wrap-a-dictionaryt-u-and-expose-an-enumerator
// https://stackoverflow.com/questions/7444395/encapsulate-collection-in-c-sharp
// https://stackoverflow.com/questions/1176416/implementing-ilist-interface
// https://stackoverflow.com/questions/3464841/how-to-get-the-index-of-element-in-the-listt-in-c-sharp
public class ElementDescription : ValueObject
{
	private ElementDescription(IElementType elem, DocNamePart whichPart, ElementRelativePosition relativePosition, int startIndex)
	{
		ClassifyTypeOfElement(elem);
		WhichPart = whichPart;
		RelativePosition = relativePosition;
		Value = elem;
		Start = startIndex;
	}

	public static ElementDescription CreateInstance(IElementType elem, DocNamePart whichPart, ElementRelativePosition relativePosition, int startIndex)
	{
		return new ElementDescription(elem, whichPart, relativePosition, startIndex);
	}

	public static ElementDescription NullElementDescription() => new(null, DocNamePart.NoPart, ElementRelativePosition.DoesNotExist, int.MinValue);
	public ElementRelativePosition RelativePosition { get; set; }

	public DocNamePart WhichPart { get; set; }

	//DONE: try to strong type below
	public IElementType Value { get; set; }

	public TypeOfElement TypeOfElem { get; private set; } // => Value.TypeOfElem;

	public string ConnectorBefore { get; set; }

	/// <summary>
	/// Zero-based index of start in original Part (Value) string
	/// </summary>
	public int Start { get; private set; }

	private void ClassifyTypeOfElement(object elem)
	{
		switch (elem)
		{
			case int i:
				Console.WriteLine($"The object is an int with value {i}");
				TypeOfElem = TypeOfElement.Int;
				break;
			case float f:
				Console.WriteLine($"The object is an float with value {f}");
				TypeOfElem = TypeOfElement.Float;
				break;
			case string s:
				Console.WriteLine($"The object is a string with value {s}");
				TypeOfElem = TypeOfElement.String;
				break;
			case DateTime d:
				Console.WriteLine($"The object is a DateTime with value {d}");
				TypeOfElem = TypeOfElement.DateTime;
				break;
			case VersionInSentence v:
				TypeOfElem = v.HasVersionAnyPrefix ? TypeOfElement.VersionWithPrefix : TypeOfElement.VersionNumberOnly;
				//Console.WriteLine($"The object is a VersionInSentence type {TypeOfElem.GetDescription()} with value {v}");				
				break;
			case DateInSentence d:
				//Console.WriteLine($"The object is a DateInSentence with value {d}");
				TypeOfElem = TypeOfElement.Date;
				break;
			case IntervalInSentence i:
				//Console.WriteLine($"The object is a IntervalInSentence with value {i}");
				TypeOfElem = TypeOfElement.Interval;
				break;
			case InNameGUID i:
				Console.WriteLine($"The object is a InNameGUID with value {i}");
				TypeOfElem = TypeOfElement.GUID;
				break;
			case MedicineAndDosageInSentence i:
				Console.WriteLine($"The object is a MedicineAndDosageInSentence with value {i}");
				TypeOfElem = TypeOfElement.DrugNameDose;
				break;
			case null:
				Console.WriteLine("The object is null");
				TypeOfElem = TypeOfElement.Null;
				break;
			default:
				Console.WriteLine("The object is of an unknown type");
				TypeOfElem = TypeOfElement.Unclassified;
				break;
		}
	}

	public override string ToString()
	{
		return $"Element {TypeOfElem.GetDescription()} is in {WhichPart}, starting at position {(Start > -1 ? Start : "fixa")}: \n \t {Value.ToString()}";
	}

	protected override IEnumerable<IComparable> GetEqualityComponents()
	{
		yield return Value;
		yield return TypeOfElem;
		yield return ConnectorBefore;
		yield return WhichPart;
		yield return Start;
	}
}

// ###################            ##################################      ElementDescription      ##################################            ###################
// ###################            ##################################      DocPartElementsMount      ##################################            ###################
// ###################            ##################################      DocPartElementsMount      ##################################            ###################
// ###################            ##################################      InNameGUID       ##################################            ###################
public class InNameGUID : BaseElement, IElementType
{
	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 const string Grab_GUID_BEFOREparsing = @"(?<GUID>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})";
	private InNameGUID(DocNamePart namePart, string partToParse)
	{
		OriginalText = partToParse;
		Part = namePart;
	}

	public static InNameGUID CreateInstance(string part, DocNamePart namePart)
	{
		var instance = new InNameGUID(namePart, part);
		Console.WriteLine($"text to parse {part}");
		if (instance.GetGUID())
			return instance;
		return NullGUID();
	}

	//public TypeOfElement TypeOfElem => TypeOfElement.GUID;
	public bool NoGUID => string.IsNullOrEmpty(GUID);
	public static InNameGUID NullGUID() => new(DocNamePart.NoPart, string.Empty);
	public bool GetGUID()
	{
		var rgx = new Regex(Grab_GUID_BEFOREparsing);//Grab_GUID_treated);
		var match = rgx.Match(this.OriginalText);
		Console.WriteLine($"text to parse GUID {this.OriginalText}");
		//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, Part, match.Groups["GUID"].Value) : NullGUID();
		if (match.Success)
		{
			StartIndex = match.Groups["GUID"].Index;
			End = match.Groups["GUID"].Length - 1;
			GUID = match.Groups["GUID"].Value;
			Console.WriteLine($"GUID {GUID}");
			return true;
		}

		//      1  	2			
		//  0   1	2	3	4	5
		//? Result.Success(match.Groups["GUID"].Value.Trim())
		//: Result.Failure<string>("No GUID in this part");
		Console.WriteLine($"GUID failed");
		return false;
	}

	public int End { get; private set; } = -1;
	//TODO: is DocNamePart necessary!?!?!? if yes, push to BaseElement
	public DocNamePart Part { get; private set; }

	public string GUID { get; private set; }

	public override string ToString()
	{
		return $"It is in {Part}, starting at position {(StartIndex > -1 ? StartIndex : "fixa")}; \n \t Value is {GUID}";
	}

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

// ###################            ##################################      InNameGUID       ##################################            ###################
// ###################            ##################################      MedicineDosageForm       ##################################            ###################
public class MedicineDosageForm : BaseElement, IElementType
{
	public string Name { get; }

	public string Dosage { get; }

	public string Unit { get; }

	public string Form { get; }

	//public string OriginalText { get; }
	private MedicineDosageForm(string originalText, string name, string dosage, string unit, string form)
	{
		Name = name;
		Dosage = dosage;
		Unit = unit;
		Form = form;
		OriginalText = originalText;
	}

	public static MedicineDosageForm CreateInstance(string originalText, string name, string dosage, string unit, string form = "comprimido")
	{
		return new MedicineDosageForm(originalText, name, dosage, unit, form);
	}

	public static MedicineDosageForm NullMedicine => new(string.Empty, string.Empty, string.Empty, string.Empty, string.Empty);
	public override string ToString()
	{
		return $"Drug: {Name} {Form} of {Dosage}{Unit}";
	}

#region Overrides of ValueObject
	protected override IEnumerable<IComparable> GetEqualityComponents()
	{
		yield return Name;
		yield return Dosage;
		yield return Unit;
		yield return Form;
		yield return OriginalText;
	}
#endregion
}

// ###################            ##################################      MedicineDosageForm       ##################################            ###################
// ###################            ##################################      DateInSentence      ##################################            ###################
public class DateInSentence : BaseElement, IElementType // ValueObject
{
	private readonly string _originalSentenceToParseDate;
	private readonly CultureInfo _cultureInfo;
	private readonly int? _maxPossibleYear;
	private readonly bool _forceDdmMorMmdd;
	private readonly int _minPossibleYear;
	private readonly bool _acceptWildCard;
	#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^^^^^^^^^^^^
	public const string GrabDatesWithMonthsInLettersOrPureNumbersFromFile = @"(?<relationandinterval>(?<temporalrelation> em | por )?(?<=\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))(?<timeframe> ano | anos | mês | meses | dia | dias )?)";
	//https://regex101.com/r/ZuUZy3/11^^^^^^^^^^^^
	//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
	#region Public Fields
	public string DateText { get; private set; } = string.Empty;
	public DateTime DateAndTime { get; private set; } = DateTime.MinValue;
	/// <summary>
	/// When TypeInterval == TimeFrame, DateTime == DateTime.MinValue and
	/// here will be stored Number of Days, Months or Years
	/// </summary>
	//[JsonIgnore]
	public int IntervalTimeFrame => int.Parse(DateText);
	public DateFormat Mask { get; private set; } = DateFormat.NoDate;
	public CertaintyAboutElement CertaintyAbout { get; private set; } = CertaintyAboutElement.NonExisting;
	public bool IsDDMM => _cultureInfo?.Name == "pt-BR";
	#endregion Public Fields
	#region Constructors
	//[JsonConstructor]
	private DateInSentence()
	{
	}

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

	private DateInSentence(string originalSentenceToParseDate, CultureInfo cultureInfo, int? maxPossibleYear, bool forceDDMMorMMDD, int minPossibleYear, bool acceptWildCard)
	{
		_originalSentenceToParseDate = originalSentenceToParseDate;
		_cultureInfo = cultureInfo;
		_maxPossibleYear = maxPossibleYear ??= GetCurrentYearPlus(3);
		_forceDdmMorMmdd = forceDDMMorMMDD;
		_minPossibleYear = minPossibleYear;
		_acceptWildCard = acceptWildCard;
	}

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

	public static DateInSentence ChangeToYYYY(DateInSentence 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.DateAndTime, DateFormat.yyyy);
	}

	public static DateInSentence ChangeToMMDD(DateInSentence 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.DateAndTime, DateFormat.MMdd);
	}

	public static DateInSentence ChangeToDDMM(DateInSentence 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.DateAndTime, DateFormat.ddMM);
	}

	public static DateInSentence CreateInstanceTimeFrame(string dateText, DateFormat mask, CertaintyAboutElement certaintyAbout = CertaintyAboutElement.AbsolutelyCertain)
	{
		//if (!int.TryParse(dateText, out _)) throw new ArgumentException("dateText must be a number");
		return new DateInSentence(dateText, DateTime.MinValue, mask, certaintyAbout);
	}

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

	/// <summary>
	/// Create Instance inferring Mask and Format for Date Parsing
	/// </summary>
	public static DateInSentence CreateInstance(string dateToParse, CultureInfo cultureInfo, int? maxPossibleYear, bool forceDDMMorMMDD = false, int minPossibleYear = 1990, bool acceptWildCard = true)
	{
		var dateParsing = new DateInSentence(dateToParse, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
		var dateExtracted = dateParsing.GetDate(dateToParse, (-1, -1));
		if (dateExtracted.IsFailure) return DateInSentence.NullDate;

		var maskForDateParsing = string.Empty;
		DateTime parsedDate = DateTime.MinValue;
		var raw = dateExtracted.Value;
		// TryParse won't work in some situations, like what happens if the string is a credit card number with 16 digits
		// or if DateTime is in sortable format, like "20210620150000"		
		//if (dateToParse.IsNumber())
		if (raw.IsDigit())
		{
			if (raw.Length == DateFormat.sortable.GetDescription().Length) //yyyyMMddHHmmss
			{
				//[Description("yyyyMMddHHmmss")]
				//sortable,
				dateParsing.Mask = DateFormat.sortable;
			}
			//[Description("dd/MM/yyyy HH:mm:ss")]
			//completeUpToSeconds,
			//[Description("MM/dd/yyyy HH:mm:ss")]
			//completeUpToSecondsUS,
			else if (raw.Length == 8) //ddmmyyyy or mmddyyyy
			{
				dateParsing.Mask = dateParsing.IsDDMM ? DateFormat.ddMMyyyy : DateFormat.MMddyyyy;
			}
			else if (raw.Length == 6) //MMyyyy 
			{
				dateParsing.Mask = DateFormat.MMyyyy;
			}
			else if (raw.Length == 4) //ddMM OR MMdd OR yyyy
			{
				var yyyyToTestIfWithinAllowedRange = DateTime.MinValue;
				var maybeDDMMorMMDD = IsItPossibleToBeDDMMOrMMDD(raw, cultureInfo);
				//DateTime.TryParseExact(dateParsing, DateFormat.ddMM.GetDescription(), cultureInfo, DateTimeStyles.None, out _) ||
				// DateTime.TryParseExact(dateParsing, DateFormat.MMdd.GetDescription(), cultureInfo, DateTimeStyles.None, out _);
				var maybeYYYY = DateTime.TryParseExact(raw, DateFormat.yyyy.GetDescription(), cultureInfo, DateTimeStyles.None, out yyyyToTestIfWithinAllowedRange);
				if ((maybeDDMMorMMDD && !maybeYYYY) || forceDDMMorMMDD)
					dateParsing.Mask = dateParsing.IsDDMM ? DateFormat.ddMM : DateFormat.MMdd;
				else if (!maybeDDMMorMMDD && maybeYYYY)
					dateParsing.Mask = DateFormat.yyyy;
				else if (maybeDDMMorMMDD && maybeYYYY)
				{ //assume yyyy if possible ????
					dateParsing.CertaintyAbout = 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
						dateParsing.Mask = DateFormat.yyyy;
					else
						dateParsing.Mask = dateParsing.IsDDMM ? DateFormat.ddMM : DateFormat.MMdd;
				}
				else if (maybeDDMMorMMDD && maybeYYYY)
				{
					//?????
					dateParsing.Mask = DateFormat.NoDate;
					dateParsing.CertaintyAbout = CertaintyAboutElement.NonExisting;
				}
			}
			else if (raw.Length == 2) //dd OR MM OR yy
			{
				throw new NotImplementedException("InferMaskAndFormatForDateParsing: dateParsing.Length == 2");
			}

			//if (DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), cultureInfo, DateTimeStyles.None, out parsedDate))
			//{
			//	dateParsing.DateAndTime = parsedDate;
			//	dateParsing.DateText = raw;
			//	dateParsing.ElementValue = Result.Success(raw);
			//	return dateParsing;
			//}
		}
		else //if (!raw.IsDigit()) MMM or MMMM or ddd or dd or tt
		{
			if (raw.Contains(WildCardForDate) && raw.Length == 4)
			{ //202_
				dateParsing.Mask = DateFormat.yyyy;
				dateParsing.DateText = raw;
				dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
				return dateParsing;
			}
			if (!raw.Contains(WildCardForDate) && raw.Length == 7)
			{ //fev2021
				dateParsing.Mask = DateFormat.MMMyyyy;
				//_ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), cultureInfo, DateTimeStyles.None, out parsedDate);
				//dateParsing.DateText = raw;
				//dateParsing.DateAndTime = parsedDate;
				dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
				//return dateParsing;
			}

			//GrabDatesWithMonthsInLettersOrPureNumbersFromFile
			//grab: 202_
			//[Description("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'")]
			//universalSortable		
			throw new NotImplementedException("InferMaskAndFormatForDateParsing: dateParsing is not digit, ie, MMM or MMMM or ddd or dd or tt");
		}
		if (DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), cultureInfo, DateTimeStyles.None, out parsedDate))
		{
			dateParsing.DateAndTime = parsedDate;
			dateParsing.DateText = raw;
			dateParsing.ElementValue = Result.Success(raw);
			return dateParsing;
		}
		dateParsing.ElementValue = Result.Failure<string>("No date stamp in this file name");
		return DateInSentence.NullDate; // dateParsing;
										//DateInSentence.CreateInstance(raw, parsedDate, dateParsing.Mask, dateParsing.CertaintyAbout);
	}

	public static DateInSentence CreateInstanceFromSentence(string dateToParse, CultureInfo cultureInfo, (int start, int end) forbiddenZoneCoordinates, int? maxPossibleYear, bool forceDDMMorMMDD = false, int minPossibleYear = 1990, bool acceptWildCard = true)
	{
		//var dateInSentence = new DateInSentence(dateToParse, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
		var hasDate = GetDateStatic(dateToParse, cultureInfo, forbiddenZoneCoordinates, acceptWildCard);
		if (hasDate.IsFailure)
			return DateInSentence.NullDate;
		return CreateInstance(hasDate.Value, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
	}

	public static Result<DateInSentence> Update(string date, DateInSentence valueDateInSentence)
	{
		var tryDate = CreateInstance(date, valueDateInSentence._cultureInfo, valueDateInSentence._maxPossibleYear, valueDateInSentence._forceDdmMorMmdd, valueDateInSentence._minPossibleYear, valueDateInSentence._acceptWildCard);
		if (tryDate == NullDate)
			return Result.Failure<DateInSentence>("Invalid date");
		return Result.Success(tryDate);
	}

	public Result<string> GetDate(string partToTest, (int start, int end) forbiddenZoneCoordinates)
	//public static Result<string> GetDateStatic(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 = ReturnDateResult(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 = ReturnDateResult(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 = ReturnDateResult(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;
	}

	#endregion Constructors
	#region Private Methods
	public static Result<string> GetDateStatic(string partToTest, CultureInfo cultureInfo, (int start, int end) forbiddenZoneCoordinates, bool acceptWildCard = true)
	//public static Result<string> GetDateStatic(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 = ReturnDateResult(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 = ReturnDateResult(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 = ReturnDateResult(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;
	}

	internal static int GetCurrentYearPlus(int toAddCurrent) => DateTime.Now.Year + toAddCurrent;
	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 _);
	}

	private 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, new CultureInfo("pt-BR")))
		//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 (acceptWildCard && dateWithoutSpace.Contains(WildCardForDate))
		{
			return Result.Success(dateWithoutSpace);
		}

		//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> ReturnDateResult(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;
	}

	public override string ToString()
	{
		return $"{DateText} with mask {Mask}: {DateAndTime}; certainty: {CertaintyAbout}";
	}

	#endregion Private Methods
	#region Overrides of ValueObject
	protected override IEnumerable<IComparable> GetEqualityComponents()
	{
		yield return DateText;
		yield return DateAndTime;
		yield return Mask;
		yield return CertaintyAbout;
	}
	#endregion
}

// ###################            ##################################      DateInSentence      ##################################            ###################
// ###################            ##################################      IntervalInSentence      ##################################            ###################
public enum IntervalType
{
	Normal = 0, //"de 1203 até 20041999"
	TemporalClue //"em 082021"
}

public class IntervalInSentence : BaseElement, IElementType
{
	#region Private Constants
	private readonly string _cultureInfo;
	private readonly bool _sameFrameIntervalIsAllowed;
	private readonly bool _forceBeginDatePreviousYearIfReasonable;
	private readonly string _errorMsg;
	private Result<string> _candidateBegin;
	private Result<string> _candidateEnd;
	#endregion Private Constants
	#region Public Constants
	/// <summary>
	/// Should check for equality between relationandinterval and intervalordate; if so, the interval is invalid and should be ignored
	/// </summary>
	public const string GrabDatesWithMonthsInLettersOrPureNumbersFromFile = @"(?<relationandinterval>(?<temporalrelation> em | por )?(?<=\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))(?<timeframe> ano | anos | mês | meses | dia | dias )?)";
	//https://regex101.com/r/ZuUZy3/11^^^^^^^^^^^^
	//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
	#region Public Fields
	public IntervalType IntervalType { get; private set; }

	public string OriginalInterval { get; private set; }

	public Result<string> Interval { get; private set; }

	public string TextTemporalRelation { get; private set; }

	public string TextBetween { get; private set; }

	public string TimeFrame { get; private set; }

	public DateInSentence DateBegin { get; private set; }

	public DateInSentence DateEnd { get; private set; }

	public TypeOfElement TypeOfElem => TypeOfElement.Interval;
	public CertaintyAboutElement CertaintyAboutDateBegin => DateBegin?.CertaintyAbout ?? CertaintyAboutElement.NonExisting;
	public CertaintyAboutElement CertaintyAboutDateEnd => DateEnd?.CertaintyAbout ?? CertaintyAboutElement.NonExisting;
	public bool DateBeginHadToGoBackOneYear { get; private set; }

	#endregion Public Fields
	#region Constructors
	public static IntervalInSentence Null
	{
		get
		{
			var nullInterval = new IntervalInSentence(string.Empty, CultureInfo.CurrentCulture, false, false, "No interval date stamp in this file name");
			nullInterval.Interval = Result.Failure<string>(nullInterval._errorMsg);
			return nullInterval;
		}
	}

	//[JsonConstructor]
	private IntervalInSentence()
	{
	}

	private IntervalInSentence(string originalInterval, CultureInfo cultureInfo, bool sameFrameIntervalIsAllowed, bool forceBeginDatePreviousYearIfReasonable, string errorMsg)
	{
		_cultureInfo = cultureInfo.Name;
		_sameFrameIntervalIsAllowed = sameFrameIntervalIsAllowed;
		_forceBeginDatePreviousYearIfReasonable = forceBeginDatePreviousYearIfReasonable;
		_errorMsg = errorMsg;
		OriginalInterval = originalInterval;
	}

	internal static IntervalInSentence CreateInstance(string interval, CultureInfo cultureInfo, bool forceBeginDatePreviousYearIfReasonable = false, bool sameFrameIntervalIsAllowed = false, string errorMsg = "No interval date stamp in this file name")
	{
		var intervalInSentence = new IntervalInSentence(interval, cultureInfo, sameFrameIntervalIsAllowed, forceBeginDatePreviousYearIfReasonable, errorMsg);
		return !intervalInSentence.GetIntervalDates(interval) ? IntervalInSentence.Null : intervalInSentence;
	}

	#endregion Constructors
	#region Private Methods
	private bool IsDDMM => _cultureInfo == "pt-BR";
	/// <summary>
	///TODO 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 valid, but I do not know for sure
	/// </summary>
	/// <param name = "partToTest"></param>
	/// <param name = "errorMsg"></param>
	/// <returns></returns>
	private bool GetIntervalDates(string partToTest)
	{
		if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest))
			return false;
		var hasInterval = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "interval", _errorMsg);
		var allErrors = string.Empty;
		//var errorMsg1 = string.Empty; var errorMsg2 = string.Empty;
		if (hasInterval.IsSuccess)
		{
			Interval = hasInterval;
			_candidateBegin = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "datebegin", _errorMsg);
			//allErrors = string.IsNullOrEmpty(_errorMsg) ? string.Empty : _errorMsg;
			_candidateEnd = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "dateend", _errorMsg);
			//allErrors += string.IsNullOrEmpty(errorMsg1) ? string.Empty : $";\n{errorMsg2}";
			if (_candidateBegin.IsFailure || _candidateEnd.IsFailure)
			{
				//_errorMsg = CompoundErrorMsgs
				ElementValue = Result.Failure<string>( $"No date stamp in this file name because: \n {_errorMsg}");
				return false;
			}
			var intervalDates = TryCompareIntervalDates(_candidateBegin.Value, _candidateEnd.Value);
			if (intervalDates.dateBegin.IsFailure && intervalDates.dateEnd.IsFailure)
			{
				ElementValue = Result.Failure<string>($"No date stamp in this file name because: \n {_errorMsg}");
				return false;
			}
			DateBegin = intervalDates.dateBegin.Value;
			DateEnd = intervalDates.dateEnd.Value;
			TextTemporalRelation = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "starting", _errorMsg).Value;
			TextBetween = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "link", _errorMsg).Value;
			IntervalType = IntervalType.Normal;
			TimeFrame = string.Empty;
			ElementValue = Result.Success(hasInterval.Value);
			return true; //return IsIntervalValid(partToTest); //? hasInterval : Result.Failure<string>(errorMsg);
		}

		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))
			{
				Interval = Result.Failure<string>(_errorMsg);
				ElementValue = Result.Failure<string>($"No date stamp in this file name because: \n {_errorMsg}");
				return false; // Result.Failure<string>(errorMsg);
			}

			Interval = result;
			IntervalType = IntervalType.TemporalClue;
			_candidateBegin = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "intervalordate", _errorMsg);
			_candidateEnd = _candidateBegin;
			if (_candidateBegin.IsFailure)
				return false;
			TextTemporalRelation = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "temporalrelation", _errorMsg).Value;
			TextBetween = string.Empty;
			TimeFrame = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "timeframe", _errorMsg).Value;
			DateBegin = DateInSentence.CreateInstanceTimeFrame(_candidateBegin.Value, DetermineTimeFrameType(result.Value));
			ElementValue = Result.Success(hasInterval.Value);
		}

		return _candidateBegin.IsSuccess && _candidateEnd.IsSuccess;
	}
	private string CompoundErrorMsgs (string @base, string first, string second = "")
	{
		if (string.IsNullOrEmpty(first)) return string.Empty;
		var allErrors = @$"{@base}\n{first}";
		allErrors += string.IsNullOrEmpty(_errorMsg) ? string.Empty : $";\n{second}";
		return allErrors;
	}
	private (Result<DateInSentence> dateBegin, Result<DateInSentence> dateEnd) TryCompareIntervalDates(string dateBegin, string dateEnd)
	{
		var errorMsg = "because BeginDate is After EndDate";
		// TryParse won't work in some situations, like what happens if the string is a credit card number with 16 digits
		// or if DateTime is in sortable format, like "20210620150000"
		//if (dateBegin.IsNumber() && dateEnd.IsNumber()) 
		if (dateBegin.IsDigit() && dateEnd.IsDigit())
		{
			switch (dateEnd.Length)
			{
				case 14: //DateFormat.sortable.GetDescription().Length;
					if (dateBegin.Length == DateFormat.sortable.GetDescription().Length)
					{
						var beginDDMMDateIsInPreviousYear = CompareDatesWithSameFormat(dateBegin, dateEnd, out var format, out var validDates);
						if (beginDDMMDateIsInPreviousYear)
						{
							return (Result.Success(DateInSentence.CreateInstance(dateBegin, validDates.dateStarted, format)), Result.Success(DateInSentence.CreateInstance(dateEnd, validDates.dateEnded, format)));
						}
					}

					break;
				case 8: //ddMMyyyy
					var formatEnd = IsDDMM ? DateFormat.ddMMyyyy : DateFormat.MMddyyyy;
					var dateEndIsDDMM = DateTime.TryParseExact(dateEnd, formatEnd.GetDescription(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out var dateEnded);
					if (dateBegin.Length == 8) //ddMMyyyy
					{
						var beginDDMMDateIsInPreviousYear = CompareDatesWithSameFormat(dateBegin, dateEnd, out var format, out var validDates);
						if (beginDDMMDateIsInPreviousYear)
						{
							return (Result.Success(DateInSentence.CreateInstance(dateBegin, validDates.dateStarted, format)), Result.Success(DateInSentence.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(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out var ddMMBegin);
						if (!dateBeginIsDDMM)
						{
							errorMsg = "because BeginDate is After EndDate";
						}
						else if (IsBeginDateReallyBeforeEndDate(ddMMBegin, dateEnded))
						{
							//return (Result.Success(InNameDate.CreateInstance(dateBegin + dateEnded.Year, ddMMBegin, formatEnd)), 
							//		Result.Success(InNameDate.CreateInstance(dateEnd, dateEnded, formatEnd))
							//	   );
							//Above return real tested date; below the original one
							var formatBegin = IsDDMM ? DateFormat.ddMM : DateFormat.MMdd;
							if (DateBeginHadToGoBackOneYear)
								ddMMBegin = ddMMBegin.AddYears(-1);
							return (Result.Success(DateInSentence.CreateInstance(dateBegin, ddMMBegin, formatBegin)), Result.Success(DateInSentence.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(DateInSentence.CreateInstance(dateBegin, new DateTime(dateEnded.Year, dateEnded.Month, dayBegin), DateFormat.dd));
							return (dayInterval, Result.Success(DateInSentence.CreateInstance(dateEnd, dateEnded, formatEnd)));
						}

						errorMsg = "because BeginDate is After EndDate";
					}

					break;
				case 6: //MMyyyy
					formatEnd = DateFormat.MMyyyy;
					dateEndIsDDMM = DateTime.TryParseExact(dateEnd, formatEnd.GetDescription(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out dateEnded);
					if (dateBegin.Length == 8) //almost impossible ddMMyyyy
					{
						throw new NotImplementedException("I did not implemented 'de ddMMyyyy até MMyyyy'");
					}
					else if (dateBegin.Length == 6) //MMyyyy
					{
						var dateBeginIsDDMM = DateTime.TryParseExact(dateBegin, formatEnd.GetDescription(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out var ddMMBegin);
						if (IsBeginDateReallyBeforeEndDate(ddMMBegin, dateEnded))
						{
							return (Result.Success(DateInSentence.CreateInstance(dateBegin, ddMMBegin, formatEnd)), Result.Success(DateInSentence.CreateInstance(dateEnd, dateEnded, formatEnd)));
						}

						errorMsg = "because BeginDate is After EndDate";
					}
					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, null, sameFrameIntervalIsAllowed: _sameFrameIntervalIsAllowed);
						if (result.dateBegin.CertaintyAbout != CertaintyAboutElement.NonExisting)
						{
							return (Result.Success(result.dateBegin), Result.Success(result.dateEnd));
						}

						errorMsg = "not existing BeginDate or EndDate";
					}
					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<DateInSentence>(errorMsg), Result.Failure<DateInSentence>(errorMsg));
	}

	private bool CompareDatesWithSameFormat(string dateBegin, string dateEnd, out DateFormat format, out (bool dateBeginIsDDMM, DateTime dateStarted, bool dateEndIsDDMM, DateTime dateEnded) validDates)
	{
		string errorMsg;
		var date = DateInSentence.CreateInstance(dateBegin, new CultureInfo(_cultureInfo), 2025, false);
		(var mask, format) = (date.Mask.GetDescription(), date.Mask);
		validDates = TryToParseDatesAsDDMM_MMDD(dateBegin, dateEnd, mask);
		bool beginDDMMDateIsInPreviousYear = false;
		if (validDates.dateStarted == DateTime.MinValue || validDates.dateEnded == DateTime.MinValue)
			return beginDDMMDateIsInPreviousYear;
		beginDDMMDateIsInPreviousYear = IsDDMMBeginDateReallyBeforeEndDate(dateBegin, dateEnd, format, _sameFrameIntervalIsAllowed);
		return beginDDMMDateIsInPreviousYear;
	}

	/// <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>
	private (DateInSentence dateBegin, DateInSentence dateEnd) DecideIfDateEndIsYYYYOrDDMM(string dateBeginToTest, string dateEndToTest, int? maxPossibleYear, int minPossibleYear = 1990, bool sameFrameIntervalIsAllowed = false)
	{
		maxPossibleYear ??= DateInSentence.GetCurrentYearPlus(3);
		var (isDateEndDubious, isDateBeginDubious, certaintyAboutYYYY) = DecideDegreeOfCertaintyAboutDates(dateBeginToTest, dateEndToTest);
		var dateBeginTry = DateInSentence.CreateInstance(dateBeginToTest, new CultureInfo(_cultureInfo), 2025, false);
		//var (maskForDDMM, formatForDDMM) = FormatForDDMMBasedOn(cultureInfo);			
		var (_, formatForDateBeginTry) = (dateBeginTry.Mask.GetDescription(), dateBeginTry.Mask);
		var dateBegin = DateInSentence.NullDate;
		var dateBeginIsYYYY = false;
		var dateBeginIsDDMM = false;
		var dateEnd = DateInSentence.NullDate;
		var dateEndIsYYYY = false;
		var dateEndIsDDMM = false;
		var (dateEnded, endDateMaybeYYYY) = TryToParseDateAsYYYY(dateEndToTest);
		var (dateStarted, beginDateMaybeYYYY) = TryToParseDateAsYYYY(dateBeginToTest);
		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
		(dateBeginIsYYYY, dateEndIsYYYY) = DetermineIfIntervalDatesShouldBeYYYY(isDateEndDubious, isDateBeginDubious, endDateMaybeYYYY, beginDateMaybeYYYY, dateEndIsYYYY, dateBeginIsYYYY);
		var beginCannotBeDDMMOrMMDD = !DateInSentence.IsItPossibleToBeDDMMOrMMDD(dateBeginToTest, new CultureInfo(_cultureInfo));
		if (beginCannotBeDDMMOrMMDD && !endDateMaybeYYYY)
		{
			if (dateStarted != dateEnded)
				return (DateInSentence.NullDate, DateInSentence.NullDate);
			//Below is by design; I do not allow interval like "between 2013 and 2013", unless for testing purposes
			if (dateStarted == dateEnded && !sameFrameIntervalIsAllowed)
				return (DateInSentence.NullDate, DateInSentence.NullDate);
		}

		if (dateBeginIsYYYY || beginCannotBeDDMMOrMMDD)
			(dateStarted, dateBeginIsYYYY) = TryToParseDateAsYYYY(dateBeginToTest);
		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...
			formatForDateBeginTry = IsDDMM ? DateFormat.ddMM : DateFormat.MMdd;
			(dateBeginIsDDMM, dateStarted, dateEndIsDDMM, dateEnded) = TryToParseDatesAsDDMM_MMDD(dateBeginToTest, dateEndToTest, formatForDateBeginTry.ToString());
		}

		if (dateBeginIsYYYY)
		{
			dateEndIsYYYY = DateTime.TryParseExact(dateEndToTest, DateFormat.yyyy.GetDescription(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out dateEnded);
			if (!dateEndIsYYYY)
				return (dateBegin, dateEnd);
			dateBegin = DateInSentence.CreateInstance(dateBeginToTest, dateStarted, DateFormat.yyyy, certaintyAboutYYYY);
			dateEnd = DateInSentence.CreateInstance(dateEndToTest, dateEnded, DateFormat.yyyy, certaintyAboutYYYY);
		}
		else if (dateBeginIsDDMM)
		{
			if (!dateEndIsDDMM || !IsDDMMBeginDateReallyBeforeEndDate(dateBeginToTest, dateEndToTest, formatForDateBeginTry, sameFrameIntervalIsAllowed))
				return (dateBegin, dateEnd);
			dateBegin = DateInSentence.CreateInstance(dateBeginToTest, dateStarted, formatForDateBeginTry, certaintyAboutYYYY);
			dateEnd = DateInSentence.CreateInstance(dateEndToTest, dateEnded, formatForDateBeginTry, certaintyAboutYYYY);
		}

		return (dateBegin, dateEnd);
	}

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

	/// <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>
	private bool IsDDMMBeginDateReallyBeforeEndDate(string dateBegin, string dateEnd, DateFormat dateFormat, bool sameFrameIntervalIsAllowed = false)
	{
		//var maskForDDMM = MaskForDateParsing(cultureInfo, dateFormat);
		var beginDateValid = DateTime.TryParseExact(dateBegin, dateFormat.GetDescription(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out var beginDate);
		//var beginDate = DateTime.ParseExact(dateBegin, dateFormat.GetDescription(), cultureInfo);
		var endDateValid = DateTime.TryParseExact(dateEnd, dateFormat.GetDescription(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out var endDate);
		if (!beginDateValid || !endDateValid)
			return false;
		//var endDate = DateTime.ParseExact(dateEnd, dateFormat.GetDescription(), cultureInfo);
		return IsBeginDateReallyBeforeEndDate(beginDate, endDate);
		//sameFrameIntervalIsAllowed ? beginDate <= endDate : beginDate < endDate;
	}

	//internal static (string mask, DateFormat dateFormat, CertaintyAboutElement degreeOfcertainty)
	private bool IsBeginDateReallyBeforeEndDate(DateTime dateBegin, DateTime dateEnd)
	{
		DateBeginHadToGoBackOneYear = false;
		var isBefore = _sameFrameIntervalIsAllowed ? dateBegin <= dateEnd : dateBegin < dateEnd;
		if (!isBefore && _forceBeginDatePreviousYearIfReasonable)
		{
			var dateBeginPreviousYear = dateBegin.AddYears(-1);
			isBefore = _sameFrameIntervalIsAllowed ? dateBeginPreviousYear <= dateEnd : dateBeginPreviousYear < dateEnd;
			DateBeginHadToGoBackOneYear = isBefore;
			return isBefore;
		}

		return isBefore;
	}

	private (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 bool AtLeastSomeDateIsDubiousAndBothDatesMaybeYYYY(bool endDateMaybeYYYY, bool beginDateMaybeYYYY)
	{
		return endDateMaybeYYYY && beginDateMaybeYYYY;
	}

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

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

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

	private (bool dateBeginIsDDMM, DateTime dateStarted, bool dateEndIsDDMM, DateTime dateEnded) TryToParseDatesAsDDMM_MMDD(string dateBeginToTest, string dateEndToTest, string maskForDDMM)
	{
		var dateBeginIsDDMM = DateTime.TryParseExact(dateBeginToTest, maskForDDMM, new CultureInfo(_cultureInfo), DateTimeStyles.None, out var dateStarted);
		var dateEndIsDDMM = DateTime.TryParseExact(dateEndToTest, maskForDDMM, new CultureInfo(_cultureInfo), DateTimeStyles.None, out var dateEnded);
		return (dateBeginIsDDMM, dateStarted, dateEndIsDDMM, dateEnded);
	}
	private DateFormat DetermineTimeFrameType(string originalText)
	{
		if (originalText.Contains("dia"))
			return DateFormat.NumDays;
		if (originalText.Contains("mês") || originalText.Contains("meses"))
			return DateFormat.NumMonths;
		if (originalText.Contains("ano"))
			return DateFormat.NumYears;
		return DateFormat.Unknown;
	}
	#endregion Private Methods

	#region Draft
	private bool IsIntervalValid(string partToTest)
	{
		var validBeginInterval = DocNameHelper.DateTryParseExact(_candidateBegin.Value, out var beginInterval, CultureInfo.CurrentCulture);
		var validEndInterval = DocNameHelper.DateTryParseExact(_candidateEnd.Value, out var endInterval, CultureInfo.CurrentCulture);
		var isValid = beginInterval < endInterval;
		return isValid;
	}

	public override string ToString()
	{
		return $"Interval is type {IntervalType.GetDescription()}. \n \t Start Date is {DateBegin.ToString()} (certainty: {CertaintyAboutDateBegin.GetDescription()}) \n \t End Date is {DateEnd.ToString()} (certainty: {CertaintyAboutDateEnd.GetDescription()})";
	}

	#endregion Draft
	#region Overrides of ValueObject
	protected override IEnumerable<IComparable> GetEqualityComponents()
	{
		//yield return _candidateBegin;
		//yield return _candidateEnd;
		yield return _cultureInfo;
		yield return _sameFrameIntervalIsAllowed;
		yield return _forceBeginDatePreviousYearIfReasonable;
		yield return OriginalInterval;
		yield return DateBeginHadToGoBackOneYear;
		yield return TextBetween;
		yield return TextTemporalRelation;
		yield return TimeFrame;
		yield return DateBegin;
		yield return DateEnd;
		yield return TypeOfElem;
		yield return IntervalType;
		yield return CertaintyAboutDateBegin;
		yield return CertaintyAboutDateEnd;
	}
	#endregion
}

// ###################            ##################################      IntervalInSentence      ##################################            ###################
// ###################            ##################################      VersionInSentence      ##################################            ###################
public class VersionInSentence : BaseElement, IElementType
{
	private readonly string _originalSentenceToParseDate;
	#region Public Constants
	public const string GrabVersionFromFile = @"(?<version>\sv[ersionão]*[\d@]+[\w@]*|[\d@]+v[ersionão]*[\w@]*)";
	//https://regex101.com/r/BfGfIY/2 ^^^^^^^^^^^^^^^^^^^ 
	#endregion Public Constants
	public string Version { get; private set; }

	public string VersionPrefix => Version.ReturnOnlyNonNumericCharacters();
	public int VersionNumber => Version.ReturnOnlyNumbersAsInt()!.Value;
	public bool HasVersionAnyPrefix => VersionPrefix.Length > 0;
	public TypeOfElement TypeOfElem => HasVersionAnyPrefix ? TypeOfElement.VersionWithPrefix : TypeOfElement.VersionNumberOnly;
	private VersionInSentence(string partToTest)//, string parsedVersion)
	{
		_originalSentenceToParseDate = partToTest;
		ElementValue = Result.Failure<string>("No file version");
		//Version = parsedVersion;
	}

	public static VersionInSentence CreateInstance(string partToTest)
	{
		if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest)) return NullVersion;
		var instance =  new VersionInSentence(partToTest);//, version.Value);		
		instance.ElementValue = instance.GetVersion();
		if (instance.ElementValue.IsFailure)
			return NullVersion;
		instance.Version = instance.ElementValue.Value;
		return instance;
	}

	public static VersionInSentence NullVersion => new(string.Empty);
	private Result<string> GetVersion()//string partToTest)
	{
		//if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest))
		//	return Result.Failure<string>("No file version");
		var partToTest = _originalSentenceToParseDate;
		var version = GetVersionFromPart(partToTest);
		if (!version.IsFailure && version.Value.IsNumber())
		{
			return TestVersionNumberOnly(version.Value);
		}

		if (version.IsFailure && partToTest.Length < 3 && partToTest.IsNumber())
		{
			return TestVersionNumberOnly(partToTest);
		}

		if (version.IsFailure && partToTest.ReturnOnlyNumbers().Length > 0 && partToTest.ReturnOnlyNumbers().Length < 3 && partToTest.ReturnOnlyNumbers().IsNumber())
		{
			return TestVersionNumberOnly(partToTest.ReturnOnlyNumbers());
		}

		return version; // "2017"
	}

	private static Result<string> TestVersionNumberOnly(string candidateForVersion)
	{
		var candidate = int.Parse(candidateForVersion);
		if (candidate < 1 || candidate > 20)
			return Result.Failure<string>("No file version");
		return Result.Success(candidate.ToString());
	}

	private static Result<string> GetVersionFromPart(string partToTest)
	{
		var version = DocNameHelper.ReturnResult(GrabVersionFromFile, partToTest, "version", "No file version");
		if (version.IsFailure && !char.IsWhiteSpace(partToTest, 0))
			version = DocNameHelper.ReturnResult(GrabVersionFromFile, $" {partToTest}", "version", "No file version");
		return version;
	}

	public static Result<string> TryRecoverFileVersionOnlyNumber(Result<string> fileDateOrInterval, Result<string> partNameToTest)
	{
		// special case:
		//	Nome do paciente - exame laboratorial amplo - 122022 2.docx######
		//	 FirstPartName: Nome do paciente
		//	 MiddlePartName: exame laboratorial amplo
		//	 MiddlePartNameOriginal: exame laboratorial amplo
		//	 LastPartName: 2
		//   LastPartNameOriginal: 122022 2
		//   FileVersion: No file version
		//   FileDate: 122022
		var rest = string.Empty;
		int tryVersion;
		if (fileDateOrInterval.IsSuccess)
		{
			rest = partNameToTest.Value.Replace(fileDateOrInterval.Value, string.Empty).Trim();
			// if (!int.TryParse(rest, out tryVersion)) return Result.Failure<string>("No file version");
			int.TryParse(rest, out tryVersion);
			if (tryVersion is > 0 and < 20)
				return Result.Success(tryVersion.ToString());
		}

		// special case:
		//Nome do paciente - exame laboratorial amplo 3 - 23122022.docx######
		//FirstPartName: Nome do paciente
		//MiddlePartName: exame laboratorial amplo 3
		//MiddlePartNameOriginal: exame laboratorial amplo 3
		//LastPartName:
		//LastPartNameOriginal: 23122022
		//FileVersion: No file version
		//FileDate: 23122022
		var restNum = rest.ReturnOnlyNumbersToArray();
		if (restNum.Length != 1 || !int.TryParse(restNum[0].ToString(), out tryVersion))
			return Result.Failure<string>("No file version");
		return tryVersion is > 0 and < 20 ? Result.Success(tryVersion.ToString()) : Result.Failure<string>("No file version");
	}

	public override string ToString()
	{
		return $"It has a Value '{Version}'";
	}

	#region Overrides of ValueObject
	protected override IEnumerable<IComparable> GetEqualityComponents()
	{
		yield return _originalSentenceToParseDate;
		yield return Version;
		yield return TypeOfElem;
	}
	#endregion
}


// ###################            ##################################      VersionInSentence      ##################################            ###################
// ###################            ##################################      MedicineAndDosageInSentence      ##################################            ###################
public class MedicineAndDosageInSentence : BaseElement // ValueObject
{
#region Private Constants
#endregion Private Constants
#region Public Constants
	/// <summary>
	///Should match:
	///Gilda Elena Brandão Andrade D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Zolpidem SL 5 mg 082021.docx
	///Gilda Elena Brandão Andrade D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Zolpidem CR 6,25 mg.docx
	///x - RECEITUÁRIO CONTROLE ESPECIAL - trazodona retard 150 mg
	///x - RECEITUÁRIO CONTROLE ESPECIAL - Prolopa HBS 100_25 mg.docx
	///x - RECEITUÁRIO CONTROLE ESPECIAL - Prolopa orodispersível 125 mg.docx
	///x - RECEITUÁRIO CONTROLE ESPECIAL - Parkidopa 25_250 mg
	///x - RECEITUÁRIO CONTROLE ESPECIAL - Parkidopa 25_250 mg.docx
	///x - RECEITUÁRIO CONTROLE ESPECIAL - pramipexol Sifrol 1,5 mg.docx
	///x - RECEITUÁRIO CONTROLE ESPECIAL - Rivastigmina Exelon Patch 9 mg.docx
	/// </summary>
	public const string GrabDoseAndUnitOfMedicinesFromPartOfFile = @"(?<=-|- )?(?<complete>(?<medicine>(?:(?!RECEITUÁRIO CONTROLE ESPECIAL)\w+ ){1,4})(?<=[ ]{1,2})(?<dosewithunit>(?<dose>[\d,.]+|[\d]+_[\d]+)[ ]{0,2}(?<unit>mg|comp|cp|UI|g)))(?=[ .-]?)";
	//https://regex101.com/r/sbmaPI/1 ^^^^^^^^^^^^^^^^
#endregion Public Constants
#region Public Fields
	public string Name { get; private set; }

	public string Dosage { get; set; }

	public string Unit { get; set; }

	public string Form { get; set; }

#endregion Public Fields
#region Constructors
	private MedicineAndDosageInSentence(string originalText, string name, string dosage, string unit, string form)
	{
		Name = name;
		Dosage = dosage;
		Unit = unit;
		Form = form;
		OriginalText = originalText;
	}

	private MedicineAndDosageInSentence(string originalText)
	{
		OriginalText = originalText;
	}

	public static MedicineAndDosageInSentence CreateInstance(string originalText)
	{
		if (string.IsNullOrEmpty(originalText))
			return NullMedicine;
		var instance = new MedicineAndDosageInSentence(originalText);
		instance.TryFindMedicineDosageForm();
		return instance.ElementValue.IsFailure ? NullMedicine : instance;
	}

	public static MedicineAndDosageInSentence NullMedicine => new(string.Empty, string.Empty, string.Empty, string.Empty, string.Empty);
#endregion Constructors
#region Private Methods
	private void TryFindMedicineDosageForm()
	{
		Result<string> version;
		var rgx = new Regex(GrabDoseAndUnitOfMedicinesFromPartOfFile);
		var match = rgx.Match(OriginalText);
		//Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
		//Result<MedicineDosageForm> result;
		//MedicineDosageForm toReturn;
		if (match.Success)
		{
			//toReturn = MedicineDosageForm.CreateInstance(
			//    match.Groups["complete"].Value,
			//    match.Groups["medicine"].Value.Replace("CONTROLE ESPECIAL", string.Empty).Trim(),
			//    match.Groups["dose"].Value,
			//    match.Groups["unit"].Value,
			//    "comprimido"
			//);
			OriginalText = match.Groups["complete"].Value;
			Name = match.Groups["medicine"].Value.Replace("CONTROLE ESPECIAL", string.Empty).Trim();
			Dosage = match.Groups["dose"].Value;
			Unit = match.Groups["unit"].Value;
			Form = "comprimido";
		//result = Result.Success(toReturn);
		}
		else
		{
		//result = Result.Failure<MedicineDosageForm>(errorMsg);
		}

		//if (!result.IsFailure) return result;
		//Try to look list of words only
		//until now is losing below
		//Gilda Elena Brandão Andrade D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Fosfomicina 20__.docx
		var criteria = new string[]{"Receita de Antibióticos", "Receita de Psicotrópicos"};
		var medicines = GetWordsThatPointsToType(criteria);
		foreach (var medicine in medicines)
		{
			if (!OriginalText.ToLowerInvariant().Contains(medicine.ToLowerInvariant()))
				continue;
			//toReturn = MedicineDosageForm.CreateInstance(medicine.CapitalizeFirstLetter()
			//    , medicine.CapitalizeFirstLetter(), "N/A", "N/A", "N/A");
			Name = medicine.CapitalizeFirstLetter();
			Dosage = "N/A";
			Unit = "N/A";
			Form = "N/A";
		//result = Result.Success(toReturn);
		}
	//return result;
	}

	private static IEnumerable<string> GetWordsThatPointsToType(string[] criteria)
	//private static List<string> GetWordsThatPointsToType(string[] criteria)
	{
		return new string[]{"Receita de Antibióticos", "Receita de Psicotrópicos"};
	}

#endregion Private Methods
#region Overrides of ValueObject
	protected override IEnumerable<IComparable> GetEqualityComponents()
	{
		yield return Name;
		yield return Dosage;
		yield return Unit;
		yield return Form;
	}
#endregion
}

// ###################            ##################################      MedicineAndDosageInSentence      ##################################            ###################
// ###################            ##################################      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
	//internal static string StripOffDateIntervalVersionAndDrug(string partToBeStrippedOff, DocPartElementsMount docNameElements, string date = "", string version = "", string interval = "", string medicineAndDose = "")
	//{
	//}
	//internal static string StripOffPartWithConnector(string partToBeStrippedOff, string partToStrip, WhichElementItIs whichElementItIs, DocPartElementsMount docNameElements)
	//{
	//}
	internal 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();
	}

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

	internal 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
	internal static string[] dubiousDDMMOrYYYY() => new[]{"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
	internal static string[] dubiousMMDDOrYYYY() => new[]{""};
	//								^^^^^^^^^^^^^^^^^^^^^^^^^^ ??
#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>
	/// If yearToAssume == string.Empty, it will try to parse with no year 
	/// </summary>
	/// <param name = "yearToAssume"></param>
	/// <param name = "testDate"></param>
	/// <param name = "cultureInfo"></param>
	/// <param name = "dateWithNoYearAndWithoutSpace"></param>
	/// <returns></returns>
	internal static bool DateWithNoYearTryParseExact(string dateWithNoYearAndWithoutSpace, out DateTime testDate, CultureInfo cultureInfo, string yearToAssume)
	{
		//Guard.ThrowIfStringNullOrEmptyOrNotString(dateWithNoYearAndWithoutSpace, nameof(dateWithNoYearAndWithoutSpace));
		return DateTryParseExact(dateWithNoYearAndWithoutSpace + yearToAssume, out testDate, cultureInfo, string.IsNullOrEmpty(yearToAssume));
	}

	/// <summary>
	/// 
	/// </summary>
	/// <param name = "dateWithoutSpace"></param>
	/// <param name = "testDate"></param>
	/// <param name = "cultureInfo"></param>
	/// <param name = "forceDDMM"></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));
		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"
	}
//internal 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      ##################################            ###################
// ###################            ##################################      WrappedCollection      ##################################            ###################
// https://stackoverflow.com/questions/10712933/how-do-i-correctly-wrap-a-dictionaryt-u-and-expose-an-enumerator
// https://stackoverflow.com/questions/7444395/encapsulate-collection-in-c-sharp
// https://stackoverflow.com/questions/1176416/implementing-ilist-interface
// https://stackoverflow.com/questions/3464841/how-to-get-the-index-of-element-in-the-listt-in-c-sharp
public class WrappedCollection<T> : IList<T>
{
	private readonly IList<T> _list = new List<T>();
	public WrappedCollection(IList<T> wrappedCollection)
	{
		this._list = wrappedCollection ?? throw new ArgumentNullException(nameof(wrappedCollection));
	}

#region Implementation of IEnumerable
	public IEnumerator<T> GetEnumerator()
	{
		return _list.GetEnumerator();
	}

	// Error if not using System.Collections;
	// https://stackoverflow.com/questions/8760322/troubles-implementing-ienumerablet
	// 'MyCollection<T>' does not implement interface member 'IEnumerable.GetEnumerator()'. 'MyCollection<T>.GetEnumerator()' cannot implement 'IEnumerable.GetEnumerator()' because it does not have the matching return type of 'IEnumerator'.
	IEnumerator IEnumerable.GetEnumerator()
	{
		return this.GetEnumerator();
	}

#endregion
#region Implementation of ICollection<T>
	public void Add(T item)
	{
		_list.Add(item);
	}

	// Implement methods that do make sense by passing the call to the wrapped collection
	//    public void Add(T item)
	//    {
	//        this.wrappedCollection.Add(item);
	//    }
	// "hide" methods that don't make sense by explicitly implementing them and
	// throwing a NotSupportedException
	//void IList<T>.RemoveAt(int index)
	//{
	//    throw new NotSupportedException();
	//}
	public bool Remove(T item)
	{
		return _list.Remove(item);
	}

	public void Clear()
	{
		_list.Clear();
	}

	public bool Contains(T item)
	{
		return _list.Contains(item);
	}

	public void CopyTo(T[] array, int arrayIndex)
	{
		_list.CopyTo(array, arrayIndex);
	}

	public int Count => _list.Count;
	public bool IsReadOnly => _list.IsReadOnly;
#endregion
#region Implementation of IList<T>
	public int IndexOf(T item)
	{
		return _list.IndexOf(item);
	}

	public void Insert(int index, T item)
	{
		_list.Insert(index, item);
	}

	public void RemoveAt(int index)
	{
		_list.RemoveAt(index);
	}

	public T this[int index] { get => _list[index]; set => _list[index] = value; }
#endregion
#region Your Added Stuff
// Add new features to your collection.
#endregion
}

// ###################            ##################################      WrappedCollection      ##################################            ###################
// ###################            ##################################      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 OutlookDefaultDateForInvalidEntry(this DateTime @this)
	{
		if (CultureInfo.CurrentCulture.Name.ToString() == "pt-BR")
			return Convert.ToDateTime("30/12/1899 00:00:00"); // ApplicationServices.OutlookDefaultDateForInvalid;
		return Convert.ToDateTime("12/30/1899 00:00:00"); 
	}
	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();
	}
    public static string TrimLastCharacter(this String str) => String.IsNullOrEmpty(str) ? str : str.TrimEnd(str[str.Length - 1]);
	/// <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);
	/// <summary>
	/// https://stackoverflow.com/questions/7461080/fastest-way-to-check-if-string-contains-only-digits-in-c-sharp
	/// TryParse won't work in some situations, like what happens if the string is a credit card number with 16 digits
	/// or if DateTime is in sortable format, like "20210620150000"
	/// </summary>
	/// <param name = "this"></param>
	/// <returns></returns>
	public static bool IsNumber(this string @this) => int.TryParse(@this, out var number);
	public static bool IsDigit(this string @this) => @this.All(c => c >= '0' && c <= '9');
}

// ###################            ##################################      StringTextExtensions      ##################################            ###################
// ###################            ##################################      EasyOfficeFolderExtensions      ##################################            ###################
public static class EasyOfficeFolderExtensions
{
	public static string GetParentFolder(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(":", ":\\");
	}
}

// ###################            ##################################      EasyOfficeFolderExtensions      ##################################            ###################
// ###################            ##################################      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;
using System.Diagnostics;
​
//using PatientManagerMD.ResourceCentral.ExtensionMethods;
//using PatientManagerMD.ResourceCentral.Support;
//using System.Collections.Generic;
//using System.Linq;
//using Microsoft.Toolkit.Uwp.Notifications;
public class Program
{
    public static void Main()
    {
        //Console.WriteLine("Hello World");
        // Set the current culture
        //var culture = new CultureInfo("pt-BR"); //("en-US");      
        var culture = new CultureInfo("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}");
        Console.WriteLine("------------------------------------------------------------------------------------");
        CultureInfo.CurrentCulture = culture;       
        CanCreate_DocNameElementsMount();
    }
​
    public static void CanCreate_DocNameElementsMount()
    {
var nameToParse = "US abdominal-cisto hepático_5f9a739a-0b2e-4fcc-9228-81035e6e50ea da internação de 2803 até 03062022 - 23122022 v3.docx";
    var docElements = new List<ElementDescription>();
    //"------------------------------------------------------------------------------------"
    var elementGuid = InNameGUID.CreateInstance(nameToParse, DocNamePart.Middle);
    docElements.Add(ElementDescription.CreateInstance(elementGuid, DocNamePart.Middle, ElementRelativePosition.First, -1));
    nameToParse = nameToParse.Replace(elementGuid.GUID, string.Empty);
    //"------------------------------------------------------------------------------------"
    var elementVer = VersionInSentence.CreateInstance(nameToParse); //"Junk before v2");
    docElements.Add(ElementDescription.CreateInstance(elementVer, DocNamePart.Last, ElementRelativePosition.First, -1));
    nameToParse = nameToParse.Replace(elementVer.Version, string.Empty);
    //"------------------------------------------------------------------------------------"
    var cultureInfo = new CultureInfo("pt-BR");
    var elementInt = IntervalInSentence.CreateInstance(nameToParse /*"de 2804 até 03052022"*/, cultureInfo);
    docElements.Add(ElementDescription.CreateInstance(elementInt, DocNamePart.Middle, ElementRelativePosition.Last, -1));
    nameToParse = nameToParse.Replace(elementInt.Interval.Value, string.Empty);
    //"------------------------------------------------------------------------------------"
    var elementDate = DateInSentence.CreateInstance(nameToParse /*"052022"*/, cultureInfo, null);
    docElements.Add(ElementDescription.CreateInstance(elementDate, DocNamePart.Last, ElementRelativePosition.First, -1));
    //"------------------------------------------------------------------------------------"
    //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})";
    //const string Grab_GUID_BEFOREparsing = @"(?<GUID>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})";
    //var rgx = new Regex(Grab_GUID_BEFOREparsing);
    //var originalText = $"Junk before {Guid.NewGuid()} junk after"; //
    //var match = rgx.Match(nameToParse);
    //Console.WriteLine($" {originalText}");
    //match.Dump();
    //"------------------------------------------------------------------------------------"
    foreach (var docElement in docElements)
    {
        Console.WriteLine(docElement);
        Console.WriteLine("------------------------------------------------------------------------------------");
    }
    //docNameElements.Element.Add(ElementDescription.CreateInstance(WhichElementItIs.FileNameDate, "052022", DocNamePart.Last, ElementRelativePosition.Last, -1));
    //docNameElements.Element.Add(ElementDescription.CreateInstance(WhichElementItIs.FileNameInterval, "de 2804 até 03052022", DocNamePart.Middle, ElementRelativePosition.Last, -1));
    //docNameElements.Element.Add(ElementDescription.CreateInstance(WhichElementItIs.VersionWithPrefix, "v2", DocNamePart.Last, ElementRelativePosition.First, -1));
    //var count = docNameElements.Element.Count == numberElem ? string.Empty : ($": it should be {numberElem} instead of {docNameElements.Element.Count}");
    //Console.WriteLine($"-----------------------Testing docNameElements.Element.Count-------------------------------------------------");
    //Console.WriteLine($"docNameElements.Element.Count = {numberElem}: {docNameElements.Element.Count == numberElem} {count}");
    //Console.WriteLine($"-----------------------Testing docNameElements.Element.Count-------------------------------------------------");
    //Console.WriteLine($"{WhichElementItIs.FileNameInterval.ToString()} = Middle: {interval.FirstOrDefault() == DocNamePart.Middle}");
    // (from x in Items where x.Id == 123 select x).FirstOrDefault();
    // var item1 = Items.FirstOrDefault(x => x.Id == 123);
    //Console.WriteLine($"{WhichElementItIs.FileNameInterval.ToString()} is in position 1: {elemInterval.FirstOrDefault() == docNameElements.Element[1]}");
    }
}
​
// ###################            ##################################      Enums      ##################################            ###################
public enum DateFormat
{
    Unknown = -99,
    [Description("ano(s)")]
    NumYears = -4,
    [Description("mês/meses")]
    NumMonths = -3,
    [Description("dia(s)")]
    NumDays = -2,
    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
}
​
// Primitives or References
public enum TypeOfElement
{
    @Null = -1,
    @Unclassified = 0,
    @String = 1,
    @Int,
    @Float,
    @DateTime,
    //Above primitives
    //Below References
    @VersionNumberOnly,
    @VersionWithPrefix,
    @Date,
    @Interval,
    @GUID,
    @DrugNameDose
}
​
// ###################            ##################################      Enums      ##################################            ###################
// ###################            ##################################  NOT USED  Element      ##################################            ###################
// ###################            ##################################   NOT USED  Element      ##################################            ###################
// ###################            ##################################   Interface and Base      ##################################            ###################
public interface IElementType : IComparable
{
//public ElementType ElemValue { get; set; }
//public TypeOfElement TypeOfElem { get; }
}
​
public class BaseElement : ValueObject
{
    public int StartIndex { get; set; } = -1;
    public string ConnectorBefore { get; set; } = string.Empty;
    /// <summary>
    /// Text where the element was extracted from
    /// </summary>
    public string OriginalText { get; private protected set; } = string.Empty;
    public Result<string> ElementValue { get; set; } = Result.Failure<string>("No value");
#region Overrides of ValueObject
    protected override IEnumerable<IComparable> GetEqualityComponents()
    {
        yield return StartIndex;
        yield return ConnectorBefore;
        yield return OriginalText;
    }
#endregion
}
​
// ###################            ##################################   Interface and Base      ##################################            ###################
// ###################            ##################################      ElementDescription      ##################################            ###################
// https://stackoverflow.com/questions/10712933/how-do-i-correctly-wrap-a-dictionaryt-u-and-expose-an-enumerator
// https://stackoverflow.com/questions/7444395/encapsulate-collection-in-c-sharp
// https://stackoverflow.com/questions/1176416/implementing-ilist-interface
// https://stackoverflow.com/questions/3464841/how-to-get-the-index-of-element-in-the-listt-in-c-sharp
public class ElementDescription : ValueObject
{
    private ElementDescription(IElementType elem, DocNamePart whichPart, ElementRelativePosition relativePosition, int startIndex)
    {
        ClassifyTypeOfElement(elem);
        WhichPart = whichPart;
        RelativePosition = relativePosition;
        Value = elem;
        Start = startIndex;
    }
​
    public static ElementDescription CreateInstance(IElementType elem, DocNamePart whichPart, ElementRelativePosition relativePosition, int startIndex)
    {
        return new ElementDescription(elem, whichPart, relativePosition, startIndex);
    }
​
    public static ElementDescription NullElementDescription() => new(null, DocNamePart.NoPart, ElementRelativePosition.DoesNotExist, int.MinValue);
    public ElementRelativePosition RelativePosition { get; set; }
​
    public DocNamePart WhichPart { get; set; }
​
    //DONE: try to strong type below
    public IElementType Value { get; set; }
​
    public TypeOfElement TypeOfElem { get; private set; } // => Value.TypeOfElem;
​
    public string ConnectorBefore { get; set; }
​
    /// <summary>
    /// Zero-based index of start in original Part (Value) string
    /// </summary>
    public int Start { get; private set; }
​
    private void ClassifyTypeOfElement(object elem)
    {
        switch (elem)
        {
            case int i:
                Console.WriteLine($"The object is an int with value {i}");
                TypeOfElem = TypeOfElement.Int;
                break;
            case float f:
                Console.WriteLine($"The object is an float with value {f}");
                TypeOfElem = TypeOfElement.Float;
                break;
            case string s:
                Console.WriteLine($"The object is a string with value {s}");
                TypeOfElem = TypeOfElement.String;
                break;
            case DateTime d:
                Console.WriteLine($"The object is a DateTime with value {d}");
                TypeOfElem = TypeOfElement.DateTime;
                break;
            case VersionInSentence v:
                TypeOfElem = v.HasVersionAnyPrefix ? TypeOfElement.VersionWithPrefix : TypeOfElement.VersionNumberOnly;
                //Console.WriteLine($"The object is a VersionInSentence type {TypeOfElem.GetDescription()} with value {v}");                
                break;
            case DateInSentence d:
                //Console.WriteLine($"The object is a DateInSentence with value {d}");
                TypeOfElem = TypeOfElement.Date;
                break;
            case IntervalInSentence i:
                //Console.WriteLine($"The object is a IntervalInSentence with value {i}");
                TypeOfElem = TypeOfElement.Interval;
                break;
            case InNameGUID i:
                Console.WriteLine($"The object is a InNameGUID with value {i}");
                TypeOfElem = TypeOfElement.GUID;
                break;
            case MedicineAndDosageInSentence i:
                Console.WriteLine($"The object is a MedicineAndDosageInSentence with value {i}");
                TypeOfElem = TypeOfElement.DrugNameDose;
                break;
            case null:
                Console.WriteLine("The object is null");
                TypeOfElem = TypeOfElement.Null;
                break;
            default:
                Console.WriteLine("The object is of an unknown type");
                TypeOfElem = TypeOfElement.Unclassified;
                break;
        }
    }
​
    public override string ToString()
    {
        return $"Element {TypeOfElem.GetDescription()} is in {WhichPart}, starting at position {(Start > -1 ? Start : "fixa")}: \n \t {Value.ToString()}";
    }
​
    protected override IEnumerable<IComparable> GetEqualityComponents()
    {
        yield return Value;
        yield return TypeOfElem;
        yield return ConnectorBefore;
        yield return WhichPart;
        yield return Start;
    }
}
​
// ###################            ##################################      ElementDescription      ##################################            ###################
// ###################            ##################################      DocPartElementsMount      ##################################            ###################
// ###################            ##################################      DocPartElementsMount      ##################################            ###################
// ###################            ##################################      InNameGUID       ##################################            ###################
public class InNameGUID : BaseElement, IElementType
{
    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 const string Grab_GUID_BEFOREparsing = @"(?<GUID>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})";
    private InNameGUID(DocNamePart namePart, string partToParse)
    {
        OriginalText = partToParse;
        Part = namePart;
    }
​
    public static InNameGUID CreateInstance(string part, DocNamePart namePart)
    {
        var instance = new InNameGUID(namePart, part);
        Console.WriteLine($"text to parse {part}");
        if (instance.GetGUID())
            return instance;
        return NullGUID();
    }
​
    //public TypeOfElement TypeOfElem => TypeOfElement.GUID;
    public bool NoGUID => string.IsNullOrEmpty(GUID);
    public static InNameGUID NullGUID() => new(DocNamePart.NoPart, string.Empty);
    public bool GetGUID()
    {
        var rgx = new Regex(Grab_GUID_BEFOREparsing);//Grab_GUID_treated);
        var match = rgx.Match(this.OriginalText);
        Console.WriteLine($"text to parse GUID {this.OriginalText}");
        //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, Part, match.Groups["GUID"].Value) : NullGUID();
        if (match.Success)
        {
            StartIndex = match.Groups["GUID"].Index;
            End = match.Groups["GUID"].Length - 1;
            GUID = match.Groups["GUID"].Value;
            Console.WriteLine($"GUID {GUID}");
            return true;
        }
​
        //      1   2           
        //  0   1   2   3   4   5
        //? Result.Success(match.Groups["GUID"].Value.Trim())
        //: Result.Failure<string>("No GUID in this part");
        Console.WriteLine($"GUID failed");
        return false;
    }
​
    public int End { get; private set; } = -1;
    //TODO: is DocNamePart necessary!?!?!? if yes, push to BaseElement
    public DocNamePart Part { get; private set; }
​
    public string GUID { get; private set; }
​
    public override string ToString()
    {
        return $"It is in {Part}, starting at position {(StartIndex > -1 ? StartIndex : "fixa")}; \n \t Value is {GUID}";
    }
​
    protected override IEnumerable<IComparable> GetEqualityComponents()
    {
        yield return Part;
        yield return End;
        yield return GUID;
        yield return NoGUID;
    }
}
​
// ###################            ##################################      InNameGUID       ##################################            ###################
// ###################            ##################################      MedicineDosageForm       ##################################            ###################
public class MedicineDosageForm : BaseElement, IElementType
{
    public string Name { get; }
​
    public string Dosage { get; }
​
    public string Unit { get; }
​
    public string Form { get; }
​
    //public string OriginalText { get; }
    private MedicineDosageForm(string originalText, string name, string dosage, string unit, string form)
    {
        Name = name;
        Dosage = dosage;
        Unit = unit;
        Form = form;
        OriginalText = originalText;
    }
​
    public static MedicineDosageForm CreateInstance(string originalText, string name, string dosage, string unit, string form = "comprimido")
    {
        return new MedicineDosageForm(originalText, name, dosage, unit, form);
    }
​
    public static MedicineDosageForm NullMedicine => new(string.Empty, string.Empty, string.Empty, string.Empty, string.Empty);
    public override string ToString()
    {
        return $"Drug: {Name} {Form} of {Dosage}{Unit}";
    }
​
#region Overrides of ValueObject
    protected override IEnumerable<IComparable> GetEqualityComponents()
    {
        yield return Name;
        yield return Dosage;
        yield return Unit;
        yield return Form;
        yield return OriginalText;
    }
#endregion
}
​
// ###################            ##################################      MedicineDosageForm       ##################################            ###################
// ###################            ##################################      DateInSentence      ##################################            ###################
public class DateInSentence : BaseElement, IElementType // ValueObject
{
    private readonly string _originalSentenceToParseDate;
    private readonly CultureInfo _cultureInfo;
    private readonly int? _maxPossibleYear;
    private readonly bool _forceDdmMorMmdd;
    private readonly int _minPossibleYear;
    private readonly bool _acceptWildCard;
    #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^^^^^^^^^^^^
    public const string GrabDatesWithMonthsInLettersOrPureNumbersFromFile = @"(?<relationandinterval>(?<temporalrelation> em | por )?(?<=\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))(?<timeframe> ano | anos | mês | meses | dia | dias )?)";
    //https://regex101.com/r/ZuUZy3/11^^^^^^^^^^^^
    //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
    #region Public Fields
    public string DateText { get; private set; } = string.Empty;
    public DateTime DateAndTime { get; private set; } = DateTime.MinValue;
    /// <summary>
    /// When TypeInterval == TimeFrame, DateTime == DateTime.MinValue and
    /// here will be stored Number of Days, Months or Years
    /// </summary>
    //[JsonIgnore]
    public int IntervalTimeFrame => int.Parse(DateText);
    public DateFormat Mask { get; private set; } = DateFormat.NoDate;
    public CertaintyAboutElement CertaintyAbout { get; private set; } = CertaintyAboutElement.NonExisting;
    public bool IsDDMM => _cultureInfo?.Name == "pt-BR";
    #endregion Public Fields
    #region Constructors
    //[JsonConstructor]
    private DateInSentence()
    {
    }
​
    private DateInSentence(string dateText, DateTime dateTime, DateFormat mask, CertaintyAboutElement certaintyAbout)
    {
        DateText = dateText;
        DateAndTime = dateTime;
        Mask = mask;
        CertaintyAbout = certaintyAbout;
    }
​
    private DateInSentence(string originalSentenceToParseDate, CultureInfo cultureInfo, int? maxPossibleYear, bool forceDDMMorMMDD, int minPossibleYear, bool acceptWildCard)
    {
        _originalSentenceToParseDate = originalSentenceToParseDate;
        _cultureInfo = cultureInfo;
        _maxPossibleYear = maxPossibleYear ??= GetCurrentYearPlus(3);
        _forceDdmMorMmdd = forceDDMMorMMDD;
        _minPossibleYear = minPossibleYear;
        _acceptWildCard = acceptWildCard;
    }
​
    public static DateInSentence NullDate => new(string.Empty, DateTime.MinValue, DateFormat.NoDate, CertaintyAboutElement.NonExisting);
    public static DateInSentence ChangeMask(DateInSentence date, DateFormat newMask)
    {
        return CreateInstance(date.DateText, date.DateAndTime, newMask);
    }
​
    public static DateInSentence ChangeToYYYY(DateInSentence 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.DateAndTime, DateFormat.yyyy);
    }
​
    public static DateInSentence ChangeToMMDD(DateInSentence 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.DateAndTime, DateFormat.MMdd);
    }
​
    public static DateInSentence ChangeToDDMM(DateInSentence 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.DateAndTime, DateFormat.ddMM);
    }
​
    public static DateInSentence CreateInstanceTimeFrame(string dateText, DateFormat mask, CertaintyAboutElement certaintyAbout = CertaintyAboutElement.AbsolutelyCertain)
    {
        //if (!int.TryParse(dateText, out _)) throw new ArgumentException("dateText must be a number");
        return new DateInSentence(dateText, DateTime.MinValue, mask, certaintyAbout);
    }
​
    public static DateInSentence CreateInstance(string dateText, DateTime dateTime, DateFormat mask, CertaintyAboutElement certaintyAbout = CertaintyAboutElement.AbsolutelyCertain)
    {
        return new DateInSentence(dateText, dateTime, mask, certaintyAbout);
    }
​
    /// <summary>
    /// Create Instance inferring Mask and Format for Date Parsing
    /// </summary>
    public static DateInSentence CreateInstance(string dateToParse, CultureInfo cultureInfo, int? maxPossibleYear, bool forceDDMMorMMDD = false, int minPossibleYear = 1990, bool acceptWildCard = true)
    {
        var dateParsing = new DateInSentence(dateToParse, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
        var dateExtracted = dateParsing.GetDate(dateToParse, (-1, -1));
        if (dateExtracted.IsFailure) return DateInSentence.NullDate;
​
        var maskForDateParsing = string.Empty;
        DateTime parsedDate = DateTime.MinValue;
        var raw = dateExtracted.Value;
        // TryParse won't work in some situations, like what happens if the string is a credit card number with 16 digits
        // or if DateTime is in sortable format, like "20210620150000"      
        //if (dateToParse.IsNumber())
        if (raw.IsDigit())
        {
            if (raw.Length == DateFormat.sortable.GetDescription().Length) //yyyyMMddHHmmss
            {
                //[Description("yyyyMMddHHmmss")]
                //sortable,
                dateParsing.Mask = DateFormat.sortable;
            }
            //[Description("dd/MM/yyyy HH:mm:ss")]
            //completeUpToSeconds,
            //[Description("MM/dd/yyyy HH:mm:ss")]
            //completeUpToSecondsUS,
            else if (raw.Length == 8) //ddmmyyyy or mmddyyyy
            {
                dateParsing.Mask = dateParsing.IsDDMM ? DateFormat.ddMMyyyy : DateFormat.MMddyyyy;
            }
            else if (raw.Length == 6) //MMyyyy 
            {
                dateParsing.Mask = DateFormat.MMyyyy;
            }
            else if (raw.Length == 4) //ddMM OR MMdd OR yyyy
            {
                var yyyyToTestIfWithinAllowedRange = DateTime.MinValue;
                var maybeDDMMorMMDD = IsItPossibleToBeDDMMOrMMDD(raw, cultureInfo);
                //DateTime.TryParseExact(dateParsing, DateFormat.ddMM.GetDescription(), cultureInfo, DateTimeStyles.None, out _) ||
                // DateTime.TryParseExact(dateParsing, DateFormat.MMdd.GetDescription(), cultureInfo, DateTimeStyles.None, out _);
                var maybeYYYY = DateTime.TryParseExact(raw, DateFormat.yyyy.GetDescription(), cultureInfo, DateTimeStyles.None, out yyyyToTestIfWithinAllowedRange);
                if ((maybeDDMMorMMDD && !maybeYYYY) || forceDDMMorMMDD)
                    dateParsing.Mask = dateParsing.IsDDMM ? DateFormat.ddMM : DateFormat.MMdd;
                else if (!maybeDDMMorMMDD && maybeYYYY)
                    dateParsing.Mask = DateFormat.yyyy;
                else if (maybeDDMMorMMDD && maybeYYYY)
                { //assume yyyy if possible ????
                    dateParsing.CertaintyAbout = 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
                        dateParsing.Mask = DateFormat.yyyy;
                    else
                        dateParsing.Mask = dateParsing.IsDDMM ? DateFormat.ddMM : DateFormat.MMdd;
                }
                else if (maybeDDMMorMMDD && maybeYYYY)
                {
                    //?????
                    dateParsing.Mask = DateFormat.NoDate;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.NonExisting;
                }
            }
            else if (raw.Length == 2) //dd OR MM OR yy
            {
                throw new NotImplementedException("InferMaskAndFormatForDateParsing: dateParsing.Length == 2");
            }
​
            //if (DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), cultureInfo, DateTimeStyles.None, out parsedDate))
            //{
            //  dateParsing.DateAndTime = parsedDate;
            //  dateParsing.DateText = raw;
            //  dateParsing.ElementValue = Result.Success(raw);
            //  return dateParsing;
            //}
        }
        else //if (!raw.IsDigit()) MMM or MMMM or ddd or dd or tt
        {
            if (raw.Contains(WildCardForDate) && raw.Length == 4)
            { //202_
                dateParsing.Mask = DateFormat.yyyy;
                dateParsing.DateText = raw;
                dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
                return dateParsing;
            }
            if (!raw.Contains(WildCardForDate) && raw.Length == 7)
            { //fev2021
                dateParsing.Mask = DateFormat.MMMyyyy;
                //_ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), cultureInfo, DateTimeStyles.None, out parsedDate);
                //dateParsing.DateText = raw;
                //dateParsing.DateAndTime = parsedDate;
                dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
                //return dateParsing;
            }
​
            //GrabDatesWithMonthsInLettersOrPureNumbersFromFile
            //grab: 202_
            //[Description("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'")]
            //universalSortable     
            throw new NotImplementedException("InferMaskAndFormatForDateParsing: dateParsing is not digit, ie, MMM or MMMM or ddd or dd or tt");
        }
        if (DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), cultureInfo, DateTimeStyles.None, out parsedDate))
        {
            dateParsing.DateAndTime = parsedDate;
            dateParsing.DateText = raw;
            dateParsing.ElementValue = Result.Success(raw);
            return dateParsing;
        }
        dateParsing.ElementValue = Result.Failure<string>("No date stamp in this file name");
        return DateInSentence.NullDate; // dateParsing;
                                        //DateInSentence.CreateInstance(raw, parsedDate, dateParsing.Mask, dateParsing.CertaintyAbout);
    }
​
    public static DateInSentence CreateInstanceFromSentence(string dateToParse, CultureInfo cultureInfo, (int start, int end) forbiddenZoneCoordinates, int? maxPossibleYear, bool forceDDMMorMMDD = false, int minPossibleYear = 1990, bool acceptWildCard = true)
    {
        //var dateInSentence = new DateInSentence(dateToParse, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
        var hasDate = GetDateStatic(dateToParse, cultureInfo, forbiddenZoneCoordinates, acceptWildCard);
        if (hasDate.IsFailure)
            return DateInSentence.NullDate;
        return CreateInstance(hasDate.Value, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
    }
​
    public static Result<DateInSentence> Update(string date, DateInSentence valueDateInSentence)
    {
        var tryDate = CreateInstance(date, valueDateInSentence._cultureInfo, valueDateInSentence._maxPossibleYear, valueDateInSentence._forceDdmMorMmdd, valueDateInSentence._minPossibleYear, valueDateInSentence._acceptWildCard);
        if (tryDate == NullDate)
            return Result.Failure<DateInSentence>("Invalid date");
        return Result.Success(tryDate);
    }
​
    public Result<string> GetDate(string partToTest, (int start, int end) forbiddenZoneCoordinates)
    //public static Result<string> GetDateStatic(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 = ReturnDateResult(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 = ReturnDateResult(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 = ReturnDateResult(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;
    }
​
    #endregion Constructors
    #region Private Methods
    public static Result<string> GetDateStatic(string partToTest, CultureInfo cultureInfo, (int start, int end) forbiddenZoneCoordinates, bool acceptWildCard = true)
    //public static Result<string> GetDateStatic(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 = ReturnDateResult(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 = ReturnDateResult(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 = ReturnDateResult(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;
    }
​
    internal static int GetCurrentYearPlus(int toAddCurrent) => DateTime.Now.Year + toAddCurrent;
    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 _);
    }
​
    private 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, new CultureInfo("pt-BR")))
        //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 (acceptWildCard && dateWithoutSpace.Contains(WildCardForDate))
        {
            return Result.Success(dateWithoutSpace);
        }
​
        //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> ReturnDateResult(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;
    }
​
    public override string ToString()
    {
        return $"{DateText} with mask {Mask}: {DateAndTime}; certainty: {CertaintyAbout}";
    }
​
    #endregion Private Methods
    #region Overrides of ValueObject
    protected override IEnumerable<IComparable> GetEqualityComponents()
    {
        yield return DateText;
        yield return DateAndTime;
        yield return Mask;
        yield return CertaintyAbout;
    }
    #endregion
}
​
// ###################            ##################################      DateInSentence      ##################################            ###################
// ###################            ##################################      IntervalInSentence      ##################################            ###################
public enum IntervalType
{
    Normal = 0, //"de 1203 até 20041999"
    TemporalClue //"em 082021"
}
​
public class IntervalInSentence : BaseElement, IElementType
{
    #region Private Constants
    private readonly string _cultureInfo;
    private readonly bool _sameFrameIntervalIsAllowed;
    private readonly bool _forceBeginDatePreviousYearIfReasonable;
    private readonly string _errorMsg;
    private Result<string> _candidateBegin;
    private Result<string> _candidateEnd;
    #endregion Private Constants
    #region Public Constants
    /// <summary>
    /// Should check for equality between relationandinterval and intervalordate; if so, the interval is invalid and should be ignored
    /// </summary>
    public const string GrabDatesWithMonthsInLettersOrPureNumbersFromFile = @"(?<relationandinterval>(?<temporalrelation> em | por )?(?<=\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))(?<timeframe> ano | anos | mês | meses | dia | dias )?)";
    //https://regex101.com/r/ZuUZy3/11^^^^^^^^^^^^
    //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
    #region Public Fields
    public IntervalType IntervalType { get; private set; }
​
    public string OriginalInterval { get; private set; }
​
    public Result<string> Interval { get; private set; }
​
    public string TextTemporalRelation { get; private set; }
​
    public string TextBetween { get; private set; }
​
    public string TimeFrame { get; private set; }
​
    public DateInSentence DateBegin { get; private set; }
​
    public DateInSentence DateEnd { get; private set; }
​
    public TypeOfElement TypeOfElem => TypeOfElement.Interval;
    public CertaintyAboutElement CertaintyAboutDateBegin => DateBegin?.CertaintyAbout ?? CertaintyAboutElement.NonExisting;
    public CertaintyAboutElement CertaintyAboutDateEnd => DateEnd?.CertaintyAbout ?? CertaintyAboutElement.NonExisting;
    public bool DateBeginHadToGoBackOneYear { get; private set; }
​
    #endregion Public Fields
    #region Constructors
    public static IntervalInSentence Null
    {
        get
        {
            var nullInterval = new IntervalInSentence(string.Empty, CultureInfo.CurrentCulture, false, false, "No interval date stamp in this file name");
            nullInterval.Interval = Result.Failure<string>(nullInterval._errorMsg);
            return nullInterval;
        }
    }
​
    //[JsonConstructor]
    private IntervalInSentence()
    {
    }
​
    private IntervalInSentence(string originalInterval, CultureInfo cultureInfo, bool sameFrameIntervalIsAllowed, bool forceBeginDatePreviousYearIfReasonable, string errorMsg)
    {
        _cultureInfo = cultureInfo.Name;
        _sameFrameIntervalIsAllowed = sameFrameIntervalIsAllowed;
        _forceBeginDatePreviousYearIfReasonable = forceBeginDatePreviousYearIfReasonable;
        _errorMsg = errorMsg;
        OriginalInterval = originalInterval;
    }
​
    internal static IntervalInSentence CreateInstance(string interval, CultureInfo cultureInfo, bool forceBeginDatePreviousYearIfReasonable = false, bool sameFrameIntervalIsAllowed = false, string errorMsg = "No interval date stamp in this file name")
    {
        var intervalInSentence = new IntervalInSentence(interval, cultureInfo, sameFrameIntervalIsAllowed, forceBeginDatePreviousYearIfReasonable, errorMsg);
        return !intervalInSentence.GetIntervalDates(interval) ? IntervalInSentence.Null : intervalInSentence;
    }
​
    #endregion Constructors
    #region Private Methods
    private bool IsDDMM => _cultureInfo == "pt-BR";
    /// <summary>
    ///TODO 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 valid, but I do not know for sure
    /// </summary>
    /// <param name = "partToTest"></param>
    /// <param name = "errorMsg"></param>
    /// <returns></returns>
    private bool GetIntervalDates(string partToTest)
    {
        if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest))
            return false;
        var hasInterval = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "interval", _errorMsg);
        var allErrors = string.Empty;
        //var errorMsg1 = string.Empty; var errorMsg2 = string.Empty;
        if (hasInterval.IsSuccess)
        {
            Interval = hasInterval;
            _candidateBegin = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "datebegin", _errorMsg);
            //allErrors = string.IsNullOrEmpty(_errorMsg) ? string.Empty : _errorMsg;
            _candidateEnd = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "dateend", _errorMsg);
            //allErrors += string.IsNullOrEmpty(errorMsg1) ? string.Empty : $";\n{errorMsg2}";
            if (_candidateBegin.IsFailure || _candidateEnd.IsFailure)
            {
                //_errorMsg = CompoundErrorMsgs
                ElementValue = Result.Failure<string>( $"No date stamp in this file name because: \n {_errorMsg}");
                return false;
            }
            var intervalDates = TryCompareIntervalDates(_candidateBegin.Value, _candidateEnd.Value);
            if (intervalDates.dateBegin.IsFailure && intervalDates.dateEnd.IsFailure)
            {
                ElementValue = Result.Failure<string>($"No date stamp in this file name because: \n {_errorMsg}");
                return false;
            }
            DateBegin = intervalDates.dateBegin.Value;
            DateEnd = intervalDates.dateEnd.Value;
            TextTemporalRelation = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "starting", _errorMsg).Value;
            TextBetween = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "link", _errorMsg).Value;
            IntervalType = IntervalType.Normal;
            TimeFrame = string.Empty;
            ElementValue = Result.Success(hasInterval.Value);
            return true; //return IsIntervalValid(partToTest); //? hasInterval : Result.Failure<string>(errorMsg);
        }
​
        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))
            {
                Interval = Result.Failure<string>(_errorMsg);
                ElementValue = Result.Failure<string>($"No date stamp in this file name because: \n {_errorMsg}");
                return false; // Result.Failure<string>(errorMsg);
            }
​
            Interval = result;
            IntervalType = IntervalType.TemporalClue;
            _candidateBegin = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "intervalordate", _errorMsg);
            _candidateEnd = _candidateBegin;
            if (_candidateBegin.IsFailure)
                return false;
            TextTemporalRelation = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "temporalrelation", _errorMsg).Value;
            TextBetween = string.Empty;
            TimeFrame = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "timeframe", _errorMsg).Value;
            DateBegin = DateInSentence.CreateInstanceTimeFrame(_candidateBegin.Value, DetermineTimeFrameType(result.Value));
            ElementValue = Result.Success(hasInterval.Value);
        }
​
        return _candidateBegin.IsSuccess && _candidateEnd.IsSuccess;
    }
    private string CompoundErrorMsgs (string @base, string first, string second = "")
    {
        if (string.IsNullOrEmpty(first)) return string.Empty;
        var allErrors = @$"{@base}\n{first}";
        allErrors += string.IsNullOrEmpty(_errorMsg) ? string.Empty : $";\n{second}";
        return allErrors;
    }
    private (Result<DateInSentence> dateBegin, Result<DateInSentence> dateEnd) TryCompareIntervalDates(string dateBegin, string dateEnd)
    {
        var errorMsg = "because BeginDate is After EndDate";
        // TryParse won't work in some situations, like what happens if the string is a credit card number with 16 digits
        // or if DateTime is in sortable format, like "20210620150000"
        //if (dateBegin.IsNumber() && dateEnd.IsNumber()) 
        if (dateBegin.IsDigit() && dateEnd.IsDigit())
        {
            switch (dateEnd.Length)
            {
                case 14: //DateFormat.sortable.GetDescription().Length;
                    if (dateBegin.Length == DateFormat.sortable.GetDescription().Length)
                    {
                        var beginDDMMDateIsInPreviousYear = CompareDatesWithSameFormat(dateBegin, dateEnd, out var format, out var validDates);
                        if (beginDDMMDateIsInPreviousYear)
                        {
                            return (Result.Success(DateInSentence.CreateInstance(dateBegin, validDates.dateStarted, format)), Result.Success(DateInSentence.CreateInstance(dateEnd, validDates.dateEnded, format)));
                        }
                    }
​
                    break;
                case 8: //ddMMyyyy
                    var formatEnd = IsDDMM ? DateFormat.ddMMyyyy : DateFormat.MMddyyyy;
                    var dateEndIsDDMM = DateTime.TryParseExact(dateEnd, formatEnd.GetDescription(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out var dateEnded);
                    if (dateBegin.Length == 8) //ddMMyyyy
                    {
                        var beginDDMMDateIsInPreviousYear = CompareDatesWithSameFormat(dateBegin, dateEnd, out var format, out var validDates);
                        if (beginDDMMDateIsInPreviousYear)
                        {
                            return (Result.Success(DateInSentence.CreateInstance(dateBegin, validDates.dateStarted, format)), Result.Success(DateInSentence.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(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out var ddMMBegin);
                        if (!dateBeginIsDDMM)
                        {
                            errorMsg = "because BeginDate is After EndDate";
                        }
                        else if (IsBeginDateReallyBeforeEndDate(ddMMBegin, dateEnded))
                        {
                            //return (Result.Success(InNameDate.CreateInstance(dateBegin + dateEnded.Year, ddMMBegin, formatEnd)), 
                            //      Result.Success(InNameDate.CreateInstance(dateEnd, dateEnded, formatEnd))
                            //     );
                            //Above return real tested date; below the original one
                            var formatBegin = IsDDMM ? DateFormat.ddMM : DateFormat.MMdd;
                            if (DateBeginHadToGoBackOneYear)
                                ddMMBegin = ddMMBegin.AddYears(-1);
                            return (Result.Success(DateInSentence.CreateInstance(dateBegin, ddMMBegin, formatBegin)), Result.Success(DateInSentence.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(DateInSentence.CreateInstance(dateBegin, new DateTime(dateEnded.Year, dateEnded.Month, dayBegin), DateFormat.dd));
                            return (dayInterval, Result.Success(DateInSentence.CreateInstance(dateEnd, dateEnded, formatEnd)));
                        }
​
                        errorMsg = "because BeginDate is After EndDate";
                    }
​
                    break;
                case 6: //MMyyyy
                    formatEnd = DateFormat.MMyyyy;
                    dateEndIsDDMM = DateTime.TryParseExact(dateEnd, formatEnd.GetDescription(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out dateEnded);
                    if (dateBegin.Length == 8) //almost impossible ddMMyyyy
                    {
                        throw new NotImplementedException("I did not implemented 'de ddMMyyyy até MMyyyy'");
                    }
                    else if (dateBegin.Length == 6) //MMyyyy
                    {
                        var dateBeginIsDDMM = DateTime.TryParseExact(dateBegin, formatEnd.GetDescription(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out var ddMMBegin);
                        if (IsBeginDateReallyBeforeEndDate(ddMMBegin, dateEnded))
                        {
                            return (Result.Success(DateInSentence.CreateInstance(dateBegin, ddMMBegin, formatEnd)), Result.Success(DateInSentence.CreateInstance(dateEnd, dateEnded, formatEnd)));
                        }
​
                        errorMsg = "because BeginDate is After EndDate";
                    }
                    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, null, sameFrameIntervalIsAllowed: _sameFrameIntervalIsAllowed);
                        if (result.dateBegin.CertaintyAbout != CertaintyAboutElement.NonExisting)
                        {
                            return (Result.Success(result.dateBegin), Result.Success(result.dateEnd));
                        }
​
                        errorMsg = "not existing BeginDate or EndDate";
                    }
                    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<DateInSentence>(errorMsg), Result.Failure<DateInSentence>(errorMsg));
    }
​
    private bool CompareDatesWithSameFormat(string dateBegin, string dateEnd, out DateFormat format, out (bool dateBeginIsDDMM, DateTime dateStarted, bool dateEndIsDDMM, DateTime dateEnded) validDates)
    {
        string errorMsg;
        var date = DateInSentence.CreateInstance(dateBegin, new CultureInfo(_cultureInfo), 2025, false);
        (var mask, format) = (date.Mask.GetDescription(), date.Mask);
        validDates = TryToParseDatesAsDDMM_MMDD(dateBegin, dateEnd, mask);
        bool beginDDMMDateIsInPreviousYear = false;
        if (validDates.dateStarted == DateTime.MinValue || validDates.dateEnded == DateTime.MinValue)
            return beginDDMMDateIsInPreviousYear;
        beginDDMMDateIsInPreviousYear = IsDDMMBeginDateReallyBeforeEndDate(dateBegin, dateEnd, format, _sameFrameIntervalIsAllowed);
        return beginDDMMDateIsInPreviousYear;
    }
​
    /// <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>
    private (DateInSentence dateBegin, DateInSentence dateEnd) DecideIfDateEndIsYYYYOrDDMM(string dateBeginToTest, string dateEndToTest, int? maxPossibleYear, int minPossibleYear = 1990, bool sameFrameIntervalIsAllowed = false)
    {
        maxPossibleYear ??= DateInSentence.GetCurrentYearPlus(3);
        var (isDateEndDubious, isDateBeginDubious, certaintyAboutYYYY) = DecideDegreeOfCertaintyAboutDates(dateBeginToTest, dateEndToTest);
        var dateBeginTry = DateInSentence.CreateInstance(dateBeginToTest, new CultureInfo(_cultureInfo), 2025, false);
        //var (maskForDDMM, formatForDDMM) = FormatForDDMMBasedOn(cultureInfo);         
        var (_, formatForDateBeginTry) = (dateBeginTry.Mask.GetDescription(), dateBeginTry.Mask);
        var dateBegin = DateInSentence.NullDate;
        var dateBeginIsYYYY = false;
        var dateBeginIsDDMM = false;
        var dateEnd = DateInSentence.NullDate;
        var dateEndIsYYYY = false;
        var dateEndIsDDMM = false;
        var (dateEnded, endDateMaybeYYYY) = TryToParseDateAsYYYY(dateEndToTest);
        var (dateStarted, beginDateMaybeYYYY) = TryToParseDateAsYYYY(dateBeginToTest);
        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
        (dateBeginIsYYYY, dateEndIsYYYY) = DetermineIfIntervalDatesShouldBeYYYY(isDateEndDubious, isDateBeginDubious, endDateMaybeYYYY, beginDateMaybeYYYY, dateEndIsYYYY, dateBeginIsYYYY);
        var beginCannotBeDDMMOrMMDD = !DateInSentence.IsItPossibleToBeDDMMOrMMDD(dateBeginToTest, new CultureInfo(_cultureInfo));
        if (beginCannotBeDDMMOrMMDD && !endDateMaybeYYYY)
        {
            if (dateStarted != dateEnded)
                return (DateInSentence.NullDate, DateInSentence.NullDate);
            //Below is by design; I do not allow interval like "between 2013 and 2013", unless for testing purposes
            if (dateStarted == dateEnded && !sameFrameIntervalIsAllowed)
                return (DateInSentence.NullDate, DateInSentence.NullDate);
        }
​
        if (dateBeginIsYYYY || beginCannotBeDDMMOrMMDD)
            (dateStarted, dateBeginIsYYYY) = TryToParseDateAsYYYY(dateBeginToTest);
        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...
            formatForDateBeginTry = IsDDMM ? DateFormat.ddMM : DateFormat.MMdd;
            (dateBeginIsDDMM, dateStarted, dateEndIsDDMM, dateEnded) = TryToParseDatesAsDDMM_MMDD(dateBeginToTest, dateEndToTest, formatForDateBeginTry.ToString());
        }
​
        if (dateBeginIsYYYY)
        {
            dateEndIsYYYY = DateTime.TryParseExact(dateEndToTest, DateFormat.yyyy.GetDescription(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out dateEnded);
            if (!dateEndIsYYYY)
                return (dateBegin, dateEnd);
            dateBegin = DateInSentence.CreateInstance(dateBeginToTest, dateStarted, DateFormat.yyyy, certaintyAboutYYYY);
            dateEnd = DateInSentence.CreateInstance(dateEndToTest, dateEnded, DateFormat.yyyy, certaintyAboutYYYY);
        }
        else if (dateBeginIsDDMM)
        {
            if (!dateEndIsDDMM || !IsDDMMBeginDateReallyBeforeEndDate(dateBeginToTest, dateEndToTest, formatForDateBeginTry, sameFrameIntervalIsAllowed))
                return (dateBegin, dateEnd);
            dateBegin = DateInSentence.CreateInstance(dateBeginToTest, dateStarted, formatForDateBeginTry, certaintyAboutYYYY);
            dateEnd = DateInSentence.CreateInstance(dateEndToTest, dateEnded, formatForDateBeginTry, certaintyAboutYYYY);
        }
​
        return (dateBegin, dateEnd);
    }
​
    private (bool isDateEndDubious, bool isDateBeginDubious, CertaintyAboutElement certaintyAboutYYYY) DecideDegreeOfCertaintyAboutDates(string dateBeginToTest, string dateEndToTest)
    {
        var dubiousDate = _cultureInfo == "pt-BR" ? DocNameHelper.dubiousDDMMOrYYYY() : DocNameHelper.dubiousMMDDOrYYYY();
        var isDateEndDubious = dubiousDate.Contains(dateEndToTest);
        var isDateBeginDubious = dubiousDate.Contains(dateBeginToTest);
        var certaintyAboutYYYY = isDateBeginDubious && isDateEndDubious ? CertaintyAboutElement.InformedGuess : CertaintyAboutElement.AbsolutelyCertain;
        return (isDateEndDubious, isDateBeginDubious, certaintyAboutYYYY);
    }
​
    /// <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>
    private bool IsDDMMBeginDateReallyBeforeEndDate(string dateBegin, string dateEnd, DateFormat dateFormat, bool sameFrameIntervalIsAllowed = false)
    {
        //var maskForDDMM = MaskForDateParsing(cultureInfo, dateFormat);
        var beginDateValid = DateTime.TryParseExact(dateBegin, dateFormat.GetDescription(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out var beginDate);
        //var beginDate = DateTime.ParseExact(dateBegin, dateFormat.GetDescription(), cultureInfo);
        var endDateValid = DateTime.TryParseExact(dateEnd, dateFormat.GetDescription(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out var endDate);
        if (!beginDateValid || !endDateValid)
            return false;
        //var endDate = DateTime.ParseExact(dateEnd, dateFormat.GetDescription(), cultureInfo);
        return IsBeginDateReallyBeforeEndDate(beginDate, endDate);
        //sameFrameIntervalIsAllowed ? beginDate <= endDate : beginDate < endDate;
    }
​
    //internal static (string mask, DateFormat dateFormat, CertaintyAboutElement degreeOfcertainty)
    private bool IsBeginDateReallyBeforeEndDate(DateTime dateBegin, DateTime dateEnd)
    {
        DateBeginHadToGoBackOneYear = false;
        var isBefore = _sameFrameIntervalIsAllowed ? dateBegin <= dateEnd : dateBegin < dateEnd;
        if (!isBefore && _forceBeginDatePreviousYearIfReasonable)
        {
            var dateBeginPreviousYear = dateBegin.AddYears(-1);
            isBefore = _sameFrameIntervalIsAllowed ? dateBeginPreviousYear <= dateEnd : dateBeginPreviousYear < dateEnd;
            DateBeginHadToGoBackOneYear = isBefore;
            return isBefore;
        }
​
        return isBefore;
    }
​
    private (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 bool AtLeastSomeDateIsDubiousAndBothDatesMaybeYYYY(bool endDateMaybeYYYY, bool beginDateMaybeYYYY)
    {
        return endDateMaybeYYYY && beginDateMaybeYYYY;
    }
​
    private bool IfNoDateIsDubious(bool isDateEndDubious, bool isDateBeginDubious)
    {
        return !isDateEndDubious && !isDateBeginDubious;
    }
​
    private bool IsValidEndDateYYYY(DateTime dateBegin, DateTime dateEnd, int minPossibleYear, int maxPossibleYear, bool sameYearIntervalIsAllowed)
    {
        if (!IsBeginDateReallyBeforeEndDate(dateBegin, dateEnd))
            return false;
        return dateEnd.Year >= minPossibleYear && dateEnd.Year <= maxPossibleYear;
    }
​
    private (DateTime dateParsed, bool tryParseExact) TryToParseDateAsYYYY(string dateToTest)
    {
        var tryParseExact = DateTime.TryParseExact(dateToTest, DateFormat.yyyy.ToString(), new CultureInfo(_cultureInfo), DateTimeStyles.None, out var dateParsed);
        return (dateParsed, tryParseExact);
    }
​
    private (bool dateBeginIsDDMM, DateTime dateStarted, bool dateEndIsDDMM, DateTime dateEnded) TryToParseDatesAsDDMM_MMDD(string dateBeginToTest, string dateEndToTest, string maskForDDMM)
    {
        var dateBeginIsDDMM = DateTime.TryParseExact(dateBeginToTest, maskForDDMM, new CultureInfo(_cultureInfo), DateTimeStyles.None, out var dateStarted);
        var dateEndIsDDMM = DateTime.TryParseExact(dateEndToTest, maskForDDMM, new CultureInfo(_cultureInfo), DateTimeStyles.None, out var dateEnded);
        return (dateBeginIsDDMM, dateStarted, dateEndIsDDMM, dateEnded);
    }
    private DateFormat DetermineTimeFrameType(string originalText)
    {
        if (originalText.Contains("dia"))
            return DateFormat.NumDays;
        if (originalText.Contains("mês") || originalText.Contains("meses"))
            return DateFormat.NumMonths;
        if (originalText.Contains("ano"))
            return DateFormat.NumYears;
        return DateFormat.Unknown;
    }
    #endregion Private Methods
​
    #region Draft
    private bool IsIntervalValid(string partToTest)
    {
        var validBeginInterval = DocNameHelper.DateTryParseExact(_candidateBegin.Value, out var beginInterval, CultureInfo.CurrentCulture);
        var validEndInterval = DocNameHelper.DateTryParseExact(_candidateEnd.Value, out var endInterval, CultureInfo.CurrentCulture);
        var isValid = beginInterval < endInterval;
        return isValid;
    }
​
    public override string ToString()
    {
        return $"Interval is type {IntervalType.GetDescription()}. \n \t Start Date is {DateBegin.ToString()} (certainty: {CertaintyAboutDateBegin.GetDescription()}) \n \t End Date is {DateEnd.ToString()} (certainty: {CertaintyAboutDateEnd.GetDescription()})";
    }
​
    #endregion Draft
    #region Overrides of ValueObject
    protected override IEnumerable<IComparable> GetEqualityComponents()
    {
        //yield return _candidateBegin;
        //yield return _candidateEnd;
        yield return _cultureInfo;
        yield return _sameFrameIntervalIsAllowed;
        yield return _forceBeginDatePreviousYearIfReasonable;
        yield return OriginalInterval;
        yield return DateBeginHadToGoBackOneYear;
        yield return TextBetween;
        yield return TextTemporalRelation;
        yield return TimeFrame;
        yield return DateBegin;
        yield return DateEnd;
        yield return TypeOfElem;
        yield return IntervalType;
        yield return CertaintyAboutDateBegin;
        yield return CertaintyAboutDateEnd;
    }
    #endregion
}
​
// ###################            ##################################      IntervalInSentence      ##################################            ###################
// ###################            ##################################      VersionInSentence      ##################################            ###################
public class VersionInSentence : BaseElement, IElementType
{
    private readonly string _originalSentenceToParseDate;
    #region Public Constants
    public const string GrabVersionFromFile = @"(?<version>\sv[ersionão]*[\d@]+[\w@]*|[\d@]+v[ersionão]*[\w@]*)";
    //https://regex101.com/r/BfGfIY/2 ^^^^^^^^^^^^^^^^^^^ 
    #endregion Public Constants
    public string Version { get; private set; }
​
    public string VersionPrefix => Version.ReturnOnlyNonNumericCharacters();
    public int VersionNumber => Version.ReturnOnlyNumbersAsInt()!.Value;
    public bool HasVersionAnyPrefix => VersionPrefix.Length > 0;
    public TypeOfElement TypeOfElem => HasVersionAnyPrefix ? TypeOfElement.VersionWithPrefix : TypeOfElement.VersionNumberOnly;
    private VersionInSentence(string partToTest)//, string parsedVersion)
    {
        _originalSentenceToParseDate = partToTest;
        ElementValue = Result.Failure<string>("No file version");
        //Version = parsedVersion;
    }
​
    public static VersionInSentence CreateInstance(string partToTest)
    {
        if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest)) return NullVersion;
        var instance =  new VersionInSentence(partToTest);//, version.Value);       
        instance.ElementValue = instance.GetVersion();
        if (instance.ElementValue.IsFailure)
            return NullVersion;
        instance.Version = instance.ElementValue.Value;
        return instance;
    }
​
    public static VersionInSentence NullVersion => new(string.Empty);
    private Result<string> GetVersion()//string partToTest)
    {
        //if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest))
        //  return Result.Failure<string>("No file version");
        var partToTest = _originalSentenceToParseDate;
        var version = GetVersionFromPart(partToTest);
        if (!version.IsFailure && version.Value.IsNumber())
        {
            return TestVersionNumberOnly(version.Value);
        }
​
        if (version.IsFailure && partToTest.Length < 3 && partToTest.IsNumber())
        {
            return TestVersionNumberOnly(partToTest);
        }
​
        if (version.IsFailure && partToTest.ReturnOnlyNumbers().Length > 0 && partToTest.ReturnOnlyNumbers().Length < 3 && partToTest.ReturnOnlyNumbers().IsNumber())
        {
            return TestVersionNumberOnly(partToTest.ReturnOnlyNumbers());
        }
​
        return version; // "2017"
    }
​
    private static Result<string> TestVersionNumberOnly(string candidateForVersion)
    {
        var candidate = int.Parse(candidateForVersion);
        if (candidate < 1 || candidate > 20)
            return Result.Failure<string>("No file version");
        return Result.Success(candidate.ToString());
    }
​
    private static Result<string> GetVersionFromPart(string partToTest)
    {
        var version = DocNameHelper.ReturnResult(GrabVersionFromFile, partToTest, "version", "No file version");
        if (version.IsFailure && !char.IsWhiteSpace(partToTest, 0))
            version = DocNameHelper.ReturnResult(GrabVersionFromFile, $" {partToTest}", "version", "No file version");
        return version;
    }
​
    public static Result<string> TryRecoverFileVersionOnlyNumber(Result<string> fileDateOrInterval, Result<string> partNameToTest)
    {
        // special case:
        //  Nome do paciente - exame laboratorial amplo - 122022 2.docx######
        //   FirstPartName: Nome do paciente
        //   MiddlePartName: exame laboratorial amplo
        //   MiddlePartNameOriginal: exame laboratorial amplo
        //   LastPartName: 2
        //   LastPartNameOriginal: 122022 2
        //   FileVersion: No file version
        //   FileDate: 122022
        var rest = string.Empty;
        int tryVersion;
        if (fileDateOrInterval.IsSuccess)
        {
            rest = partNameToTest.Value.Replace(fileDateOrInterval.Value, string.Empty).Trim();
            // if (!int.TryParse(rest, out tryVersion)) return Result.Failure<string>("No file version");
            int.TryParse(rest, out tryVersion);
            if (tryVersion is > 0 and < 20)
                return Result.Success(tryVersion.ToString());
        }
​
        // special case:
        //Nome do paciente - exame laboratorial amplo 3 - 23122022.docx######
        //FirstPartName: Nome do paciente
        //MiddlePartName: exame laboratorial amplo 3
        //MiddlePartNameOriginal: exame laboratorial amplo 3
        //LastPartName:
        //LastPartNameOriginal: 23122022
        //FileVersion: No file version
        //FileDate: 23122022
        var restNum = rest.ReturnOnlyNumbersToArray();
        if (restNum.Length != 1 || !int.TryParse(restNum[0].ToString(), out tryVersion))
            return Result.Failure<string>("No file version");
        return tryVersion is > 0 and < 20 ? Result.Success(tryVersion.ToString()) : Result.Failure<string>("No file version");
    }
​
    public override string ToString()
    {
        return $"It has a Value '{Version}'";
    }
​
    #region Overrides of ValueObject
    protected override IEnumerable<IComparable> GetEqualityComponents()
    {
        yield return _originalSentenceToParseDate;
        yield return Version;
        yield return TypeOfElem;
    }
    #endregion
}
​
​
// ###################            ##################################      VersionInSentence      ##################################            ###################
// ###################            ##################################      MedicineAndDosageInSentence      ##################################            ###################
public class MedicineAndDosageInSentence : BaseElement // ValueObject
{
#region Private Constants
#endregion Private Constants
#region Public Constants
    /// <summary>
    ///Should match:
    ///Gilda Elena Brandão Andrade D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Zolpidem SL 5 mg 082021.docx
    ///Gilda Elena Brandão Andrade D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Zolpidem CR 6,25 mg.docx
    ///x - RECEITUÁRIO CONTROLE ESPECIAL - trazodona retard 150 mg
    ///x - RECEITUÁRIO CONTROLE ESPECIAL - Prolopa HBS 100_25 mg.docx
    ///x - RECEITUÁRIO CONTROLE ESPECIAL - Prolopa orodispersível 125 mg.docx
    ///x - RECEITUÁRIO CONTROLE ESPECIAL - Parkidopa 25_250 mg
    ///x - RECEITUÁRIO CONTROLE ESPECIAL - Parkidopa 25_250 mg.docx
    ///x - RECEITUÁRIO CONTROLE ESPECIAL - pramipexol Sifrol 1,5 mg.docx
    ///x - RECEITUÁRIO CONTROLE ESPECIAL - Rivastigmina Exelon Patch 9 mg.docx
    /// </summary>
    public const string GrabDoseAndUnitOfMedicinesFromPartOfFile = @"(?<=-|- )?(?<complete>(?<medicine>(?:(?!RECEITUÁRIO CONTROLE ESPECIAL)\w+ ){1,4})(?<=[ ]{1,2})(?<dosewithunit>(?<dose>[\d,.]+|[\d]+_[\d]+)[ ]{0,2}(?<unit>mg|comp|cp|UI|g)))(?=[ .-]?)";
    //https://regex101.com/r/sbmaPI/1 ^^^^^^^^^^^^^^^^
#endregion Public Constants
#region Public Fields
    public string Name { get; private set; }
​
    public string Dosage { get; set; }
​
    public string Unit { get; set; }
​
    public string Form { get; set; }
​
#endregion Public Fields
#region Constructors
    private MedicineAndDosageInSentence(string originalText, string name, string dosage, string unit, string form)
    {
        Name = name;
        Dosage = dosage;
        Unit = unit;
        Form = form;
        OriginalText = originalText;
    }
​
    private MedicineAndDosageInSentence(string originalText)
    {
        OriginalText = originalText;
    }
​
    public static MedicineAndDosageInSentence CreateInstance(string originalText)
    {
        if (string.IsNullOrEmpty(originalText))
            return NullMedicine;
        var instance = new MedicineAndDosageInSentence(originalText);
        instance.TryFindMedicineDosageForm();
        return instance.ElementValue.IsFailure ? NullMedicine : instance;
    }
​
    public static MedicineAndDosageInSentence NullMedicine => new(string.Empty, string.Empty, string.Empty, string.Empty, string.Empty);
#endregion Constructors
#region Private Methods
    private void TryFindMedicineDosageForm()
    {
        Result<string> version;
        var rgx = new Regex(GrabDoseAndUnitOfMedicinesFromPartOfFile);
        var match = rgx.Match(OriginalText);
        //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
        //Result<MedicineDosageForm> result;
        //MedicineDosageForm toReturn;
        if (match.Success)
        {
            //toReturn = MedicineDosageForm.CreateInstance(
            //    match.Groups["complete"].Value,
            //    match.Groups["medicine"].Value.Replace("CONTROLE ESPECIAL", string.Empty).Trim(),
            //    match.Groups["dose"].Value,
            //    match.Groups["unit"].Value,
            //    "comprimido"
            //);
            OriginalText = match.Groups["complete"].Value;
            Name = match.Groups["medicine"].Value.Replace("CONTROLE ESPECIAL", string.Empty).Trim();
            Dosage = match.Groups["dose"].Value;
            Unit = match.Groups["unit"].Value;
            Form = "comprimido";
        //result = Result.Success(toReturn);
        }
        else
        {
        //result = Result.Failure<MedicineDosageForm>(errorMsg);
        }
​
        //if (!result.IsFailure) return result;
        //Try to look list of words only
        //until now is losing below
        //Gilda Elena Brandão Andrade D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Fosfomicina 20__.docx
        var criteria = new string[]{"Receita de Antibióticos", "Receita de Psicotrópicos"};
        var medicines = GetWordsThatPointsToType(criteria);
        foreach (var medicine in medicines)
        {
            if (!OriginalText.ToLowerInvariant().Contains(medicine.ToLowerInvariant()))
                continue;
            //toReturn = MedicineDosageForm.CreateInstance(medicine.CapitalizeFirstLetter()
            //    , medicine.CapitalizeFirstLetter(), "N/A", "N/A", "N/A");
            Name = medicine.CapitalizeFirstLetter();
            Dosage = "N/A";
            Unit = "N/A";
            Form = "N/A";
        //result = Result.Success(toReturn);
        }
    //return result;
    }
​
    private static IEnumerable<string> GetWordsThatPointsToType(string[] criteria)
    //private static List<string> GetWordsThatPointsToType(string[] criteria)
    {
        return new string[]{"Receita de Antibióticos", "Receita de Psicotrópicos"};
    }
​
#endregion Private Methods
#region Overrides of ValueObject
    protected override IEnumerable<IComparable> GetEqualityComponents()
    {
        yield return Name;
        yield return Dosage;
        yield return Unit;
        yield return Form;
    }
#endregion
}
​
// ###################            ##################################      MedicineAndDosageInSentence      ##################################            ###################
// ###################            ##################################      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
    //internal static string StripOffDateIntervalVersionAndDrug(string partToBeStrippedOff, DocPartElementsMount docNameElements, string date = "", string version = "", string interval = "", string medicineAndDose = "")
    //{
    //}
    //internal static string StripOffPartWithConnector(string partToBeStrippedOff, string partToStrip, WhichElementItIs whichElementItIs, DocPartElementsMount docNameElements)
    //{
    //}
    internal 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();
    }
​
    internal static bool DifficultyToTestPart(string partToTest)
    {
        return partToTest.Length > 10 && partToTest.DoesNotContainAnySpace();
    }
​
    internal 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
    internal static string[] dubiousDDMMOrYYYY() => new[]{"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
    internal static string[] dubiousMMDDOrYYYY() => new[]{""};
    //                              ^^^^^^^^^^^^^^^^^^^^^^^^^^ ??
#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>
    /// If yearToAssume == string.Empty, it will try to parse with no year 
    /// </summary>
    /// <param name = "yearToAssume"></param>
    /// <param name = "testDate"></param>
    /// <param name = "cultureInfo"></param>
    /// <param name = "dateWithNoYearAndWithoutSpace"></param>
    /// <returns></returns>
    internal static bool DateWithNoYearTryParseExact(string dateWithNoYearAndWithoutSpace, out DateTime testDate, CultureInfo cultureInfo, string yearToAssume)
    {
        //Guard.ThrowIfStringNullOrEmptyOrNotString(dateWithNoYearAndWithoutSpace, nameof(dateWithNoYearAndWithoutSpace));
        return DateTryParseExact(dateWithNoYearAndWithoutSpace + yearToAssume, out testDate, cultureInfo, string.IsNullOrEmpty(yearToAssume));
    }
​
    /// <summary>
    /// 
    /// </summary>
    /// <param name = "dateWithoutSpace"></param>
    /// <param name = "testDate"></param>
    /// <param name = "cultureInfo"></param>
    /// <param name = "forceDDMM"></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));
        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"
    }
//internal 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      ##################################            ###################
// ###################            ##################################      WrappedCollection      ##################################            ###################
// https://stackoverflow.com/questions/10712933/how-do-i-correctly-wrap-a-dictionaryt-u-and-expose-an-enumerator
// https://stackoverflow.com/questions/7444395/encapsulate-collection-in-c-sharp
// https://stackoverflow.com/questions/1176416/implementing-ilist-interface
// https://stackoverflow.com/questions/3464841/how-to-get-the-index-of-element-in-the-listt-in-c-sharp
public class WrappedCollection<T> : IList<T>
{
    private readonly IList<T> _list = new List<T>();
    public WrappedCollection(IList<T> wrappedCollection)
    {
        this._list = wrappedCollection ?? throw new ArgumentNullException(nameof(wrappedCollection));
    }
​
#region Implementation of IEnumerable
    public IEnumerator<T> GetEnumerator()
    {
        return _list.GetEnumerator();
    }
​
    // Error if not using System.Collections;
    // https://stackoverflow.com/questions/8760322/troubles-implementing-ienumerablet
    // 'MyCollection<T>' does not implement interface member 'IEnumerable.GetEnumerator()'. 'MyCollection<T>.GetEnumerator()' cannot implement 'IEnumerable.GetEnumerator()' because it does not have the matching return type of 'IEnumerator'.
    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
​
#endregion
#region Implementation of ICollection<T>
    public void Add(T item)
    {
        _list.Add(item);
    }
​
    // Implement methods that do make sense by passing the call to the wrapped collection
    //    public void Add(T item)
    //    {
    //        this.wrappedCollection.Add(item);
    //    }
    // "hide" methods that don't make sense by explicitly implementing them and
    // throwing a NotSupportedException
    //void IList<T>.RemoveAt(int index)
    //{
    //    throw new NotSupportedException();
    //}
    public bool Remove(T item)
    {
        return _list.Remove(item);
    }
​
    public void Clear()
    {
        _list.Clear();
    }
​
    public bool Contains(T item)
    {
        return _list.Contains(item);
    }
​
    public void CopyTo(T[] array, int arrayIndex)
    {
        _list.CopyTo(array, arrayIndex);
    }
​
    public int Count => _list.Count;
    public bool IsReadOnly => _list.IsReadOnly;
#endregion
#region Implementation of IList<T>
    public int IndexOf(T item)
    {
        return _list.IndexOf(item);
    }
​
    public void Insert(int index, T item)
    {
        _list.Insert(index, item);
    }
​
    public void RemoveAt(int index)
    {
        _list.RemoveAt(index);
    }
​
    public T this[int index] { get => _list[index]; set => _list[index] = value; }
#endregion
#region Your Added Stuff
// Add new features to your collection.
#endregion
}
​
// ###################            ##################################      WrappedCollection      ##################################            ###################
// ###################            ##################################      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 OutlookDefaultDateForInvalidEntry(this DateTime @this)
    {
        if (CultureInfo.CurrentCulture.Name.ToString() == "pt-BR")
            return Convert.ToDateTime("30/12/1899 00:00:00"); // ApplicationServices.OutlookDefaultDateForInvalid;
        return Convert.ToDateTime("12/30/1899 00:00:00"); 
    }
    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();
    }
    public static string TrimLastCharacter(this String str) => String.IsNullOrEmpty(str) ? str : str.TrimEnd(str[str.Length - 1]);
    /// <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);
    /// <summary>
    /// https://stackoverflow.com/questions/7461080/fastest-way-to-check-if-string-contains-only-digits-in-c-sharp
    /// TryParse won't work in some situations, like what happens if the string is a credit card number with 16 digits
    /// or if DateTime is in sortable format, like "20210620150000"
    /// </summary>
    /// <param name = "this"></param>
    /// <returns></returns>
    public static bool IsNumber(this string @this) => int.TryParse(@this, out var number);
    public static bool IsDigit(this string @this) => @this.All(c => c >= '0' && c <= '9');
}
​
// ###################            ##################################      StringTextExtensions      ##################################            ###################
// ###################            ##################################      EasyOfficeFolderExtensions      ##################################            ###################
public static class EasyOfficeFolderExtensions
{
    public static string GetParentFolder(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(":", ":\\");
    }
}
​
// ###################            ##################################      EasyOfficeFolderExtensions      ##################################            ###################
// ###################            ##################################      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      ##################################            ###################
​

Że też łże jeż? łże też! : True
Ada blada nici nadal bada. : True
Do geese see God? : True
Ada blada nitki nadal bada. : True
Do God see geese? : True

Cached Result
Last Run:	3:52:23 am
Compile:	0.283s
Execute:	0.016s
Memory:	8kb
CPU:	0.094s

View IL Code