DocName with NamePart v4 with CSF 2.40 | C# Online Compiler

DocName with NamePart v4 with 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 Newtonsoft.Json;
//	Line	##########
//	154	Program End
//	155	DocName
//	905	NamePart
//	1621	InNameGUID
//	1706	MedicineAndDosageInSentence
//	1814	SimpleText
//	1831	VersionInSentence
//	1993	DateInSentence
//	2818	IntervalInSentence
//	3386	BaseElement
//	3429	Enums
//	3569	DocNameHelper
//	3956	TypeOfDoc
//	3972	MessageDialogService
//	4017	WrappedCollection
//	4128	MyExtensions
//	4132	DateTimeExtensions
//	4315	StringTextExtensions
//	4730	EasyOfficeFolderExtensions
//	4759	ObjectTextExtensions
//	4943	Guard
//	Line	##########
#region private::tests
public class Program
{
	public static void Main()
	{
		// Set the current culture
		var culture = new CultureInfo("pt-BR"); //("en-US"); // it does capture interval "entre 3005 a 14062013" 
		//var culture = new CultureInfo("en-US"); // it does NOT capture interval "entre 3005 a 14062013" 
		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;
		//Console.WriteLine(System.Diagnostics.Debugger.IsAttached);
		Console.WriteLine(System.IO.Directory.GetLogicalDrives());
		TestNameParts();
	}
	public static void TestNameParts()
	{/**/
	(string name, string culture)[] nameTests = {
						/**/  ("Laudo médico com afastamento por 2 meses 13042021.pdf", "pt-BR")
						, ("Laudo médico com afastamento por 2 meses .pdf", "pt-BR")
						, ("Laudo médico com afastamento por 100 dias.pdf", "pt-BR")
						, ("Prontuário Itau com anotações entre 2007 e 2021.pdf", "pt-BR")
						, ("Recibos comparecimento a Fisioterapia entre 052016 e 122019.pdf", "pt-BR")
						, ("US abdominal˗cisto hepático_5f9a739a-0b2e-4fcc-9228-81035e6e50ea 23122022 v3.docx", "pt-BR")
						, ("Ruy Quiroga_20230605161406.pdf", "pt-BR")
						, ("Aderaldo Vieira Chaves - SOLICITAÇÃO DE EXAME_5f9a739a-0b2e-4fcc-9228-81035e6e50ea.pdf", "pt-BR")
						, ("Nome do paciente D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL_5f9a739a-0b2e-4fcc-9228-81035e6e50ea durante internação Copa D'Or de 12 a 15052017 - Ciprofloxacino 500 mg 3 2017.pdf", "pt-BR")
						, ("Nome do paciente - exame laboratorial amplo 3 - 23122022.docx", "pt-BR")
						, ("Nome do paciente - exame laboratorial amplo - 23122022 2.docx", "pt-BR")
						, ("Nome do paciente - exame laboratorial amplo - 122022 2.docx", "pt-BR")
						, ("Nome do paciente - relatório internação de 12 a 20122022 - 2 20__.docx", "pt-BR")
						, ("Nome do paciente - exame laboratorial amplo - 23122022 v2.docx", "pt-BR")
						, ("Nome do paciente - exame laboratorial amplo v3 - 23122022.docx", "pt-BR")
						, ("Nome do paciente - exame laboratorial amplo - 122022 v2.docx", "pt-BR")
						, ("Nome do paciente - relatório internação de 12 a 20122022 - v2 20__.docx", "pt-BR")
						, ("US abdominal-cisto hepático 23122022.docx", "pt-BR")
						, ("US abdominal˗cisto hepático 23122022.docx", "pt-BR")
						, ("US abdominal–cisto hepático 23122022.docx", "pt-BR")
						, ("US abdominal - cisto hepático 23122022.docx", "pt-BR")
						, ("US abdominal - cisto hepático v3 23122022.doc", "pt-BR")
						, ("US abdominal 23122022.docx", "pt-BR")
						, ("US abdominal - 23122022.docx", "pt-BR")
						, ("Nome do paciente - exame laboratorial amplo v2 - 23122022.docx", "pt-BR")
						, ("Nome do paciente - v2 23122022.docx", "pt-BR")
						, ("Outro paciente - exame laboratorial amplo para home-care - v2 23122022.docx", "pt-BR")
						, ("Nome do paciente - relatório internação de 12 a 20122022 - v2 23122022.docx", "pt-BR")
						, ("Nome do paciente - exame laboratorial amplo - 202_ v3.docx", "pt-BR")
						, ("Nome do paciente D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Ciprofloxacino 500 mg 2017.pdf", "pt-BR")
						, ("Fulano Sicrano Beltrano - relatório internação - de 1208 até 20062021 - erosão traqueal - v2 12072021.docx", "pt-BR")
						, ("Paulo Afonso Zavataro - Recibo PF referente ao período de 06 a 11082023 internação no Hospital Copa Star.pdf", "pt-BR")
						, ("Paulo Afonso Zavataro - Recibo PJ referente ao período de 12 a 17082023 internação no Hospital Copa Star - NFSe_00003478_02874440.pdf", "pt-BR")
						, ("Paulo Afonso Zavataro - Relatório e Recibo PF referente ao período de 06 a 11082023 internação no Hospital Copa Star - 77d93944-071c-4f01-8788-838d2a204a3d.pdf", "pt-BR")
						, ("Waldenice de Albuquerque Haidamus - Relatório da internação entre 3005 a 14062013.docx", "pt-BR")
						, ("Miuza de Holanda Fragelli - anotação Outlook_backup_2013_abr._20__13_38_12.pdf", "pt-BR")
						, ("Miuza de Holanda Fragelli - anotação Outlook_backup_2013_apr_20__13_38_12.pdf", "en-US") 
						, ("Miuza de Holanda Fragelli - anotação Outlook_backup_2013_abr_20__13_38_12.pdf", "pt-BR") 
						, ("Gilda Elena Brandão Andrade D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Zolpidem SL 5 mg 082021.docx", "pt-BR") 
						, ("Gilda Elena Brandão Andrade D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Zolpidem CR 6,25 mg.docx", "pt-BR") 
						, ("x - RECEITUÁRIO CONTROLE ESPECIAL - trazodona retard 150 mg", "pt-BR") 
						, ("x - RECEITUÁRIO CONTROLE ESPECIAL - Prolopa HBS 100_25 mg.docx", "pt-BR") 
						, ("x - RECEITUÁRIO CONTROLE ESPECIAL - Prolopa orodispersível 125 mg.docx", "pt-BR") 
						, ("x - RECEITUÁRIO CONTROLE ESPECIAL - Parkidopa 25_250 mg", "pt-BR") 
						, ("x - RECEITUÁRIO CONTROLE ESPECIAL - Parkidopa 25_250 mg.docx", "pt-BR") 
						, ("x - RECEITUÁRIO CONTROLE ESPECIAL - pramipexol Sifrol 1,5 mg.docx", "pt-BR") 
						, ("x - RECEITUÁRIO CONTROLE ESPECIAL - Rivastigmina Exelon Patch 9 mg.docx", "pt-BR") 
						, ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - 23.05.pdf", "pt-BR") 
						, ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - 05.23.pdf", "en-US") 
						, ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - 23.5.pdf", "pt-BR") 
						, ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - 5.23.pdf", "en-US")
						, ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - abr.2005.pdf", "pt-BR") 
						, ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - abr2005.pdf", "pt-BR") 
						, ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - apr2005.pdf", "en-US") 
						, ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - march2021.pdf", "en-US") 
						, ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - march.2021.pdf", "en-US") 
						, ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - março2021.pdf", "pt-BR") 
						,("CARLOS ANTONIO MENEZES AMARAL BARBOSA - março.2021.pdf", "pt-BR") 
						 /**/};
	var docs = new List<DocName>();
	foreach (var fileName in nameTests)
	{
		var docName = DocName.CreateInstance(fileName.name, new MessageDialogServiceNone(), false, fileName.culture);
		docs.Add(docName);
	}
		var orderedDocs = DocNameHelper.OrderDocsByDate(docs).ToArray();
		var allDates = orderedDocs.Select(doc => doc.GetDateTimeOrLastPartOfIntervalForOrderDoc()).ToList();
		foreach (var n in allDates)
		{
			Console.WriteLine(n);
		}
		Console.WriteLine();
		Console.WriteLine($"################################################  Ordered docs by Date ################################################");
		
		foreach (var n in orderedDocs)
		{
			//if	(string.IsNullOrEmpty(test)) { 
			Console.WriteLine($"######  {n.FullNameWithExtension}  ######");
			Console.WriteLine($"-------------------------------------------------------------------------------------");
			//TODO: implement ToString() for NamePart
			//n.Dump();			
			Console.WriteLine($"FirstPart: {(n.FirstPartName.IsSuccess ? n.FirstPartName.Value : n.FirstPartName.Error)}");// .ToString());//
			Console.WriteLine();
			Console.WriteLine($"MiddlePart: {(n.MiddlePartName.IsSuccess ? n.MiddlePartName.Value : n.MiddlePartName.Error)}");// .ToString());//
			Console.WriteLine();
			Console.WriteLine($"LastPart: {(n.LastPartName.IsSuccess ? n.LastPartName.Value : n.LastPartName.Error)}");// .ToString());//
			Console.WriteLine();
			Console.WriteLine($"Extension: {n.Extension}");// .ToString());//
			Console.WriteLine();
			//Console.WriteLine($"ToString: {n.ToString()}");// .ToString());//
			Console.WriteLine("######################################################################################"); Console.WriteLine();
		}
		Console.WriteLine();
	}
}
#endregion 
//################################################################################### Program End ##########################################################################################						  
#region private::Main
//################################################################################### DocName ##########################################################################################		
    public class DocName : ValueObject//<DocName>
    {
        private readonly IMessageDialogService _dialog;
        private readonly bool _raiseEvents;
        private readonly int _maxNumOfParts;

        #region Private Fields
        private string _name;
        private int _maxNumDelimiter;
        private string _patientNameFromDocType = NoNameFromDocType;
        private const string NoNameFromDocType = "No DisplayName From DocType";
        #endregion Private Fields 

        #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 Constructors and Destructor
        [JsonConstructor]
        private DocName() { }

	private DocName(string fullNameWithExtension, IMessageDialogService dialog, bool raiseEvents, string culture, int maxNumOfParts = 3)
	{
		if (string.IsNullOrEmpty(fullNameWithExtension))
			throw new ArgumentException("Value cannot be null or empty.", nameof(fullNameWithExtension));
		_dialog = dialog;
		_raiseEvents = raiseEvents;
		this._maxNumOfParts = maxNumOfParts;
		CultureInfoName = culture;
		OriginalNameBeforeTreat = fullNameWithExtension;
		GetParts(fullNameWithExtension);
	}

	/// <summary>
	/// If not specified, there are some calculations about both the maximum and minimum possible year for a date or interval in a sentence
	/// Currently, it is hardcoded 1990 as minimum value, but it should be added as configuration in the future
	/// </summary>
	/// <param name="fullNameWithExtension"></param>
	/// <param name="dialog"></param>
	/// <param name="raiseEvents"></param>
	/// <param name="culture"></param>
	/// <param name="maxPossibleYear"></param>
	/// <param name="minPossibleYear"></param>
	/// <returns></returns>
	public static DocName CreateInstance(string fullNameWithExtension, IMessageDialogService dialog,
		bool raiseEvents, string culture, int maxPossibleYear = int.MinValue, int minPossibleYear = int.MaxValue)
	{
		if (maxPossibleYear == int.MinValue)
			maxPossibleYear = DateInSentence.GetMaxPossibleYear();
		if (minPossibleYear == int.MaxValue)
			minPossibleYear = 1990; //TODO add this as configuration
		return new DocName(fullNameWithExtension, dialog, raiseEvents, culture) { MaxPossibleYear = maxPossibleYear, MinPossibleYear = minPossibleYear };
	}
	/// <summary>
	/// For Serialization ONLY; coding use the other without dialog Argument
	/// </summary>
	public static DocName None(IMessageDialogService dialog) => new(string.Empty, dialog, false, string.Empty);
	/// <summary>
	/// Null Obj Pattern
	/// </summary>
	public static DocName None() => new();
	#endregion Constructors and Destructor	  

        #region Public Methods
        #region Common 
        /// <summary>
        /// Only works if there is no specific element at all
        /// </summary>
        /// <param name="whichElementItIs"></param>
        /// <param name="elemValue"></param>
        /// <param name="docNamePart"></param>
        /// <param name="position"></param>
        /// <returns></returns>
        public bool CreateElement(WhichElementItIs whichElementItIs, string elemValue, DocNamePart docNamePart, ElementRelativePosition position)
        {
            //if (OriginalNameCannotBeRehydrated) 
            //    return false;
            if (ElementExists(whichElementItIs)) return false;
            //get in which DocNamePart docNamePart element is
            
            var connector = position == ElementRelativePosition.First ? string.Empty : " " ;
            switch (docNamePart)
            {
                case DocNamePart.First:
                    FirstPartName.Value.CreateElement(whichElementItIs, elemValue, position, connector);
                    break;
                case DocNamePart.Middle:
                    MiddlePartName.Value.CreateElement(whichElementItIs, elemValue, position, connector);
                    break;
                case DocNamePart.Last:
                    LastPartName.Value.CreateElement(whichElementItIs, elemValue, position, connector);
                    break;
                case DocNamePart.NoPart:
                    break;
                case DocNamePart.Extension:
                    break;
            }
            return ElementExists(whichElementItIs);
        }

        internal bool UpdateElementAndConnectorBefore(WhichElementItIs whichElementItIs, string elemValue
            , string connectorBefore = " ")
        {
            //if (OriginalNameCannotBeRehydrated)
            //    return false;
            if (!ElementExists(whichElementItIs)) return false;
            DocNamePart docPart;
            if (FirstPartName.Value.ElementExists(whichElementItIs))
                docPart = DocNamePart.First;
            else if (MiddlePartName.IsSuccess && MiddlePartName.Value.ElementExists(whichElementItIs))
                docPart = DocNamePart.Middle;
            else if (LastPartName.IsSuccess && LastPartName.Value.ElementExists(whichElementItIs))
                docPart = DocNamePart.Last;
            else
                return false;
            switch (docPart)
            {
                case DocNamePart.First:
                    FirstPartName.Value.UpdateElementAndConnectorBefore(whichElementItIs, elemValue, connectorBefore);
                    break;
                case DocNamePart.Middle:
                    MiddlePartName.Value.UpdateElementAndConnectorBefore(whichElementItIs, elemValue, connectorBefore);
                    break;
                case DocNamePart.Last:
                    LastPartName.Value.UpdateElementAndConnectorBefore(whichElementItIs, elemValue, connectorBefore);
                    break;
                case DocNamePart.NoPart:
                    break;
                case DocNamePart.Extension:
                    break;
            }
            return ElementExists(whichElementItIs);
        }
        public bool DeleteElement(WhichElementItIs whichElementItIs)//, string connectorBeforeOtherIfNeeded = " ")
        {

            //if (OriginalNameCannotBeRehydrated)
            //    return false; 
            if (!ElementExists(whichElementItIs)) return false;
            DocNamePart docPart;
            if (FirstPartName.Value.ElementExists(whichElementItIs))
                docPart = DocNamePart.First;
            else if (MiddlePartName.IsSuccess && MiddlePartName.Value.ElementExists(whichElementItIs))
                docPart = DocNamePart.Middle;
            else if (LastPartName.IsSuccess && LastPartName.Value.ElementExists(whichElementItIs))
                docPart = DocNamePart.Last;
            else
                return false;
            switch (docPart)
            {
                case DocNamePart.First:
                    FirstPartName.Value.DeleteElementAndAdjustConnectorOfOtherAfterIfNeeded(whichElementItIs);//, connectorBeforeOtherIfNeeded);
                    break;
                case DocNamePart.Middle:
                    MiddlePartName.Value.DeleteElementAndAdjustConnectorOfOtherAfterIfNeeded(whichElementItIs);//, connectorBeforeOtherIfNeeded);
                    break;
                case DocNamePart.Last:
                    LastPartName.Value.DeleteElementAndAdjustConnectorOfOtherAfterIfNeeded(whichElementItIs);
                    break;
                case DocNamePart.NoPart:
                    break;
                case DocNamePart.Extension:
                    break;
            }
            return !ElementExists(whichElementItIs);
        }
        #endregion Common

        #region Version
        public VersionInSentence GetVersionInSentence()
        {
            if (!HasVersionInSentence) return VersionInSentence.NullVersion;
            if (FirstPartName.Value.VersionInPart.HasVersion)
                return FirstPartName.Value.VersionInPart;
            if (MiddlePartName.IsSuccess && MiddlePartName.Value.VersionInPart.HasVersion)
                return MiddlePartName.Value.VersionInPart;
            if (LastPartName.IsSuccess && LastPartName.Value.VersionInPart.HasVersion)
                return LastPartName.Value.VersionInPart;
            return VersionInSentence.NullVersion;
        }
        public string GetVersionPrefixInSentence() => GetVersionInSentence().VersionPrefix;
        public int? GetVersionNumberInSentence() => GetVersionInSentence().VersionNumber;

        public bool UpdateVersion(int version, bool withPrefix, string whichPrefix = "v", string connectorBefore = " ")
        {
            if (!HasVersionInSentence) return false;
            var newVersion = (withPrefix ? whichPrefix : string.Empty) +  (version + GetVersionNumberInSentence()).ToString();
            return UpdateElementAndConnectorBefore(WhichElementItIs.WhicheverVersion, newVersion, connectorBefore);
        }
        public bool HasVersionInSentence => FirstPartName.Value.VersionInPart.HasVersion ||
                                            (MiddlePartName.IsSuccess && MiddlePartName.Value.VersionInPart.HasVersion) ||
                                            (LastPartName.IsSuccess && LastPartName.Value.VersionInPart.HasVersion);
        public bool HasVersionInSentenceWithPrefix => FirstPartName.Value.VersionInPart.HasVersionWithPrefix ||
                                                      (MiddlePartName.IsSuccess && MiddlePartName.Value.VersionInPart
                                                          .HasVersionWithPrefix) || (LastPartName.IsSuccess &&
                                                          LastPartName.Value.VersionInPart.HasVersionWithPrefix);
        public bool HasVersionInSentenceNumberOnly => FirstPartName.Value.VersionInPart.HasVersionNumberOnly ||
                                                      (MiddlePartName.IsSuccess && MiddlePartName.Value.VersionInPart
                                                          .HasVersionNumberOnly) || (LastPartName.IsSuccess &&
                                                          LastPartName.Value.VersionInPart.HasVersionNumberOnly);

        #endregion Version
        #region GUID
        public InNameGUID GetGUID()
        {
            if (!HasGUID) return InNameGUID.NullGUID;
            if (FirstPartName.Value.GUIDInPart.HasGUID)
                return FirstPartName.Value.GUIDInPart;
            if (MiddlePartName.IsSuccess && MiddlePartName.Value.GUIDInPart.HasGUID)
                return MiddlePartName.Value.GUIDInPart;
            if (LastPartName.IsSuccess && LastPartName.Value.GUIDInPart.HasGUID)
                return LastPartName.Value.GUIDInPart;
            return InNameGUID.NullGUID;
        }
        public bool HasGUID => FirstPartName.Value.GUIDInPart.HasGUID ||
                               (MiddlePartName.IsSuccess && MiddlePartName.Value.GUIDInPart.HasGUID) ||
                               (LastPartName.IsSuccess && LastPartName.Value.GUIDInPart.HasGUID); 
        #endregion GUID
        #region Date
        public DateInSentence GetDateInSentence()
        {
            if (!HasDateInSentence) return DateInSentence.NullDate;
            if (FirstPartName.Value.DateInPart.HasDate)
                return FirstPartName.Value.DateInPart;
            if (MiddlePartName.IsSuccess && MiddlePartName.Value.DateInPart.HasDate)
                return MiddlePartName.Value.DateInPart;
            if (LastPartName.IsSuccess && LastPartName.Value.DateInPart.HasDate)
                return LastPartName.Value.DateInPart;
            return DateInSentence.NullDate;
        }
        public DateTime GetDateTime()
        {
            return !HasDateInSentence ? DateTime.MinValue : GetDateInSentence().DateAndTime;
        }
        /// <summary>
        /// field that merge Date and, if date is null, the Last part of interval, unless the interval == IntervalType.TemporalClue
		/// But if it is IntervalType.TemporalClue it may not provide useful "order" information like in "Atestado de afastamento do trabalho dias por 100.pdf"
		/// Actually, Date is missing from FileName, but it is client's fault
        /// </summary>
        /// <returns></returns>
        public DateTime GetDateTimeOrLastPartOfIntervalForOrderDoc()
        {
            if (HasDateInSentence)
                return GetDateInSentence().DateAndTime;
            return HasIntervalInSentence 
				? (GetIntervalInSentence().IntervalType == IntervalType.TemporalClue ? GetIntervalInSentence().DateBegin.DateAndTime : GetIntervalInSentence().DateEnd.DateAndTime) 
				: DateTime.MinValue;
        }

        public bool HasDateInSentence => FirstPartName.Value.DateInPart.HasDate ||
                                         (MiddlePartName.IsSuccess && MiddlePartName.Value.DateInPart.HasDate) ||
                                         (LastPartName.IsSuccess && LastPartName.Value.DateInPart.HasDate);
        public bool UpdateExistingDate(string date, string connectorBefore = "") 
            => UpdateElementAndConnectorBefore(WhichElementItIs.FileNameDate, date, connectorBefore);

        public bool InsertDate(string date, DocNamePart docNamePart, ElementRelativePosition position)
        {
            if (!TryCreateDate(date, out var newDate)) return false;
            if (docNamePart == DocNamePart.First)
            {
                FirstPartName.Value.AddDateInSentence(newDate, position);
                return true;
            }

            if (MiddlePartName.IsSuccess && docNamePart == DocNamePart.Middle)
            {
                MiddlePartName.Value.AddDateInSentence(newDate, position);
                return true;
            }

            if (LastPartName.IsSuccess && docNamePart == DocNamePart.Last)
            {
                LastPartName.Value.AddDateInSentence(newDate, position);
                return true;
            }
            return false;
        }

	private bool TryCreateDate(string date, out DateInSentence newDate)
	{
		newDate = DateInSentence.NullDate;
		if (string.IsNullOrEmpty(date)) return false;
		newDate = DateInSentence.CreateInstance(date, CultureInfoName, null);
		return !newDate.ElementValue.IsFailure;
	}

	#endregion Date
	#region Interval
	public IntervalInSentence GetIntervalInSentence()
	{
		if (!HasIntervalInSentence) return IntervalInSentence.Null;
		if (FirstPartName.Value.IntervalInPart.HasInterval)
			return FirstPartName.Value.IntervalInPart;
		if (MiddlePartName.IsSuccess && MiddlePartName.Value.IntervalInPart.HasInterval)
			return MiddlePartName.Value.IntervalInPart;
		if (LastPartName.IsSuccess && LastPartName.Value.IntervalInPart.HasInterval)
			return LastPartName.Value.IntervalInPart;
		return IntervalInSentence.Null;
	}
	public bool HasIntervalInSentence => FirstPartName.Value.IntervalInPart.HasInterval ||
										 (MiddlePartName.IsSuccess && MiddlePartName.Value.IntervalInPart.HasInterval) ||
										 (LastPartName.IsSuccess && LastPartName.Value.IntervalInPart.HasInterval);
	#endregion Interval
	#region MedicineAndDosage
	public MedicineAndDosageInSentence GetDrugAndDoseInSentence()
	{
		if (!HasDrugAndDoseInSentence) return MedicineAndDosageInSentence.NullMedicine;
		if (FirstPartName.Value.MedicinesAndDosesInPart.HasDrugAndDose)
			return FirstPartName.Value.MedicinesAndDosesInPart;
		if (MiddlePartName.IsSuccess && MiddlePartName.Value.MedicinesAndDosesInPart.HasDrugAndDose)
			return MiddlePartName.Value.MedicinesAndDosesInPart;
		if (LastPartName.IsSuccess && LastPartName.Value.MedicinesAndDosesInPart.HasDrugAndDose)
			return LastPartName.Value.MedicinesAndDosesInPart;
		return MedicineAndDosageInSentence.NullMedicine;
	}
	public bool HasDrugAndDoseInSentence => FirstPartName.Value.MedicinesAndDosesInPart.HasDrugAndDose ||
											(MiddlePartName.IsSuccess && MiddlePartName.Value.MedicinesAndDosesInPart.HasDrugAndDose) ||
											(LastPartName.IsSuccess && LastPartName.Value.MedicinesAndDosesInPart.HasDrugAndDose);
	#endregion MedicineAndDosage
	public DocName TurnIntoGeneric()
	{
		FirstPartName = Result.Success(NamePart.DefinePart(GenericPrefix, DocNamePart.First, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
		return new DocName(FullName, _dialog, _raiseEvents, CultureInfoName) { MaxPossibleYear = this.MaxPossibleYear };
	}
	public DocName PromoteIntoPatientDoc(string fullName)
	{
		FirstPartName = Result.Success(NamePart.DefinePart(fullName, DocNamePart.First, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
		return new DocName(FullName, _dialog, _raiseEvents, CultureInfoName) { MaxPossibleYear = this.MaxPossibleYear };
	}
	/// <summary>
	/// In happy path it returns name from FirstPartName or or failure if no associated name
	/// In an edge case, where
	///     Doc has one part only
	///         AND
	///     there is a patient name in FirstPartOnly
	/// the name will be set by _patientNameFromDocType7
	/// </summary>
	/// <returns></returns>
	public Result<string> GetNameOfPatientFromDoc()
	{
		if (IsGeneric)
		{
			return Result.Failure<string>("Doc has no patient associated; it is generic");
		}
		return FileNameHasOnlyOnePart
			? DecideHowToReturnPatientNameIfFileNameHasOnlyOnePart()
			: Result.Success(FirstPartName.Value.PartText);
	}

	/// <summary>
	/// Use only to correct the error comprised of:
	/// 1) Doc has one part only
	/// 2) there is a patient name in this FirstPartOnly
	/// </summary>
	/// <param name="patientName"></param>
	/// <exception cref="InvalidOperationException"></exception>
	public void SetNameOfPatientFromDoc(string patientName)
	{
		if (IsGeneric)
			throw new InvalidOperationException(
				"Cannot use this method to turn Doc in Non-Generic; use PromoteIntoPatientDoc instead.");
		if (!FileNameHasOnlyOnePart)
			throw new InvalidOperationException(
				"Cannot use this method to rename patient in FirstPart; it has to be done in DocType or upper");
		_patientNameFromDocType = patientName;
	}

	#endregion Public Methods 

	#region Public Fields 
	public string CultureInfoName { get; private set; }
	public bool IsGeneric => FirstPartName.IsSuccess && FirstPartName.Value.PartText == GenericPrefix;
	public string GenericPrefix { get; set; } = "x";
	public string Delimiter { get; set; } = "-";
	public List<(string delimiter, int positionAt, DocNamePart whichPart)> WrongDelimiter { get; private set; } = new();
	public int MaxPossibleYear { get; private set; } = 2025;
	public int MinPossibleYear { get; private set; } = 1990;
	/// <summary>
	/// if WrongDelimiter.Any() || OriginalNumberOfParts > _maxNumOfParts
	/// </summary>
	public bool OriginalNameCannotBeRehydrated => WrongDelimiter.Any() || OriginalNumberOfParts > _maxNumOfParts || !OriginalNameBeforeTreat.Equals(FullNameWithExtension);

	public bool OriginalNameCanOnlyBeRehydratedIfPutEnDashHyphensBack()
	{
		if (!WrongDelimiter.Any()) return false;
		var stateBefore = RehydrateWithOriginalEnDashHyphen;
		RehydrateWithOriginalEnDashHyphen = true;
		var sameName = OriginalNameBeforeTreat.Equals(FullNameWithExtension);
		RehydrateWithOriginalEnDashHyphen = stateBefore;
		return sameName;

	}
	private readonly string[] _wrongDelimiters = { "˗", "–" };
	// public (string delimiter, int positionAt) OldDelimiter2 { get; private set; } = ("", -1);
	public string FakeDelimiter { get; set; } = "<>";
	//public NamePart NamePart  { get; private set; } = new();
	public Result<NamePart> FirstPartName { get; private set; }
	public Result<string> FirstPartNameOriginal { get; private set; }
	public Result<NamePart> MiddlePartName { get; private set; }
	public Result<string> MiddlePartNameOriginal { get; private set; }

	public int PositionOfMiddlePart { get; private set; }
	public Result<NamePart> LastPartName { get; private set; }
	public Result<string> LastPartNameOriginal { get; private set; }
	public int PositionOfLastPart { get; private set; }

	[JsonIgnore]
	public bool? VersionIsBeforeDate
	{
		get
		{
			if (!HasDateInSentence || !HasVersionInSentence) return null;
			if (FirstPartName.Value.CheckIfHasBothVersionAndDate())
				return FirstPartName.Value.CheckAtPartElementIfVersionIsFirst();
			if (MiddlePartName.IsSuccess && MiddlePartName.Value.CheckIfHasBothVersionAndDate())
				return MiddlePartName.Value.CheckAtPartElementIfVersionIsFirst();
			if (LastPartName.IsSuccess && LastPartName.Value.CheckIfHasBothVersionAndDate())
				return LastPartName.Value.CheckIfHasBothVersionAndDate();
			return null;
		}
	}

	public string Extension { get; private set; }
	public string ExtensionWithDot => "." + this.Extension;
	//https://stackoverflow.com/questions/73490836/how-can-you-use-a-character-comparison-against-a-dash-hyphen-character-in-powers
	public bool RehydrateWithOriginalEnDashHyphen { get; set; } = false;
	public string FullName => ConcatenateNameIncludingSimplePart().TrimEnd();
	public string FullNameWithExtension => ConcatenateNameIncludingSimplePart().TrimEnd() + "." + Extension;
	/// <summary>
	/// It has all the Original wrong delimiters, if any 
	/// </summary>
	public string OriginalNameBeforeTreat { get; private set; }
	public string OriginalNameBeforeTreatWithoutExtension { get; private set; }
	public string OriginalNameAfterEnsureLegalNumberOfPartsWithoutExtension { get; private set; }
	public bool NeededFakeDelimiter => WhichFakeDelimiter.Any();
	public List<(string delimiter, int positionAt)> WhichFakeDelimiter { get; private set; } = new();
	private InNameGUID PartHasGUID => GetGUID();
	public override string ToString()
	{
		return
			@$"FirstPartName: {FirstPartName}
					MiddlePartName: {(MiddlePartName.IsSuccess ? MiddlePartName.Value : MiddlePartName.Error)}
					MiddlePartNameOriginal: {(MiddlePartNameOriginal.IsSuccess ? MiddlePartNameOriginal.Value : MiddlePartNameOriginal.Error)}
					LastPartName: {(LastPartName.IsSuccess ? LastPartName.Value : LastPartName.Error)}
					LastPartNameOriginal: {(LastPartNameOriginal.IsSuccess ? LastPartNameOriginal.Value : LastPartNameOriginal.Error)}
					FileVersion: {(HasVersionInSentence ? GetVersionInSentence().Version : "No file version")}
					FileDate: {(HasDateInSentence ? GetDateInSentence().DateText : "No file date")}
					FileDateInterval: {(HasIntervalInSentence ? GetIntervalInSentence().ElementValue.Value : "No file interval")}
					MedicinesAndDoses: {(HasDrugAndDoseInSentence ? GetDrugAndDoseInSentence().ElementValue.Value : "No drug and dose in this file")}
						PartHasGUID? 		{PartHasGUID != null && !PartHasGUID.NoGUID}
						GUID:				{(PartHasGUID != null ? PartHasGUID.GUID : "NO")}
							ConnectorBeforeGUID: {(PartHasGUID != null && !PartHasGUID.NoGUID
							? PartHasGUID.ConnectorBefore : "NO")}			
						HasInterval? 		{HasIntervalInSentence}
							ConnectorBeforeInterval: {(!GetIntervalInSentence().ElementValue.IsSuccess
							? "NO" : (GetIntervalInSentence().ConnectorBefore == " " ? "one empty space" : GetIntervalInSentence().ConnectorBefore))}		
						HasDate? 			{HasDateInSentence}
							ConnectorBeforeDate: {(!GetDateInSentence().ElementValue.IsSuccess
							? "NO" : (GetDateInSentence().ConnectorBefore == " " ? "one empty space" : GetDateInSentence().ConnectorBefore))}
						HasVersion? 		{HasVersionInSentence}
						VersionNumberOnly?  {HasVersionInSentenceNumberOnly}
						VersionWithPrefix?  {HasVersionInSentenceWithPrefix}						
							ConnectorBeforeVersion: {(!GetVersionInSentence().ElementValue.IsSuccess
							? "NO" : (GetVersionInSentence().ConnectorBefore == " " ? "one empty space" : GetVersionInSentence().ConnectorBefore))}
				";
	}
	#endregion Public Fields 

	#region Private Methods
	private bool ElementExists(WhichElementItIs whichElementItIs)
	{
		switch (whichElementItIs)
		{
			case WhichElementItIs.VersionWithPrefix when HasVersionInSentence:
			case WhichElementItIs.VersionNumberOnly when HasVersionInSentence:
			case WhichElementItIs.WhicheverVersion when HasVersionInSentence:
				return true;
			case WhichElementItIs.DrugNameDose when HasDrugAndDoseInSentence:
				return true;
			case WhichElementItIs.FileNameDate when HasDateInSentence:
				return true;
			case WhichElementItIs.FileNameInterval when HasIntervalInSentence:
				return true;
			case WhichElementItIs.GUID when HasGUID:
				return true;
			case WhichElementItIs.DoesNotExist:
				break;
		}
		return false;
	}
	private string FixWrongDelimiters(string originalNameBeforeTreat)
	{
		for (var i = 0; i < _wrongDelimiters.Count(); i++)
		{
			if (!originalNameBeforeTreat.Contains(_wrongDelimiters[i])) continue;
			var wrong = _wrongDelimiters[i];
			foreach (var position in originalNameBeforeTreat.AllIndexesOf(wrong))
			{
				WrongDelimiter.Add((wrong, position, i == 0 ? DocNamePart.Middle : DocNamePart.Last));
				// above is wrong; but I do not know number of parts here; so, I have to fix it after...
			}
			originalNameBeforeTreat = originalNameBeforeTreat.Replace(wrong, "-");
		}
		return originalNameBeforeTreat;
	}
	private Result<string> DecideHowToReturnPatientNameIfFileNameHasOnlyOnePart()
	{
		return _patientNameFromDocType != NoNameFromDocType
			? Result.Success(_patientNameFromDocType)
			: Result.Failure<string>("Doc has no patient associated; it has only one part");
	}

	private void GetParts(string fullNameWithExtension)
	{
		fullNameWithExtension = FixWrongDelimiters(fullNameWithExtension);
		var input = fullNameWithExtension;
		(OriginalNameBeforeTreatWithoutExtension, Extension) = DivideDocNameFromExtension(input);
		List<(string delimiter, int positionAt)> temp = new();
		(var matches, OriginalNameAfterEnsureLegalNumberOfPartsWithoutExtension) = EnsureLegalNumberOfParts(OriginalNameBeforeTreatWithoutExtension.Trim(), ref temp);
		WhichFakeDelimiter = temp;
		if (matches.Count == 0) return;
		var matchesList =
			(from Match itemMatch in matches
			 where !string.IsNullOrEmpty(itemMatch.Value)
			 select itemMatch.Value).ToList();
		if (!matchesList.Any()) return;
		FirstPartName = Result.Success(NamePart.DefinePart(matchesList[0].Trim(), DocNamePart.First, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
		FirstPartNameOriginal = matchesList[0].Trim();
		OriginalNumberOfParts = matchesList.Count;
		NumberOfParts = OriginalNumberOfParts;
		switch (matchesList.Count)
		{
			case 3:
				var i = 1;
				MiddlePartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(matchesList[i].Trim()));
				MiddlePartName = Result.Success(NamePart.DefinePart(matchesList[i].Trim(), DocNamePart.Middle, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
				i = 2;
				LastPartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(matchesList[i].Trim()));
				LastPartName = Result.Success(NamePart.DefinePart(matchesList[i].Trim(), DocNamePart.Last, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
				break;
			case 2:
				MiddlePartNameOriginal = Result.Failure<string>("No middle part");
				MiddlePartName = Result.Failure<NamePart>("No middle part");
				i = 1;
				LastPartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(matchesList[i].Trim()));
				LastPartName = Result.Success(NamePart.DefinePart(matchesList[i].Trim(), DocNamePart.Last, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
				break;
			case 1:
				MiddlePartNameOriginal = Result.Failure<string>("No middle part");
				MiddlePartName = Result.Failure<NamePart>("No middle part");
				LastPartNameOriginal = Result.Failure<string>("No last part");
				LastPartName = Result.Failure<NamePart>("No last part");
				break;
			default:
				//if (_raiseEvents)
				//{
				//EventAggregator.Instance.Publish(
				//   new DocNameWithIllegalNumberOfPartsMessage(OriginalNameBeforeTreat, matches.Count));
				//}
				var joinMiddleParts = string.Empty;
				for (var j = 1; j < matchesList.Count - 1; j++)
				{
					joinMiddleParts += matchesList[j].Trim() + (j < matchesList.Count ? " " : string.Empty);
				}
				NumberOfParts = _maxNumOfParts;
				MiddlePartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(joinMiddleParts.Trim()));
				MiddlePartName = Result.Success(NamePart.DefinePart(joinMiddleParts.Trim(), DocNamePart.Middle, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
				LastPartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(matchesList[matchesList.Count - 1].Trim()));
				LastPartName = Result.Success(NamePart.DefinePart(matchesList[matchesList.Count - 1].Trim(), DocNamePart.Last, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
				break;
		}
		if (MiddlePartNameOriginal.IsSuccess)
			PositionOfMiddlePart = OriginalNameAfterEnsureLegalNumberOfPartsWithoutExtension.IndexOf(MiddlePartNameOriginal.Value, StringComparison.Ordinal);
		if (LastPartNameOriginal.IsSuccess)
			PositionOfLastPart = OriginalNameAfterEnsureLegalNumberOfPartsWithoutExtension.IndexOf(LastPartNameOriginal.Value, StringComparison.Ordinal);
		CorrectWrongDelimitersAfterKnowHowManyPartsAre();
	}

	private void CorrectWrongDelimitersAfterKnowHowManyPartsAre()
	{
		if (!WrongDelimiter.Any()) return;
		switch (NumberOfParts)
		{
			case 1:
				for (int i = 0; i < WrongDelimiter.Count; i++)
				{
					WrongDelimiter[i] = (WrongDelimiter[i].delimiter, WrongDelimiter[i].positionAt, DocNamePart.First);
					// Beware of this case: 1 part, but wrong delimiter is in the middle of the name; and maybe there are more then one wrong delimiter
					// I'm substituting ok, but not rehydrating Ok; should be by positionAt, not implemented yet
				}
				break;
			case 2:
				{
					if (WrongDelimiter.Any(x => x.whichPart == DocNamePart.Middle))
					{
						WrongDelimiter[0] = (WrongDelimiter[0].delimiter, WrongDelimiter[0].positionAt, DocNamePart.Last);
					}
					break;
				}
			case 3:
				{
					var numSpacesThatWhereTrimmedFromOriginalNameToLastPart = 3;
					var numSpacesThatWhereTrimmedFromOriginalNameToMiddlePart = 2;
					for (int i = 0; i < WrongDelimiter.Count; i++)
					{
						if (WrongDelimiter[i].positionAt >= PositionOfMiddlePart - numSpacesThatWhereTrimmedFromOriginalNameToMiddlePart && WrongDelimiter[i].positionAt < PositionOfLastPart - numSpacesThatWhereTrimmedFromOriginalNameToLastPart)
							WrongDelimiter[i] = (WrongDelimiter[i].delimiter, WrongDelimiter[i].positionAt, DocNamePart.Middle);
						else if (WrongDelimiter[i].positionAt >= PositionOfLastPart - numSpacesThatWhereTrimmedFromOriginalNameToLastPart)
							WrongDelimiter[i] = (WrongDelimiter[i].delimiter, WrongDelimiter[i].positionAt, DocNamePart.Last);
					}
					break;
				}
		}
	}

	private static (string name, string extension) DivideDocNameFromExtension(string input)
	{
		var rgx = DocNameHelper.ForGrabNameAndExtension.Value;
		var match = rgx.Match(input);
		if (match.Success) return (match.Groups["fullname"].Value, match.Groups["extension"].Value);
		return (string.Empty, string.Empty);
	}
	private bool FileNameHasThreeParts => LastPartName.IsSuccess && MiddlePartName.IsSuccess;
	private bool FileNameHasTwoParts => LastPartName.IsSuccess && MiddlePartName.IsFailure;
	private bool FileNameHasOnlyOnePart => LastPartName.IsFailure && MiddlePartName.IsFailure;

	internal int OriginalNumberOfParts { get; private set; }
	internal int NumberOfParts { get; private set; }
	private string GetMiddlePartOfFileName() =>
		LastPartName.IsFailure ? FirstPartName.Value.PartText : LastPartName.Value.PartText;
	private string GetLastPartOfFileName() =>
		LastPartName.IsFailure ? FirstPartName.Value.PartText : LastPartName.Value.PartText;
	private string IfNeededReplaceFakeDelimiter(List<string> matchesList, int i)
	{
		return NeededFakeDelimiter
			? matchesList[i].Trim().Replace(FakeDelimiter, Delimiter)
			: matchesList[i].Trim();
	}
	private string IfNeededReplaceFakeDelimiter(string partToReturnToOriginal)
	{
		return NeededFakeDelimiter
			? partToReturnToOriginal.Replace(FakeDelimiter, Delimiter).Trim()
			: partToReturnToOriginal.Trim();
	}
	private static (MatchCollection matches, string treatedName) EnsureLegalNumberOfParts(string nameBeforeTreat, ref List<(string delimiter, int positionAt)> whichFakeDelimiter)
	{
		var rgxFakeDelimiter = DocNameHelper.ForGrabFakeDelimiterWithoutAnySpaceAround.Value;
		var treatedName = nameBeforeTreat;
		// NeededFakeDelimiter = rgxFakeDelimiter.Matches(treatedName).Count > 0;
		foreach (Match match in rgxFakeDelimiter.Matches(treatedName))
		{
			whichFakeDelimiter.Add((match.Value, match.Index));
		}
		while (rgxFakeDelimiter.Matches(treatedName).Count > 0)
		{
			treatedName = rgxFakeDelimiter.Replace(treatedName, (string)TemporarySubstitutionForFakeDelimiter);
		}
		var rgx = DocNameHelper.ForGrabPartsOfName.Value;
		var matches = rgx.Matches(treatedName);
		return (matches, treatedName);
	}
	private static void ShowMatches(Regex r, Match m)
	{
		var names = r.GetGroupNames();
		Console.WriteLine("Named Groups:");
		foreach (var name in names)
		{
			var grp = m.Groups[name];
			if (!string.IsNullOrEmpty(grp.Value))
				Console.WriteLine($@" {name}: '{grp.Value}'");
		}
	}

	private string ConcatenateNameIncludingSimplePart()
	{
		return
			$"{GeneratePartOfNameIncludingSimplePartConcatenated(FirstPartName, DocNamePart.First)}"
			+ $"{GeneratePartOfNameIncludingSimplePartConcatenated(MiddlePartName, DocNamePart.Middle)}"
			+ $"{GeneratePartOfNameIncludingSimplePartConcatenated(LastPartName, DocNamePart.Last)}";
	}
	private string GeneratePartOfNameIncludingSimplePartConcatenated(Result<NamePart> part, DocNamePart whichPart)
	{
		string? name;
		if (whichPart == DocNamePart.First)
		{
			name = part.IsFailure
				? string.Empty
				: @$"{GetCorrectEnDashHyphen(part.Value.GetPartNameElements)}";
			//: @$"{part.Value.GetConcatenatedPartNameElements(FakeDelimiter, Delimiter)}";
		}
		else
		{
			var delimiter = GrabChosenDelimiter(whichPart);
			name = part.IsFailure
				? string.Empty
				: @$" {delimiter}{(string.IsNullOrEmpty(part.Value.GetPartNameElements) ? "" : " ")}{GetCorrectEnDashHyphen(part.Value.GetPartNameElements.Trim())}";
		}
		return name;//.RemoveUnnecessarySpaces();
	}

	private string GetCorrectEnDashHyphen(string partValue)
	{
		if (!RehydrateWithOriginalEnDashHyphen) return partValue;
		for (var i = 0; i < WrongDelimiter.Count; i++)
		{
			if (partValue.Contains(Delimiter))
			{
				var toReplace = partValue.IndexOf(Delimiter, StringComparison.CurrentCulture);
				// remove exactly the WrongDelimiter[i].delimiter at the position of toReplace and concatenate the correct delimiter
				partValue = partValue.SubstituteSubstringAtSpecificPositionForAnother(Delimiter, WrongDelimiter[i].delimiter, toReplace);
			}
		}
		return partValue;
	}

	private string GrabChosenDelimiter(DocNamePart whichPart)
	{
		if (!RehydrateWithOriginalEnDashHyphen) return Delimiter;
		foreach (var (wrongDelimiter, _, position) in WrongDelimiter)
		{
			if (position == whichPart) return wrongDelimiter;
		}
		return Delimiter;
	}

        #endregion Private Methods

        #region Overrides of ValueObject

        protected override IEnumerable<IComparable> GetEqualityComponents()
        {
            yield return OriginalNameBeforeTreat;
            yield return FullNameWithExtension;
        }
        #endregion Overrides of ValueObject

    }
//################################################################################### DocName End ##########################################################################################						  
//################################################################################### NamePart ##########################################################################################
public class NamePart : ValueObject//<DocName>
{
    private string _partText;

    #region Public Fields 
    public int MaxPossibleYear { get; set; }
    public int MinPossibleYear { get; set; }
    public string PartOriginalText { get; private set; }
    /// <summary>
    /// Original Text BUT with NO Elements
    /// </summary>
    public string PartText
    {
        get => _partText;
        private set => _partText = value;
    }
    public string GetOnlySimplePartNameElements => GetConcatenatedSimplePartNameElements(FakeDelimiter, FakeDelimiter);
    public string GetOnlySimplePartNameElementsOriginal => GetConcatenatedSimplePartNameElements(FakeDelimiter, Delimiter);
    public string GetPartNameElements => GetConcatenatedPartNameElements(FakeDelimiter, Delimiter);
    //TODO: Make this a list of SimpleText and use it instead of above; concatenate Part will be much easier
    public List<SimpleText> PartSimpleText { get; private set; } = new List<SimpleText>();
    public IntervalInSentence IntervalInPart { get; private set; }
    public DateInSentence DateInPart { get; private set; }
    public VersionInSentence VersionInPart { get; private set; }
    public InNameGUID GUIDInPart { get; private set; }
    public MedicineAndDosageInSentence MedicinesAndDosesInPart { get; private set; }
    public DocNamePart WhichPart { get; private set; }
    public string CultureInfoName { get; private set; }
    public bool HasVersion => HasVersionWithPrefix || HasVersionNumberOnly;
    public bool HasVersionWithPrefix => VersionInPart.HasVersionWithPrefix;
    public bool HasVersionNumberOnly => VersionInPart.HasVersionNumberOnly;
    public bool HasDate => DateInPart.HasDate;
    public bool HasInterval => IntervalInPart.HasInterval;
    public bool HasDrugAndDose => MedicinesAndDosesInPart.HasDrugAndDose;
    public bool HasGUID => GUIDInPart.HasGUID;

    public string Delimiter { get; private set; }
    public string FakeDelimiter { get; private set; }

    #endregion Public Fields 


    #region Public Methods
    public override string ToString()
    {

        return
            @$"PartOriginalText: {PartOriginalText}
		PartText: {PartText}
		GetOnlySimplePartNameElementsOriginal: {GetOnlySimplePartNameElementsOriginal}
		GetOnlySimplePartNameElements: {GetOnlySimplePartNameElements}
		GetPartNameElements: {GetPartNameElements}
		FileVersion: {(HasVersion ? VersionInPart.Version : "No file version")}
		FileDate: {(HasDate ? DateInPart.DateText + " (date mask has YYYY: " + DateInPart.DateMaskProvidesYYYY + " and it is " + (DateInPart.DateYearHasWildCard ? "" : "not ") + "with wildcard)" : "No file date")}
		FileDateInterval: {(HasInterval ? IntervalInPart.ElementValue.Value  + " (date begin mask has YYYY: " + IntervalInPart.DateBegin.DateMaskProvidesYYYY + ")" /*  + " (date end mask has YYYY: " + IntervalInPart.DateEnd.DateMaskProvideYYYY() + ")" */ : "No file interval")}
		MedicinesAndDoses: {(HasDrugAndDose ? MedicinesAndDosesInPart.ElementValue.Value : "No drug and dose in this file")}
		PartHasGUID? 		{HasGUID && !GUIDInPart.NoGUID}
		GUID:				{(HasGUID ? GUIDInPart.GUID : "NO")}
		ConnectorBeforeGUID: {(HasGUID && !GUIDInPart.NoGUID
            ? GUIDInPart.ConnectorBefore : "NO")}			
		HasInterval? 		{HasInterval}
		ConnectorBeforeInterval: {(!IntervalInPart.ElementValue.IsSuccess
            ? "NO" : (IntervalInPart.ConnectorBefore == " " ? "one empty space" : IntervalInPart.ConnectorBefore))}		
		HasDate? 			{HasDate}
		ConnectorBeforeDate: {(!DateInPart.ElementValue.IsSuccess
            ? "NO" : (DateInPart.ConnectorBefore == " " ? "one empty space" : DateInPart.ConnectorBefore))}
		HasVersion? 		{HasVersion}
		VersionNumberOnly?  {HasVersionNumberOnly}
		VersionWithPrefix?  {HasVersionWithPrefix}						
		ConnectorBeforeVersion: {(!VersionInPart.ElementValue.IsSuccess
            ? "NO" : (VersionInPart.ConnectorBefore == " " ? "one empty space" : VersionInPart.ConnectorBefore))}
		";
    }
    #endregion Public Methods

    #region Constructors and Destructor
    private NamePart()
    {
    }

    internal static NamePart DefinePart(string part, DocNamePart whichPart, string culture, string delimiter, string fakeDelimiter, int maxPossibleYear, int minPossibleYear)
    {
        if (string.IsNullOrEmpty(part))
            throw new ArgumentException("Value cannot be null or empty.", nameof(part));
        var instance = new NamePart
        {
            PartText = part,
            PartOriginalText = part,
            WhichPart = whichPart,
            CultureInfoName = culture,
            Delimiter = delimiter,
            FakeDelimiter = fakeDelimiter,
            MaxPossibleYear = maxPossibleYear,
            MinPossibleYear = minPossibleYear
        };
        instance.GetAllElementsFromPart();
        return instance;
    }
    /// <summary>
    /// For Serialization or Null Obj Pattern ONLY
    /// </summary>
    public static NamePart None() => new();
    #endregion Constructors and Destructor

    #region Private Methods

    #region Common
    private void GetAllElementsFromPart()

    {
        GUIDInPart = InNameGUID.CreateInstance(_partText, WhichPart);
        if (!GUIDInPart.NoGUID)
        {
            _partText = StripOfElementAndUpdateBaseElement(GUIDInPart, _partText, PartOriginalText);
        }
        MedicinesAndDosesInPart = MedicineAndDosageInSentence.CreateInstance(_partText);
        if (MedicinesAndDosesInPart != MedicineAndDosageInSentence.NullMedicine)
        {
            _partText = StripOfElementAndUpdateBaseElement(MedicinesAndDosesInPart, _partText, PartOriginalText);
        }
        var intervalInSentence = IntervalInSentence.CreateInstance(_partText, new CultureInfo(CultureInfoName), MaxPossibleYear, MinPossibleYear);
        //Below is the slowest place in the whole program, because of the DateTime.TryParseExact
        var dateInSentence =
            DateInSentence.CreateInstanceFromSentence(_partText, CultureInfoName, (GUIDInPart.StartIndex, GUIDInPart.EndOriginal), MaxPossibleYear, minPossibleYear: MinPossibleYear);
        TreatIntervalComparingItWithDate(ref intervalInSentence, ref dateInSentence, PartOriginalText);
        IntervalInPart = intervalInSentence;
        if (intervalInSentence.ElementValue.IsSuccess)
        {
            _partText = StripOfElementAndUpdateBaseElement(intervalInSentence, _partText, PartOriginalText);
            //After Strip of Interval from part, let's see if fileDate still exists:
            dateInSentence = DateInSentence.CreateInstanceFromSentence(_partText, CultureInfoName, (GUIDInPart.StartIndex, GUIDInPart.EndOriginal), MaxPossibleYear, minPossibleYear: MinPossibleYear);
        }
        if (dateInSentence.ElementValue.IsSuccess)
        {
            _partText = StripOfElementAndUpdateBaseElement(dateInSentence, _partText, PartOriginalText);
        }
        VersionInPart = VersionInSentence.CreateInstance(_partText);
        DateInPart = dateInSentence;
        if (VersionInPart.ElementValue.IsSuccess)
        {
            _partText = StripOfElementAndUpdateBaseElement(VersionInPart, _partText, PartOriginalText);
        }
        PartSimpleText = GetPartSimpleTextElements();
        _partText = _partText.RemoveUnnecessarySpaces();
    }

    private List<SimpleText> GetPartSimpleTextElements()
    {
        var draftList = new List<SimpleText>();
        var partWithoutElements = PartWithoutElements(PartOriginalText);
        //test by how much substrings of partWithoutElements is partOriginalToTest made of
        while (partWithoutElements.Length > 0)
        {
            for (var i = 0; i <= partWithoutElements.Length; i++)
            {
                var substring = partWithoutElements.Substring(0, i);
                var start = PartOriginalText.IndexOf(substring.Trim(), StringComparison.Ordinal);
                var end = start + substring.Length;
                if (PartOriginalText.Contains(substring))
                {
                    //draftList.Add(substring);
                    if (partWithoutElements.Equals(substring))
                    {
                        var connectorBefore = start == 0 ? string.Empty : PartOriginalText.Substring(start - 1, 1);
                        draftList.Add(SimpleText.CreateInstance(substring.TrimEnd(), start, connectorBefore));
                        partWithoutElements = partWithoutElements.Replace(substring, string.Empty).TrimEnd();
                        break;
                    }
                }
                else //if (start > -1)
                {
                    var connectorBefore = start <= 0 ? string.Empty : PartOriginalText.Substring(start - 1, 1);
                    if (start == -1)
                    {
                        substring = substring.TrimLastCharacter();
                        start = 0;
                    }
                    draftList.Add(SimpleText.CreateInstance(substring.TrimEnd(), start, connectorBefore));
                    partWithoutElements = partWithoutElements.Replace(substring, string.Empty).TrimEnd();
                    break;
                }
            }
        }
        return draftList;
    }
    private string PartWithoutElements(string partOriginalToTest)
    {
        foreach (var element in ListOfElements())
        {
            //calculate start index of element substring in name

            var elementValue = element.ElementValue.Value;
            var startIndex = partOriginalToTest.IndexOf(elementValue, StringComparison.Ordinal);
            if (startIndex == -1) continue;
            var endIndex = startIndex + elementValue.Length;
            if (startIndex == 0)
                //partOriginalToTest = partOriginalToTest.Replace(elementValue, string.Empty);
                partOriginalToTest = partOriginalToTest.Substring(endIndex);
            else
            {
                var partLength = partOriginalToTest.Length;
                var part1 = partOriginalToTest.Substring(0, startIndex - 1);
                var part2 = partOriginalToTest.Substring(endIndex);
                partOriginalToTest = part1 + part2;
            }
        }
        return partOriginalToTest;
    }
    private string StripOfElementAndUpdateBaseElement(BaseElement elem, string part, string partOriginal)
    {
        (part, var connector) = StripOffPartWithConnectorAndReturnIt(part, elem.ElementValue.Value);
        elem.ConnectorBefore = connector;
        elem.StartIndex = partOriginal.IndexOf(elem.ElementValue.Value, StringComparison.Ordinal);
        return part;
    }
    internal bool ElementExists(WhichElementItIs whichElementItIs)
    {
        switch (whichElementItIs)
        {
            case WhichElementItIs.VersionWithPrefix when HasVersion:
            case WhichElementItIs.VersionNumberOnly when HasVersion:
            case WhichElementItIs.WhicheverVersion when HasVersion:
                return true;
            case WhichElementItIs.DrugNameDose when HasDrugAndDose:
                return true;
            case WhichElementItIs.FileNameDate when HasDate:
                return true;
            case WhichElementItIs.FileNameInterval when HasInterval:
                return true;
            case WhichElementItIs.GUID when HasGUID:
                return true;
            case WhichElementItIs.DoesNotExist:
                break;
        }
        return false;
    }

    private static WhichElementItIs TypeOfElement(BaseElement elem)
    {
        return elem switch
        {
            //detect which type of this element is
            VersionInSentence => WhichElementItIs.WhicheverVersion,
            MedicineAndDosageInSentence => WhichElementItIs.DrugNameDose,
            DateInSentence => WhichElementItIs.FileNameDate,
            IntervalInSentence => WhichElementItIs.FileNameInterval,
            InNameGUID => WhichElementItIs.GUID,
            SimpleText => WhichElementItIs.SimplePart,
            _ => WhichElementItIs.DoesNotExist
        };
    }
    internal bool ElementIsFirst(WhichElementItIs whichElementItIs)
    {
        //detect if element is the first in the part
        var firstElement = ListOfElements().OrderBy(x => x.StartIndex).FirstOrDefault();
        if (firstElement == null) return false;
        return TypeOfElement(firstElement) == whichElementItIs;
    }
    /// <summary>
    /// I'm not calculating exactly Indexes here; just approximating them
    /// </summary>
    /// <param name="elem"></param>
    /// <param name="elementRelativePosition"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentOutOfRangeException"></exception>
    private int ReturnNewIndexToPositioningElementInSentence(BaseElement elem, ElementRelativePosition elementRelativePosition)
    {
        var allElements = ListOfElements();
        // get an ordered array with StartIndex of all elements
        var orderedElements = allElements.OrderBy(x => x.StartIndex).ToArray();
        // calculate the index as modal of the nearer indexes depending of the elementRelativePosition
        var sizeOfPartWithoutElem = PartWithoutElementLength();
        var index = -1;
        if (orderedElements.Length > 1)
        {
            index = elementRelativePosition switch
            {
                //Instead of that, I should positioned it after EndIndex of the previous element and dislodge the next by elem.Length
                ElementRelativePosition.Middle => (orderedElements.Max(x => x.StartIndex) -
                                                   orderedElements.Min(x => x.StartIndex)),
                ElementRelativePosition.First => 0,
                ElementRelativePosition.Last => orderedElements.Max(x => x.StartIndex) + 1,
                _ => throw new ArgumentOutOfRangeException(nameof(elementRelativePosition), elementRelativePosition,
                    null)
            };
        }
        else if (orderedElements.Length == 1)
        {
            index = elementRelativePosition switch
            {
                ElementRelativePosition.First => 0,
                //Instead of that, I should positioned it after EndIndex of the previous element and dislodge the next by elem.Length
                _ => orderedElements.FirstOrDefault().EndIndex + 1
            };
        }
        else if (orderedElements.Length == 0)
        {
            index = elementRelativePosition switch
            {
                ElementRelativePosition.First => 0,
                //Instead of that, I should positioned it after EndIndex of the previous element and dislodge the next by elem.Length
                _ => sizeOfPartWithoutElem
            };
        }
        return index;
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="whichElementItIs"></param>
    /// <param name="elemValue"></param>
    /// <param name="position"></param>
    /// <param name="connectorBefore">it only works if it not is an element in First position</param>
    /// <param name="connectorBeforeDisplacedExFirstElement"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentOutOfRangeException"></exception>
    internal bool CreateElement(WhichElementItIs whichElementItIs, string elemValue,
        ElementRelativePosition position, string connectorBefore = " ", string connectorBeforeDisplacedExFirstElement = " ")
    {
        if (string.IsNullOrEmpty(elemValue)) return false;
        //if element is to be create in first position, we should assure that it's connector is null and the connector of the element to be displaced should be inserted as space
        if (position == ElementRelativePosition.First)
        {
            connectorBefore = string.Empty;
            var firstElementThatWillBecomeSecond = ListOfElements().FirstOrDefault();
            if (firstElementThatWillBecomeSecond != null)
            {
                firstElementThatWillBecomeSecond.ConnectorBefore = connectorBeforeDisplacedExFirstElement;
            }
        }
        switch (whichElementItIs)
        {
            case WhichElementItIs.DoesNotExist:
                break;
            case WhichElementItIs.WhicheverVersion:
            case WhichElementItIs.VersionNumberOnly:
            case WhichElementItIs.VersionWithPrefix:
                CreateVersionInSentence(elemValue, position, connectorBefore);
                return HasVersion;
            case WhichElementItIs.FileNameDate:
                break;
            case WhichElementItIs.FileNameInterval:
                break;
            case WhichElementItIs.GUID:
                break;
            case WhichElementItIs.DrugNameDose:
                break;
            default:
                throw new ArgumentOutOfRangeException(nameof(whichElementItIs), whichElementItIs, null);
        }
        return false;
    }
    internal bool UpdateElementAndConnectorBefore(WhichElementItIs whichElementItIs, string elemValue, string connectorBefore = "")
    {
        if (string.IsNullOrEmpty(elemValue)) return false;
        switch (whichElementItIs)
        {
            case WhichElementItIs.DoesNotExist:
                break;
            case WhichElementItIs.WhicheverVersion:
            case WhichElementItIs.VersionNumberOnly:
            case WhichElementItIs.VersionWithPrefix:
                UpdateVersionInSentence(elemValue, connectorBefore);
                return HasVersion;
            case WhichElementItIs.FileNameDate:
                UpdateDateInSentence(elemValue, connectorBefore);
                break;
            case WhichElementItIs.FileNameInterval:
                break;
            case WhichElementItIs.GUID:
                break;
            case WhichElementItIs.DrugNameDose:
                break;
            default:
                throw new ArgumentOutOfRangeException(nameof(whichElementItIs), whichElementItIs, null);
        }
        return false;
    }
    internal bool DeleteElementAndAdjustConnectorOfOtherAfterIfNeeded(WhichElementItIs whichElementItIs)
    {
        if (!ElementExists(whichElementItIs)) return false;
        if (ElementIsFirst(whichElementItIs))
        {
            var secondElement = ListOfElements().OrderBy(x => x.StartIndex).Skip(1).FirstOrDefault();
            if (secondElement != null)
            {
                secondElement.ConnectorBefore = string.Empty;
            }
        }
        switch (whichElementItIs)
        {
            case WhichElementItIs.DoesNotExist:
                break;
            case WhichElementItIs.WhicheverVersion:
            case WhichElementItIs.VersionNumberOnly:
            case WhichElementItIs.VersionWithPrefix:
                DeleteVersionInSentence();
                return HasVersion;
            case WhichElementItIs.FileNameDate:
                DeleteDateInSentence();
                return HasDate;
            case WhichElementItIs.FileNameInterval:
                break;
            case WhichElementItIs.GUID:
                break;
            case WhichElementItIs.DrugNameDose:
                break;
            default:
                throw new ArgumentOutOfRangeException(nameof(whichElementItIs), whichElementItIs, null);
        }
        return false;
    }

    private int PartWithoutElementLength() => _partText.Length;
    private int ElementEndIndex(BaseElement baseElement) => baseElement.EndIndex;
    #region Decompose elements from Part

    private static (string partStripped, string connector) StripOffPartWithConnectorAndReturnIt(string partToBeStrippedOff, string partToStrip)
    {
        var connector = partToBeStrippedOff.GetNumberOfCharsJustBeforeSubstring(partToStrip, 1);
        partToBeStrippedOff = StripOffPart(partToBeStrippedOff, partToStrip, connector);
        return (partToBeStrippedOff, string.IsNullOrEmpty(connector) ? " " : connector);
    }
    private 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();
    }
    #endregion Decompose elements from Part
    
    #region Compose back Elements
    private IEnumerable<BaseElement> ListOfElements()
    {
        var elemToReturn = new List<BaseElement>();
        if (!GUIDInPart.NoGUID)
        {
            elemToReturn.Add(GUIDInPart);
        }
        if (DateInPart.ElementValue.IsSuccess)
        {
            elemToReturn.Add(DateInPart);
        }
        if (VersionInPart.ElementValue.IsSuccess)
        {
            elemToReturn.Add(VersionInPart);
        }
        if (IntervalInPart.ElementValue.IsSuccess)
        {
            elemToReturn.Add(IntervalInPart);
        }
        if (MedicinesAndDosesInPart.ElementValue.IsSuccess)
        {
            elemToReturn.Add(MedicinesAndDosesInPart);
        }
        return elemToReturn.OrderBy(x => x.StartIndex);
    }

    private IEnumerable<BaseElement> ListOfElementsIncludingSimpleParts()
    {
        var elemToReturn = ListOfElements().ToList();
        elemToReturn.AddRange(PartSimpleText);
        return elemToReturn.OrderBy(x => x.StartIndex);
    }

    private string GetConcatenatedPartNameElements(string fakeDelimiter, string delimiter)
    {
        var partText = new StringBuilder();
        foreach (var element in ListOfElementsIncludingSimpleParts())
        {
            partText.Append(element.ConnectorBefore);
            partText.Append(element.ElementValue.Value.Replace(fakeDelimiter, delimiter));
        }
        return Regex.Replace(partText.ToString(), @"\s{2,}", " ");
    }

    private string GetConcatenatedSimplePartNameElements(string fakeDelimiter, string delimiter)
    {
        var partText = new StringBuilder();
        foreach (var element in ListOfElementsIncludingSimpleParts().Where(e => e is SimpleText))
        {
            partText.Append(element.ConnectorBefore);
            partText.Append(element.ElementValue.Value.Replace(fakeDelimiter, delimiter));
        }
        return Regex.Replace(partText.ToString(), @"\s{2,}", " ");
    }
    #endregion Compose back Elements

    #endregion Common


    #region Version
    /// <summary>
    /// Use it after NamePart processed, like there in DocName  
    /// </summary>
    /// <returns></returns>
    internal bool CheckAtPartElementIfVersionIsFirst()
    {
        //By default, version always should be first, before date
        if (!HasVersion || !HasDate) return true;
        var whereVersion = _partText.IndexOf(VersionInPart.Version, StringComparison.CurrentCulture);
        var whereDate = _partText.IndexOf(DateInPart.DateText, StringComparison.CurrentCulture);
        return whereVersion < whereDate;
    }

    /// <summary>
    /// Only to Update; to delete Version, use Delete Version Method...
    /// If it fails, it will not corrupt the current version, rather it will maintaining it as it is
    /// </summary>
    /// <param name="newVersionValue"></param>
    /// <param name="connectorBefore"></param>
    internal bool UpdateVersionInSentence(string newVersionValue, string connectorBefore = "")
    {
        var newVersion = VersionInSentence.UpdateInstance(newVersionValue, VersionInPart, connectorBefore);
        if (newVersion == VersionInSentence.NullVersion) return false;
        VersionInPart = newVersion;
        return true;
    }
    internal void CreateVersionInSentence(string newVersionValue, ElementRelativePosition elementRelativePosition, string connectorBefore = " ")
    {
        if (string.IsNullOrEmpty(newVersionValue)) return;
        VersionInPart = VersionInSentence.CreateInstance(newVersionValue);
        VersionInPart.StartIndex =
            ReturnNewIndexToPositioningElementInSentence(VersionInPart, elementRelativePosition);
        VersionInPart.ConnectorBefore = connectorBefore;
    }
    internal void DeleteVersionInSentence()
    {
        VersionInPart = VersionInSentence.NullVersion;
    }
    #endregion Version
    internal bool CheckIfHasBothVersionAndDate() => HasVersion && HasDate;

    #region Interval and Date
    private void TreatIntervalComparingItWithDate(ref IntervalInSentence intervalInSentence,
        ref DateInSentence dateInSentence, string partOriginal)
    {
        if (dateInSentence == DateInSentence.NullDate) return;// intervalInSentence.Interval;
        if (intervalInSentence.ElementValue.IsFailure) return;// Result.Failure<string>("No interval date stamp in this file name");
        if (InvalidIntervalBecauseSupposedToBeComposedButHasOnlyOneDate(intervalInSentence, dateInSentence) 
            || InvalidIntervalBecauseSupposedToBeTemporalClueButDateInvalid(intervalInSentence, dateInSentence))
        {
            intervalInSentence = IntervalInSentence.Null;
            return ;//Result.Failure<string>("No interval date stamp in this file name");
        }
        if (InvalidDateBecauseItIsIdenticalToIntervalThatIsAllowedToHaveOnlyOneDate(intervalInSentence, dateInSentence))
        {
            dateInSentence = DateInSentence.NullDate;
        }

        if (!InvalidDateBecauseItIsCapturedInsideBeginOfInterval(intervalInSentence, dateInSentence)) return;
        if (CapturedElementsAreSuperposedInSamePlaceOfStringSoOneIsInvalid(intervalInSentence, dateInSentence, partOriginal))
        {
            dateInSentence = DateInSentence.NullDate;
        }
    }

private static bool CapturedElementsAreSuperposedInSamePlaceOfStringSoOneIsInvalid(BaseElement elem1, BaseElement elem2, string partOriginal)
{
	return partOriginal.IndexOf(elem1.ElementValue.Value, StringComparison.Ordinal)
		   == partOriginal.IndexOf(elem2.ElementValue.Value, StringComparison.Ordinal);
}

private static bool InvalidDateBecauseItIsCapturedInsideBeginOfInterval(IntervalInSentence intervalInSentence, DateInSentence dateInSentence)
{
	return intervalInSentence.IntervalType == IntervalType.NormalRange && dateInSentence.DateText == intervalInSentence.DateEnd.DateText;
}

private static bool InvalidDateBecauseItIsIdenticalToIntervalThatIsAllowedToHaveOnlyOneDate(IntervalInSentence intervalInSentence, DateInSentence dateInSentence)
{
	return intervalInSentence.IntervalType == IntervalType.TemporalClue && dateInSentence.DateText == intervalInSentence.DateBegin.DateText;
}

private static bool InvalidIntervalBecauseSupposedToBeComposedButHasOnlyOneDate(IntervalInSentence intervalInSentence, DateInSentence dateInSentence)
{
	return intervalInSentence.IntervalType == IntervalType.NormalRange && dateInSentence.DateText == intervalInSentence.ElementValue.Value;
}
private static bool InvalidIntervalBecauseSupposedToBeTemporalClueButDateInvalid(IntervalInSentence intervalInSentence, DateInSentence dateInSentence)
{
	return intervalInSentence.IntervalType == IntervalType.TemporalClue
		   && dateInSentence.DateText.Length > intervalInSentence.ElementValue.Value.Length;
}               //                 15.05.2021                                    em 15  

/// <summary>
/// Only to Update; to delete Date, use Delete Date Method...
/// </summary>
/// <param name="value"></param>
internal void UpdateDateInSentence(DateInSentence value)
{
	if (value == DateInSentence.NullDate) return;
	DateInPart = value;
}
internal bool UpdateDateInSentence(string value, string connectorBefore)
{
	var newDate = DateInSentence.UpdateInstance(value, DateInPart, connectorBefore);
	if (newDate == DateInSentence.NullDate) return false;
	DateInPart = newDate;
	return true;
}
internal void AddDateInSentence(DateInSentence value, ElementRelativePosition position, string connectorBefore = " ")
{
	if (value == DateInSentence.NullDate) return;
	value.StartIndex = ReturnNewIndexToPositioningElementInSentence(value, position);
	value.ConnectorBefore = connectorBefore;
	DateInPart = value;
}
internal void DeleteDateInSentence()
{
	DateInPart = DateInSentence.NullDate;
}
#endregion Interval and Date

#region GUID

public bool ThisPartHasGUID() => !GUIDInPart.NoGUID;
#endregion GUID

#endregion Private Methods

#region Overrides of ValueObject
protected override IEnumerable<IComparable> GetEqualityComponents()
{
	yield return PartText;
	yield return PartOriginalText;
	yield return GUIDInPart;
	yield return DateInPart;
	yield return VersionInPart;
	yield return IntervalInPart;
	yield return MedicinesAndDosesInPart;
}
#endregion Overrides of ValueObject

#region draft
/// <summary>
/// After strip GUID from part, let's see if it was removed from the beginning of the part;
/// if not, let's see if it was removed exactly from the end of the part;
/// if not, it means that the GUID was in the middle of the part, so let's modify PartSimpleText[0] to reflect this and add other part to second element of PartSimpleText
///  TODO: try to figure how to split the part in more than 2 parts, if necessary
/// </summary>
/// <param name="partOriginal"></param>
/// <param name="elem"></param>
private void AdjustPartSimpleText(string partOriginal, BaseElement elem)
{
	//string toHelpDecideIfElemSplitPart;
	if (elem.StartIndex == 0)
	{
		PartSimpleText[0] =
			SimpleText.CreateInstance(partOriginal.Substring(0, elem.StartIndex), 0, string.Empty);
		//toHelpDecideIfElemSplitPart = partOriginal.Substring(0, elem.StartIndex);
	}
	else if (elem.EndIndex == partOriginal.Length)
	{
		switch (PartSimpleText.Count)
		{
			case 1:
				PartSimpleText[0] =
					SimpleText.CreateInstance(partOriginal.Substring(elem.EndIndex), 0, string.Empty);
				break;
			case 2 when elem.ElementValue.Value.Equals(PartSimpleText[1].ElementValue.Value):
				PartSimpleText.RemoveAt(1);
				break;
			case 2:
				PartSimpleText[1] =
					SimpleText.CreateInstance(partOriginal.Substring(elem.EndIndex), 0, string.Empty);
				break;
		}
	}
	else
	{
		IncreaseSimplePartNumberBySplittingOneOfThem(partOriginal, elem);
	}
}
private void IncreaseSimplePartNumberBySplittingOneOfThem(string partOriginal, BaseElement elem)
{
	if (PartSimpleText.Count == 1)
	{
		//   PartSimpleText.Add(SimpleText.CreateInstance(string.Empty, 0, string.Empty));
		PartSimpleText[0] =
			SimpleText.CreateInstance(partOriginal.Substring(0, elem.StartIndex - 1), 0, string.Empty);
		var newDistalPart =
			SimpleText.CreateInstance(partOriginal.Substring(elem.EndIndex + 1), elem.EndIndex + 1, string.Empty);
		newDistalPart.ConnectorBefore = partOriginal.Substring(elem.EndIndex, 1);
		PartSimpleText.Add(newDistalPart);
	}
	else if (PartSimpleText.Count == 2)
	{
		//Detect in which SimplePart the elem.substring is
		var partWithSubstring = PartSimpleText.FirstOrDefault(p => p.OriginalText.Contains(elem.ElementValue.Value));
		if (partWithSubstring != null)
		{
			var index = PartSimpleText.IndexOf(partWithSubstring);
			PartSimpleText[index] =
				SimpleText.CreateInstance(partOriginal.Substring(0, elem.StartIndex - 1), 0, string.Empty);
			var newDistalPart =
				SimpleText.CreateInstance(partOriginal.Substring(elem.EndIndex + 1), 0, string.Empty);
			newDistalPart.ConnectorBefore = partOriginal.Substring(elem.EndIndex, 1);
			PartSimpleText.Add(newDistalPart);
		}
		else
		{
			throw new ArgumentOutOfRangeException(nameof(PartSimpleText), PartSimpleText.Count,
									   "PartSimpleText.Count is 2, but none of the SimpleTexts contains the substring");
		}
	}
	else
	{
		throw new ArgumentOutOfRangeException(nameof(PartSimpleText), PartSimpleText.Count,
							   "PartSimpleText.Count is greater than 2");
	}
}
#endregion draft
}
//################################################################################### NamePart End ##########################################################################################
#endregion
//################################################################################### InNameGUID ##########################################################################################
public class InNameGUID : BaseElement//ValueObject
{
	private InNameGUID(int startIndex, int end, DocNamePart part, string guid)
	{
		StartIndex = startIndex;
		EndOriginal = end;
		Part = part;
		GUID = guid;
	}
	private InNameGUID(string originalText, DocNamePart part)
	{
		Part = part;
		OriginalText = originalText;
	}
	public static InNameGUID CreateInstance(string originalText, DocNamePart part)
	{
		if (string.IsNullOrEmpty(originalText))
			return NullGUID;
		var instance = new InNameGUID(originalText, part);
		instance.GetGUID();
		return instance.ElementValue.IsFailure
			? NullGUID : instance;
	}
	//public static InNameGUID CreateInstance(int start, int end, DocNamePart part, string guid)
	//{
	//    return new InNameGUID(start, end, part, guid);
	//}

	public bool NoGUID => string.IsNullOrEmpty(GUID);
	public bool HasGUID => !string.IsNullOrEmpty(GUID);
	public static InNameGUID NullGUID => new(-1, -1, DocNamePart.NoPart, string.Empty);

	private void GetGUID()//string part, DocNamePart namePart)
	{
		//var rgx = new Regex(Grab_GUID_treated);
		var rgx = DocNameHelper.ForGrab_GUID_Treated.Value;
		var match = rgx.Match(OriginalText);
		//Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
		//var result = match.Success
		//    ? CreateInstance(match.Groups["GUID"].Index, match.Groups["GUID"].Length - 1, Part, match.Groups["GUID"].Value)
		//    : NullGUID;
		if (!match.Success) return;
		//Check if this below line is coherent with 
		StartIndex = match.Groups["GUID"].Index;
		EndOriginal = match.Groups["GUID"].Index + match.Groups["GUID"].Length - 4;
		LengthOriginal = match.Groups["GUID"].Length - 4;
		//end is not end; end is Length...and length of treated GUID, with <> instead of - (to compensate the 4 <> for 4 -, delete 4 from Length)
		EndTreated = match.Groups["GUID"].Index + match.Groups["GUID"].Length;
		LengthTreated = match.Groups["GUID"].Length;
		//Part = part;
		GUID = match.Groups["GUID"].Value.Trim();
		//      1  	2			
		//  0   1	2	3	4	5
		//? Result.Success(match.Groups["GUID"].Value.Trim())
		//: Result.Failure<string>("No GUID in this part");
		ElementValue = Result.Success(GUID);
		//return result;
	}
	//public int StartIndex { get; private set; }
	public int EndOriginal { get; private set; }
	public int LengthOriginal { get; private set; }
	public int LengthTreated { get; private set; }
	public int EndTreated { get; private set; }
	public DocNamePart Part { get; private set; }
	public string GUID { get; private set; }
	protected override IEnumerable<IComparable> GetEqualityComponents()
	{
		yield return Part;
		yield return EndOriginal;
		yield return StartIndex;
		yield return GUID;
		yield return NoGUID;
	}
}
//################################################################################### InNameGUID End ##########################################################################################						  
//################################################################################### 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 bool HasDrugAndDose => ElementValue.IsSuccess;
        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()
        {
            var rgx = new Regex(GrabDoseAndUnitOfMedicinesFromPartOfFile);
            var match = rgx.Match(OriginalText);
            if (match.Success)
            {
                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";
                ElementValue = Result.Success(OriginalText);
            }
 		else
		{
			var criteria = new string[] { "Receita de Antibióticos", "Receita de Psicotrópicos" };
			var source = SourceJSON.CreateInstance(true);
			var medicines = source.GetWordsThatPointsToType(criteria);
			foreach (var medicine in medicines)
			{
				if (!OriginalText.ToLowerInvariant().Contains(medicine.ToLowerInvariant()))
					continue;
				Name = medicine.CapitalizeFirstLetter();
				ElementValue = Result.Success(Name);
				Dosage = "N/A";
				Unit = "N/A";
				Form = "N/A";
			}
		}
	}

        #endregion Private Methods
        #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
    }
//################################################################################### MedicineAndDosageInSentence  End ##########################################################################################
//################################################################################### SimpleText  ##########################################################################################
    public class SimpleText : BaseElement
    {
        private SimpleText(string text, int startIndex, string connector)
        {
            OriginalText = text;
            StartIndex = startIndex;
            ConnectorBefore = connector;
            ElementValue = text;
        }

        public static SimpleText CreateInstance(string text, int startIndex, string connector)
        {
            return new SimpleText(text, startIndex, connector);
        }
    }
//################################################################################### SimpleText   End ##########################################################################################
//################################################################################### VersionInSentence  ##########################################################################################
public class VersionInSentence : BaseElement//ValueObject
{
    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
	#region Public Fields
	public bool HasVersion => !string.IsNullOrEmpty(Version);
	public bool HasVersionWithPrefix => !string.IsNullOrEmpty(VersionPrefix);
	public bool HasVersionNumberOnly => HasVersion && !HasVersionWithPrefix;
	public string Version { get; private set; } = string.Empty;
	//[JsonIgnore]
	public string VersionPrefix => Version.ReturnOnlyNonNumericCharacters();
	//[JsonIgnore]
	public int VersionNumber => Version.ReturnOnlyNumbersAsInt()!.Value;
	#endregion Public Fields
	#region Constructors
	private VersionInSentence(string partToTest, string parsedVersion = "")
	{
		_originalSentenceToParseDate = partToTest;
		Version = parsedVersion;
	}

	private VersionInSentence(string partToTest)
	{
		OriginalText = partToTest;
	}

	public static VersionInSentence CreateInstance(string partToTest)
	{
		if (string.IsNullOrEmpty(partToTest))
			return NullVersion;
		var instance = new VersionInSentence(partToTest);
		//I do not know but below code increased time in almost 900 ms...
		//instance._rgxForGrabVersionFromFile = new Regex(GrabVersionFromFile, RegexOptions.Compiled | RegexOptions.IgnoreCase);
		instance.GetVersion();
		return instance.ElementValue.IsFailure ? NullVersion : instance;
	}
	/// <summary>
	/// It returns the same Version if it would fail to parse the new partToTest
	/// </summary>
	/// <param name="partToTest"></param>
	/// <param name="oldVersionInSentence"></param>
	/// <returns></returns>
	internal static VersionInSentence UpdateInstance(string partToTest, VersionInSentence oldVersionInSentence, string connectorBefore = "")
	{
		var oldIndex = oldVersionInSentence.StartIndex;
		var connector = connectorBefore == "" ? oldVersionInSentence.ConnectorBefore : connectorBefore;
		var instance = CreateInstance(partToTest);
		if (instance.ElementValue.IsFailure)
			return oldVersionInSentence; //NullVersion
		CopyContextProperly(instance, oldIndex, connector);
		return instance;
	}
	/// <summary>
	/// It returns the same Version if it would fail to parse the new partToTest
	/// </summary>
	/// <param name="partToTest"></param>
	/// <param name="oldVersionInSentence"></param>
	/// <returns></returns>
	public static VersionInSentence TryUpdateInstanceFailingIfNull(string partToTest, VersionInSentence oldVersionInSentence)
	{
		var instance = CreateInstance(partToTest);
		return instance.ElementValue.IsFailure ? oldVersionInSentence : UpdateInstance(partToTest, oldVersionInSentence);
	}
	public static VersionInSentence NullVersion => new(string.Empty, string.Empty);

    #endregion Constructors

    #region Private Methods
    private void GetVersion()
    {
        Result<string> version;
        if (string.IsNullOrEmpty(OriginalText) || DocNameHelper.DifficultyToTestPart(OriginalText))
            version=  Result.Failure<string>("No file version");
        version = GetVersionFromPart(OriginalText);
        if (!version.IsFailure && version.Value.IsNumber())
        {
            version = TestVersionNumberOnly(version.Value);
        }

        if (version.IsFailure && OriginalText.Length < 3 && OriginalText.IsNumber())
        {
            version = TestVersionNumberOnly(OriginalText);
        }

        if (version.IsFailure && OriginalText.ReturnOnlyNumbers().Length > 0 && OriginalText.ReturnOnlyNumbers().Length < 3 && OriginalText.ReturnOnlyNumbers().IsNumber())
        {
            version = TestVersionNumberOnly(OriginalText.ReturnOnlyNumbers());
        }
        ElementValue = version; // "2017"
        if (ElementValue.IsSuccess)
            Version = ElementValue.Value;
    }

    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 Result<string> GetVersionFromPart(string partToTest)
	{
		var version = DocNameHelper.ReturnResult(DocNameHelper.ForGrabVersionFromFile.Value, partToTest, "version", "No file version");
		if (version.IsFailure && !char.IsWhiteSpace(partToTest, 0))
			version = DocNameHelper.ReturnResult(DocNameHelper.ForGrabVersionFromFile.Value, $" {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");
    }
    #endregion Private Methods

    #region Overrides of ValueObject

    protected override IEnumerable<IComparable> GetEqualityComponents()
    {
        yield return _originalSentenceToParseDate;
        yield return Version;
    }

    #endregion
}
//################################################################################### VersionInSentence End ##########################################################################################
//################################################################################### DateInSentence  ##########################################################################################
public class DateInSentence : BaseElement// ValueObject
{
	#region Private fields
	private readonly string _cultureInfo;
	private readonly int? _maxPossibleYear;
	private readonly bool _forceDdmMorMmdd;
	private readonly int _minPossibleYear;
	private readonly bool _acceptWildCard;
	private bool _useTestDateInsteadOfResult;
	#endregion Private fields

	#region Private Constants
	private const string WildCardForDate = "_";
	#endregion Private Constants

	#region Public Fields


	public bool PortugueseMonthErroneouslyAbbreviatedWithoutDot { get; set; }
	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);
	[JsonIgnore]
	public bool DateMaskProvidesYYYY => this.Mask.GetDescription().Contains("yyyy");
	[JsonIgnore]
	public bool DateYearHasWildCard => this.DateAndTime == DateTime.MaxValue;

	public DateFormat Mask { get; private set; } = DateFormat.NoDate;
	public CertaintyAboutElement CertaintyAbout { get; private set; } = CertaintyAboutElement.NonExisting;
	public bool IsDDMM => _cultureInfo == "pt-BR";
	public bool HasDate => DateAndTime != DateTime.MinValue;
	#endregion Public Fields

	#region Constructors
	[JsonConstructor]
	private DateInSentence()
	{

	}
	private DateInSentence(string originalSentenceToParseDate, string cultureInfo, int? maxPossibleYear,
		bool forceDDMMorMMDD, int minPossibleYear, bool acceptWildCard)
	{
		OriginalText = originalSentenceToParseDate;
		_cultureInfo = cultureInfo;
		_maxPossibleYear = maxPossibleYear ??= GetMaxPossibleYear();
		_forceDdmMorMmdd = forceDDMMorMMDD;
		_minPossibleYear = minPossibleYear;
		_acceptWildCard = acceptWildCard;
	}
	public static DateInSentence NullDate =>
		new(string.Empty, string.Empty, int.MaxValue, false, int.MinValue, false)
		{
			DateText = string.Empty,
			DateAndTime = DateTime.MinValue,
			Mask = DateFormat.NoDate,
			CertaintyAbout = CertaintyAboutElement.NonExisting
		};
	//public static DateInSentence NullDate =>
	//    new(string.Empty, DateTime.MinValue, DateFormat.NoDate, CertaintyAboutElement.NonExisting);
	public static DateInSentence ChangeToYYYY(DateInSentence date, DateFormat newMask, string cultureInfo)
	{
		if (date.DateText.Length != 4) throw new ArgumentException("Can only change mask of DDMM or MMDD to YYYY");
		return ChangeMask(date, DateFormat.yyyy, date._cultureInfo);
	}

	public static DateInSentence ChangeToMMDD(DateInSentence date, DateFormat newMask, string cultureInfo)
	{
		if (date.DateText.Length != 4) throw new ArgumentException("Can only change mask of DDMM or YYYY to MMDD");
		return ChangeMask(date, DateFormat.MMdd, date._cultureInfo);
	}
	public static DateInSentence ChangeToDDMM(DateInSentence date, DateFormat newMask, string cultureInfo)
	{
		if (date.DateText.Length != 4) throw new ArgumentException("Can only change mask of MMDD or YYYY to DDMM");
		return ChangeMask(date, DateFormat.ddMM, date._cultureInfo);
	}
	private static DateInSentence ChangeMask(DateInSentence date, DateFormat newMask, string cultureInfo)
	{
		return CreateInstanceProvidingAllCorrectElements(date.DateText, date.DateAndTime, newMask, cultureInfo
			, date.CertaintyAbout, date._maxPossibleYear.HasValue ? date._maxPossibleYear.Value : GetMaxPossibleYear()
			, date._forceDdmMorMmdd, date._minPossibleYear, date._acceptWildCard);
	}

	/// <summary>
	/// As name implies, it will return a date that is a combination of correct arguments; it will not test for validity
	/// </summary>
	/// <param name="dateText"></param>
	/// <param name="dateTime"></param>
	/// <param name="mask"></param>
	/// <param name="cultureInfo"></param>
	/// <param name="certaintyAbout"></param>
	/// <param name="maxPossibleYear"></param>
	/// <param name="forceDDMMorMMDD"></param>
	/// <param name="minPossibleYear"></param>
	/// <param name="acceptWildCard"></param>
	/// <returns></returns>
	public static DateInSentence CreateInstanceProvidingAllCorrectElements(string dateText, DateTime dateTime,
		DateFormat mask, string cultureInfo, CertaintyAboutElement certaintyAbout = CertaintyAboutElement.AbsolutelyCertain
		, int maxPossibleYear = int.MaxValue, bool forceDDMMorMMDD = false, int minPossibleYear = 1990, bool acceptWildCard = false)
	{
		return //new DateInSentence(dateText, dateTime, mask, certaintyAbout);

		new(dateText, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard)
		{
			DateText = dateText,
			DateAndTime = dateTime,
			Mask = mask,
			CertaintyAbout = certaintyAbout
		};
	}

	public static DateInSentence CreateInstanceFromSentence(string dateToParse, string cultureInfo
		, (int start, int end) forbiddenZoneCoordinates, int? maxPossibleYear
		, bool forceDDMMorMMDD = false, int minPossibleYear = 1990, bool acceptWildCard = true)
	{
		var dateBeforeParsing = new DateInSentence(dateToParse, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
		//Below is the slowest place in the whole program, because of the DateTime.TryParseExact
		var hasDate = dateBeforeParsing.GetDate(dateToParse, forbiddenZoneCoordinates);
		//Console.WriteLine($"hasDate at CreateInstanceFromSentence: {hasDate}");
		//var hasDateStatic = GetDateStatic(dateToParse, cultureInfo, forbiddenZoneCoordinates, acceptWildCard);
		if (hasDate.IsFailure)
			return DateInSentence.NullDate;
		var instance = CreateInstance(hasDate.Value, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
		return instance;
	}
	/// <summary>
	/// Create Instance inferring Mask and Format for Date Parsing
	/// </summary>
	public static DateInSentence CreateInstance(string dateToParse, string cultureInfo, int? maxPossibleYear,
		bool forceDDMMorMMDD = false, int minPossibleYear = 1990, bool acceptWildCard = true)
	{
		var dateParsing = new DateInSentence(dateToParse, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
		var raw = dateParsing.OriginalText;
		// 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())
		{
			TryParseNumericOnlyDates(cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, raw, dateParsing);
			//if (DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None,
			//        out var parsedDate))
			//{
			//    dateParsing.DateAndTime = parsedDate;
			//    dateParsing.DateText = raw;
			//    dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
			//}
		}
		else //if (!raw.IsDigit()) MMM or MMMM or ddd or dd or tt
		{
			TryParseDatesWithNonDigits(cultureInfo, raw, dateParsing);
#if DEBUG
			if (string.IsNullOrEmpty(dateParsing.DateText))
				Console.WriteLine($"InferMaskAndFormatForDateParsing: dateParsing {raw} is not digit, ie, MMM or MMMM or ddd or dd or tt");
			//throw new NotImplementedException($"InferMaskAndFormatForDateParsing: dateParsing {raw} is not digit, ie, MMM or MMMM or ddd or dd or tt");
#endif
		}
		//if (!string.IsNullOrEmpty(dateParsing.DateText)) 
		//Below only works because 202_ is a valid date BUT originally DateTime.MinValue and I changed to DateTime.MaxValue
		if (dateParsing.DateAndTime == DateTime.MinValue) return NullDate; // dateParsing;
		dateParsing.ElementValue = Result.Success(dateParsing.DateText);
		return dateParsing;
		//DateInSentence.CreateInstance(raw, parsedDate, dateParsing.Mask, dateParsing.CertaintyAbout);
	}

	private static void TryParseDatesWithNonDigits(string cultureInfo, string raw, DateInSentence dateParsing)
	{
		if (raw.Contains(WildCardForDate))
			TryParseDatesWithWildCard(cultureInfo, raw, dateParsing);
		else //if (!raw.Contains(WildCardForDate))
			TryParseDatesWithNonDigitsOtherThanWildCard(cultureInfo, raw, dateParsing);
		//GrabDatesWithMonthsInLettersOrPureNumbersFromFile
		//grab: 202_
		//[Description("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'")]
		//universalSortable				
	}
	private static DateInSentence TryParseDatesWithWildCard(string cultureInfo, string raw, DateInSentence dateParsing)
	{
		DateTime parsedDate;
		switch (raw.Length)
		{
			// 202_ or 20__ or 20_
			case 3 or 4:
				{
					dateParsing.Mask = DateFormat.yyyy;
					//Below is the way to work because 202_ is a valid date BUT originally DateTime.MinValue and I changed to DateTime.MaxValue
					dateParsing.DateAndTime = DateTime.MaxValue;
					dateParsing.DateText = raw;
					dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
					break;
				}
			case 5: //"18_09".Length
				{
					dateParsing.Mask = IsCulturePortuguese(cultureInfo) ? DateFormat.DDMMIncorrectFormattedWithWildcardBR : DateFormat.DDMMIncorrectFormattedWithWildcardUS;
					_ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
					dateParsing.DateAndTime = parsedDate;
					dateParsing.DateText = raw;
					dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
					break;
				}
			case 10: //"18_09_2023".Length
				{
					dateParsing.Mask = IsCulturePortuguese(cultureInfo) ? DateFormat.FullDateIncorrectFormattedWithWildcardBR : DateFormat.FullDateIncorrectFormattedWithWildcardUS;
					_ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
					dateParsing.DateAndTime = parsedDate;
					dateParsing.DateText = raw;
					dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
					break;
				}
			case >= 7 and <= 14 when HasFullMonth(raw, cultureInfo)://may2021 || fevereiro-2021
				{
					dateParsing.Mask = DateFormat.MMMMyyyyIncorrectFormattedWithWildcard;
					//dateParsing.DateAndTime = DateTime.Parse(raw);
					var couldParseDate = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(),
						new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
					dateParsing.DateText = couldParseDate ? parsedDate.ToString(dateParsing.Mask.GetDescription()) : raw;
					dateParsing.DateAndTime = parsedDate;
					dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
					break;
				}
			case 22 when cultureInfo == "pt-BR":// 2023_abr._10__13_38_12
				{
					//LinqPad uses it but it does not parse date, but VS uses and it parses...
					dateParsing.Mask = DateFormat.personalizedForAnotaçãoOutlookBackupWithDot;
					_ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
					//To circumvent this weary thing, I'm using mask without dot to get date with dot in LinQPad...
					if (parsedDate == DateTime.MinValue)
						_ = DateTime.TryParseExact(raw, DateFormat.personalizedForAnotaçãoOutlookBackup.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
					dateParsing.DateText = raw;
					dateParsing.DateAndTime = parsedDate;
					dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
					break;
				}
			// 2023_abr_10__13_38_12 OR 2023_apr_10__13_38_12
			case 21:
				{
					//LinqPad uses it but it does not parse date, but VS uses and it parses...
					dateParsing.Mask = DateFormat.personalizedForAnotaçãoOutlookBackup;
					var (_, nextCharIsDot) = DateInSentence.GetAbbreviatedMonthPortugueseAndTellIfNextCharIsDot(raw);
					var rawTreated = string.Empty;
					if (!nextCharIsDot)
						rawTreated = cultureInfo == "en-US" ? raw : DateInSentence.AdjustStringForMMMAddingDot(raw, cultureInfo);
					var couldParseDate = DateTime.TryParseExact(rawTreated, IsCulturePortuguese(cultureInfo) ? DateFormat.personalizedForAnotaçãoOutlookBackupWithDot.GetDescription() : dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
					//To circumvent this weary thing, I'm using mask without dot to get date with dot in LinQPad...
					if (parsedDate == DateTime.MinValue)
						_ = DateTime.TryParseExact(rawTreated, DateFormat.personalizedForAnotaçãoOutlookBackup.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
					dateParsing.DateText = raw;
					dateParsing.DateAndTime = parsedDate;
					dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
					break;
				}
		}

		return dateParsing;
	}
	private static DateInSentence TryParseDatesWithNonDigitsOtherThanWildCard(string cultureInfo, string raw, DateInSentence dateParsing)
	{
		DateTime parsedDate;
		if (raw.ContainsOnlyDigitsAndThisSubstring("."))
		{
			switch (raw.Length)
			{
				case 10://"18.09.2023".Length)
					dateParsing.Mask = IsCulturePortuguese(cultureInfo) ? DateFormat.FullDateIncorrectFormattedWithDotBR : DateFormat.FullDateIncorrectFormattedWithDotUS;
					_ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
					dateParsing.DateAndTime = parsedDate;
					dateParsing.DateText = raw;
					dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
					break;
				case 8://"18.09.23".Length)
					dateParsing.Mask = IsCulturePortuguese(cultureInfo) ? DateFormat.FullDateIncorrectTwoDigitsYearAndFormattedWithDotBR : DateFormat.FullDateIncorrectTwoDigitsYearAndFormattedWithDotUS;
					_ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
					dateParsing.DateAndTime = parsedDate;
					dateParsing.DateText = raw;
					dateParsing.CertaintyAbout = CertaintyAboutElement.InformedGuess;
					break;
				case 5:// "18.09".Length)
					dateParsing.Mask = IsCulturePortuguese(cultureInfo) ? DateFormat.DDMMIncorrectFormattedWithDotBR : DateFormat.DDMMIncorrectFormattedWithDotUS;
					_ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
					dateParsing.DateAndTime = parsedDate;
					dateParsing.DateText = raw;
					dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
					break;
				case 4://"23.5".Length)
					dateParsing.Mask = IsCulturePortuguese(cultureInfo) ? DateFormat.DDMIncorrectFormattedWithDotBR : DateFormat.DDMIncorrectFormattedWithDotUS;
					_ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
					dateParsing.DateAndTime = parsedDate;
					dateParsing.DateText = raw;
					dateParsing.CertaintyAbout = CertaintyAboutElement.NotSure;
					break;
			}
		}
		else
		{
			switch (raw.Length)
			{
				case 19 when raw.Contains("/") && raw.Contains(":") && raw.Contains(" ")://"dd/mm/yyyy hh:mm:ss".Length)
																						 //10/04/2023 16:38:12
					dateParsing.Mask = DateFormat.personalizedForAnotaçãoOutlookBackup;
					//dateParsing.DateAndTime = DateTime.Parse(raw);
					var couldParseDate = DateTime.TryParseExact(raw, cultureInfo == "en-US" ? DateFormat.completeUpToSecondsUS.GetDescription() : DateFormat.completeUpToSeconds.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
					dateParsing.DateText = couldParseDate ? parsedDate.ToString(dateParsing.Mask.GetDescription()) : raw;
					dateParsing.DateAndTime = parsedDate;
					dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
					break;
				case >= 7 and <= 14 when HasFullMonth(raw, cultureInfo)://may2021 || fevereiro-2021
					if (raw.Contains(" "))
					{
						dateParsing.Mask = DateFormat.MMMMyyyyWithSpace;
					}
					else if (raw.Contains("."))
					{
						dateParsing.Mask = DateFormat.MMMMyyyyIncorrectFormattedWithDot;
					}
					else
					{
						dateParsing.Mask = DateFormat.MMMMyyyy;
					}
					//dateParsing.DateAndTime = DateTime.Parse(raw);
					couldParseDate = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
					dateParsing.DateText = couldParseDate ? parsedDate.ToString(dateParsing.Mask.GetDescription()) : raw;
					dateParsing.DateAndTime = parsedDate;
					dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
					break;
				case 7 or 8 when HasAbbreviatedMonth(raw, cultureInfo)://fev.2021 || fev2021
					dateParsing.Mask = DateFormat.MMMyyyy;
					_ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo),
						DateTimeStyles.None, out parsedDate);
					if (parsedDate == DateTime.MinValue)
						parsedDate = AdjustStringForMonthAndDot(cultureInfo, raw, dateParsing);
					dateParsing.DateText = raw;
					dateParsing.DateAndTime = parsedDate;
					dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
					break;
				case 5 or 6 when HasAbbreviatedMonth(raw, cultureInfo)://fev.21 || fev21
					dateParsing.Mask = DateFormat.MMMyyIncorrectTwoDigitsYear;
					_ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo),
						DateTimeStyles.None, out parsedDate);
					if (parsedDate == DateTime.MinValue)
						parsedDate = AdjustStringForMonthAndDot(cultureInfo, raw, dateParsing);
					dateParsing.DateText = raw;
					dateParsing.DateAndTime = parsedDate;
					dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
					break;
			}
		}
		return dateParsing;
	}

	private static DateTime AdjustStringForMonthAndDot(string cultureInfo, string raw, DateInSentence dateParsing)
	{
		DateTime parsedDate;
		if (raw.Contains("."))
		{
			_ = DateTime.TryParseExact(DateInSentence.AdjustStringForMMMRemovingDot(raw, cultureInfo)
				, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
		}
		else
		{
			_ = DateTime.TryParseExact(DateInSentence.AdjustStringForMMMAddingDot(raw, cultureInfo)
				, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
		}

		return parsedDate;
	}

	private static void TryParseNumericOnlyDates(string cultureInfo, int? maxPossibleYear, bool forceDDMMorMMDD,
		int minPossibleYear, string raw, DateInSentence dateParsing)
	{
		dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
		var parsedDate = DateTime.MinValue;
		const int sortableLength = 14;//DateFormat.sortable.GetDescription().Length;//yyyyMMddHHmmss
		switch (raw.Length)
		{
			//[Description("dd/MM/yyyy HH:mm:ss")]
			//completeUpToSeconds,
			//[Description("MM/dd/yyyy HH:mm:ss")]
			//completeUpToSecondsUS,
			//ddmmyyyy or mmddyyyy
			case sortableLength:
				//[Description("yyyyMMddHHmmss")]
				//sortable,
				dateParsing.Mask = DateFormat.sortable;
				break;
			case 8:
				{
					dateParsing.Mask = dateParsing.IsDDMM ? DateFormat.ddMMyyyy : DateFormat.MMddyyyy;
					if (DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None,
							out parsedDate))
					{
						dateParsing.DateAndTime = parsedDate;
						dateParsing.DateText = raw;
					}
					else
					{
						dateParsing.Mask = DateFormat.yyyyMMdd;
						if (DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None,
								out parsedDate))
						{
							dateParsing.DateAndTime = parsedDate;
							dateParsing.DateText = raw;
						}
						else
						{
							dateParsing.Mask = DateFormat.NoDate;
							dateParsing.CertaintyAbout = CertaintyAboutElement.NonExisting;
						}
					}
					return;
				}
			//MMyyyy 
			case 6:
				dateParsing.Mask = DateFormat.MMyyyy;
				break;
			//ddMM OR MMdd OR yyyy
			case 4:
				{
					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(), new CultureInfo(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;
					}

					break;
				}
			//dd OR MM OR yy
			case 2:
				throw new NotImplementedException($"InferMaskAndFormatForDateParsing: {raw} dateParsing.Length == 2");
		}
		if (DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None,
				out parsedDate))
		{
			dateParsing.DateAndTime = parsedDate;
			dateParsing.DateText = raw;
			//dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
		}
	}

	public static Result<DateInSentence> Update(string date, DateInSentence valueDateInSentence)
	{
		var oldIndex = valueDateInSentence.StartIndex;
		var connector = valueDateInSentence.ConnectorBefore;
		var tryDate = CreateInstance(date, valueDateInSentence._cultureInfo, valueDateInSentence._maxPossibleYear
			, valueDateInSentence._forceDdmMorMmdd, valueDateInSentence._minPossibleYear, valueDateInSentence._acceptWildCard);
		if (tryDate == NullDate)
			return Result.Failure<DateInSentence>("Invalid date");
		CopyContextProperly(tryDate, oldIndex, connector);
		return Result.Success(tryDate);
	}
	/// <summary>
	/// It returns the same Date if it would fail to parse the new partToTest
	/// </summary>
	/// <param name="date"></param>
	/// <param name="valueDateInSentence"></param>
	/// <param name="connectorBefore"></param>
	/// <returns></returns>
	public static DateInSentence UpdateInstance(string date, DateInSentence valueDateInSentence, string connectorBefore = "")
	{
		var oldIndex = valueDateInSentence.StartIndex;
		var connector = connectorBefore == "" ? valueDateInSentence.ConnectorBefore : connectorBefore;
		var tryDate = CreateInstance(date, valueDateInSentence._cultureInfo, valueDateInSentence._maxPossibleYear
			, valueDateInSentence._forceDdmMorMmdd, valueDateInSentence._minPossibleYear, valueDateInSentence._acceptWildCard);
		if (tryDate == NullDate)
			return valueDateInSentence;//NullDate;
		CopyContextProperly(tryDate, oldIndex, connector);
		return tryDate;
	}
	#endregion Constructors

	#region Private Methods
	private Result<string> GetDate(string partToTest, (int start, int end) forbiddenZoneCoordinates)
	{
		_useTestDateInsteadOfResult = false;
		PortugueseMonthErroneouslyAbbreviatedWithoutDot = false;
		if (string.IsNullOrEmpty(partToTest) || partToTest.DoesNotContainAnyNumbers() || DocNameHelper.DifficultyToTestPart(partToTest))
			return Result.Failure<string>("No date stamp in this file name");
		var hasDate = ReturnDateResult(DocNameHelper.ForGrabDatesUTC.Value, partToTest, "dateUTC",
			"No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates, _useTestDateInsteadOfResult);
		//"No date stamp in this file name", partName, partHasGUID);
		if (hasDate.IsFailure)
		{
			_useTestDateInsteadOfResult = false;
			hasDate = ReturnDateResult(DocNameHelper.ForGrabDatePersonalizedForAnotaçãoOutlookBackup.Value, partToTest, "date",
				"No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates, _useTestDateInsteadOfResult);
			if (hasDate.IsSuccess)
			{
				Mask = DateFormat.personalizedForAnotaçãoOutlookBackup;
				PortugueseMonthErroneouslyAbbreviatedWithoutDot = true;
			}
			if (hasDate.IsFailure)
			{
				hasDate = ReturnDateResult(DocNameHelper.ForGrabDatePersonalizedForAnotaçãoOutlookBackupWithDotAfterMMM.Value, partToTest,
					"date",
					"No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates,
					_useTestDateInsteadOfResult);
				if (hasDate.IsSuccess)
					Mask = DateFormat.personalizedForAnotaçãoOutlookBackupWithDot;
			}
			//"2013_abr._20__13_38_12" for "Miuza de Holanda Fragelli - anotação Outlook_backup_2013_abr._20__13_38_12.pdf"
			//"20/04/2013 13:38:12" for "Miuza de Holanda Fragelli - anotação Outlook_backup_2013_abr_20__13_38_12.pdf"
			//"20/04/2013 13:38:12" for "Miuza de Holanda Fragelli - anotação Outlook_backup_2013_apr_20__13_38_12.pdf"
		}
		if (hasDate.IsFailure)
		{
			_useTestDateInsteadOfResult = false;
			hasDate = ReturnDateResult(DocNameHelper.ForGrabAbbreviatedMonthWithTwoOrFourDigitYearWithDotSeparatingThemOrNot.Value, partToTest, "date",
				"No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates, _useTestDateInsteadOfResult);
			if (hasDate.IsSuccess)
			{
				var length = hasDate.Value.Length;
				var numOfDots = hasDate.Value.CountOccurrences(".");
				PortugueseMonthErroneouslyAbbreviatedWithoutDot = false;
				switch (length)
				{
					case 10 when numOfDots == 2: //15.05.2021
						Mask = IsCulturePortuguese(_cultureInfo)
							? DateFormat.FullDateIncorrectFormattedWithDotBR
							: DateFormat.FullDateIncorrectFormattedWithDotUS;
						break;
					case 8 when numOfDots == 2: //15.05.21
						Mask = DateFormat.FullDateIncorrectTwoDigitsYearAndFormattedWithDotBR;
						break;
					case 8 when numOfDots == 1: //fev.2021
						Mask = DateFormat.MMMdotyyyy;
						break;
					case 7 when numOfDots == 0://fev2021
						Mask = DateFormat.MMMyyyy;
						PortugueseMonthErroneouslyAbbreviatedWithoutDot = IsCulturePortuguese(_cultureInfo) ? true : false;
						break;
					case 6://fev.21
						Mask = DateFormat.MMMdotIncorrectTwoDigitsYear;
						break;
					case 5://fev21
						Mask = DateFormat.MMMyyIncorrectTwoDigitsYear;
						PortugueseMonthErroneouslyAbbreviatedWithoutDot = IsCulturePortuguese(_cultureInfo) ? true : false;
						break;
				}
			}
			if (hasDate.IsFailure)
			{
				hasDate = ReturnDateResult(DocNameHelper.ForGrabDatePersonalizedForAnotaçãoOutlookBackupWithDotAfterMMM.Value, partToTest,
					"date",
					"No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates,
					_useTestDateInsteadOfResult);
				if (hasDate.IsSuccess)
					Mask = DateFormat.personalizedForAnotaçãoOutlookBackupWithDot;
			}
			//"2013_abr._20__13_38_12" for "Miuza de Holanda Fragelli - anotação Outlook_backup_2013_abr._20__13_38_12.pdf"
			//"20/04/2013 13:38:12" for "Miuza de Holanda Fragelli - anotação Outlook_backup_2013_abr_20__13_38_12.pdf"
			//"20/04/2013 13:38:12" for "Miuza de Holanda Fragelli - anotação Outlook_backup_2013_apr_20__13_38_12.pdf"
		}
		if (hasDate.IsFailure)
		{
			_useTestDateInsteadOfResult = false;
			hasDate = ReturnDateResult(DocNameHelper.ForGrabDatesIncorrectFormattedWithInvalidChars.Value, partToTest, "date",
				"No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates, _useTestDateInsteadOfResult);
			if (hasDate.IsSuccess)
			{
				var length = hasDate.Value.Length;
				var numOfDots = hasDate.Value.CountOccurrences(".");
				PortugueseMonthErroneouslyAbbreviatedWithoutDot = false;
				Mask = length switch
				{
					8 when numOfDots == 2 => //15.05.21
						DateFormat.FullDateIncorrectTwoDigitsYearAndFormattedWithDotBR,
					10 when numOfDots == 2 => //15.05.2021
						IsCulturePortuguese(_cultureInfo)
							? DateFormat.FullDateIncorrectFormattedWithDotBR
							: DateFormat.FullDateIncorrectFormattedWithDotUS,
					_ => Mask
				};
			}

		}
		if (hasDate.IsFailure)
		{
			_useTestDateInsteadOfResult = false;
			hasDate = ReturnDateResult(DocNameHelper.ForGrabDatesOrPureNumbersOrDatesWithCardFromPartOfFile.Value, partToTest, "date",
				"No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates, _useTestDateInsteadOfResult);
			//"No date stamp in this file name", partName, partHasGUID);				
		}
		if (hasDate.IsFailure)
		{
			_useTestDateInsteadOfResult = false;
			hasDate = ReturnDateResult(DocNameHelper.ForGrabFullMonthWithTwoOrFourDigitYearWithSomeCharSeparatingThemOrNot.Value, partToTest, "date",
				"No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates, _useTestDateInsteadOfResult);
			//"No date stamp in this file name", partName, partHasGUID);				
		}
		if (hasDate.IsFailure)
		{
			_useTestDateInsteadOfResult = false;
			hasDate = ReturnDateResult(DocNameHelper.ForGrabDatesWithMonthsInLettersOrPureNumbersFromFile.Value, partToTest, "intervalordate",
				"No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates, _useTestDateInsteadOfResult);
			//"No date stamp in this file name", partName, partHasGUID);				
		}
		if (hasDate.IsSuccess && !_useTestDateInsteadOfResult)
		{
			hasDate = FilterAbsurdDates(hasDate, _cultureInfo, Mask, _acceptWildCard, "No date stamp in this file name");
		}
		return hasDate;
	}

	internal static int GetCurrentYearPlus(int toAddCurrent) => DateTime.Now.Year + toAddCurrent;
	internal static int GetMaxPossibleYear(int yearsAhead = 2) => DateTime.Now.Year + yearsAhead;
	internal static bool IsItPossibleToBeDDMMOrMMDD(string dateToTest, string cultureInfo)
	{
		if (dateToTest.Length != 4) return false;
		return DateTime.TryParseExact(dateToTest, DateFormat.ddMM.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out _) ||
			   DateTime.TryParseExact(dateToTest, DateFormat.MMdd.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out _);
	}

	internal static Result<string> FilterAbsurdDates(
		Result<string> hasDate, string cultureInfo, DateFormat mask, 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 (string.IsNullOrEmpty(dateWithoutSpace)) return Result.Failure<string>(errorMsg);
		if (DocNameHelper.DateTryParseExact(dateWithoutSpace, out testDate, new CultureInfo(cultureInfo)))
		//if (DateTime.TryParseExact(dateWithoutSpace, "yyyy", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out testDate) 	   )
		{
			return TestIfDateIsInsideBoundaries(errorMsg, numberOfYearsToConsiderAbsurd, testDate, dateWithoutSpace);
		}
		else if (acceptWildCard && dateWithoutSpace.Contains(WildCardForDate))
		{
			return Result.Success(dateWithoutSpace);
		}
		else if (mask == DateFormat.MMMyyyy && !dateWithoutSpace.Contains("."))
		{ // proved to be incorrect assumptions
			mask = DateFormat.MMMdotyyyy;
			var dateWithDot = AdjustStringForMMMAddingDot(dateWithoutSpace, cultureInfo);
			if (DocNameHelper.DateTryParseExact(AdjustStringForMMMAddingDot(dateWithDot, cultureInfo), out testDate, new CultureInfo(cultureInfo)))
			{
				return TestIfDateIsInsideBoundaries(errorMsg, numberOfYearsToConsiderAbsurd, testDate, dateWithoutSpace);
			}
		}
		//Console.WriteLine("DateTryParseExact FAILURE: " + testDate);
		return Result.Failure<string>($"Invalid date resulting in {testDate.ToString()}");
	}

	private static Result<string> TestIfDateIsInsideBoundaries(string errorMsg, int numberOfYearsToConsiderAbsurd,
		DateTime testDate, string dateWithoutSpace)
	{
		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);
	}
	private static bool InTimeRangeAllowed(int numberOfYearsToConsiderAbsurd, DateTime testDate)
	{
		try
		{
			var tested = Math.Abs(testDate.YearsBetweenNowAndDate());
			return tested < numberOfYearsToConsiderAbsurd;
		}
		catch (Exception)
		{
			return false;
		}
	}

	private Result<string> ReturnDateResult(Regex rgx, string part, string groupName, string errorMsg
		, string cultureInfo, (int start, int end) forbiddenZoneCoordinates, bool useTestDateInsteadOfResult)
	{
		Result<string> result;
		var match = DocNameHelper.GetMatch(rgx, part, groupName, errorMsg, out result);
		if (!result.IsFailure && result.Value.Length <= 1) return Result.Failure<string>(errorMsg);
		if (!result.IsFailure && DocNameHelper.OutOfForbiddenZoneIfSamePart(groupName, match, forbiddenZoneCoordinates.start, forbiddenZoneCoordinates.end)) return result;
		if ((useTestDateInsteadOfResult && result.IsSuccess) || result.IsSuccess && DocNameHelper.DateTryParseExact(result.Value, out _, new CultureInfo(cultureInfo)))
		{
			//use https://regex101.com/r/KESkRm/5 to solve backup_2023_dec_10__13_38_12.pdf
			if (result.Value.Length > 1) part = result.Value;//AdjustStringForMMM(result.Value);
		}
		//https://stackoverflow.com/questions/38948394/datetime-tryparse-fails-at-yyyy-only
		var dateParsed = (DocNameHelper.DateTryParseExact(part, out var testDate, new CultureInfo(cultureInfo)));
		//Above is the slowest place in the whole program, because of the DateTime.TryParseExact
		if (dateParsed && !testDate.IsThisDateNullOrDefault())
			result = Result.Success(!useTestDateInsteadOfResult ? part : testDate.ToString(CultureInfo.CurrentCulture));
		//it works in Outlook_backup_2023_apr_10__13_38_12, but I suspect that it is coincidence ^^^^^^^^^^^ 
		return result;
	}

	internal static string AdjustStringForMMMAddingDot(string resultValue, string cultureInfo)
	{
		//_backup_2023_abr._10__13_38_12 OR _backup_2023_abr_10__13_38_12
		if (!IsCulturePortuguese(cultureInfo) || HasMonthFullPortuguese(resultValue))
			return resultValue;
		var (monthToAddDot, nextCharIsDot) = GetAbbreviatedMonthPortugueseAndTellIfNextCharIsDot(resultValue);
		//if next char is not a dot, add it
		if (!string.IsNullOrEmpty(monthToAddDot) && !nextCharIsDot) // tested in CorrectApplyOrRemoveDotFromPortugueseAbbreviatedMonth
			resultValue = resultValue.AddSubstringAfterThisFoundExcerpt(monthToAddDot, '.'.ToString());
		return resultValue;
	}
	internal static string AdjustStringForMMMRemovingDot(string resultValue, string cultureInfo)
	{
		//_backup_2023_abr._10__13_38_12 OR _backup_2023_abr_10__13_38_12
		if (!IsCulturePortuguese(cultureInfo) || HasMonthFullPortuguese(resultValue))
			return resultValue;
		var (monthToAddDot, nextCharIsDot) = GetAbbreviatedMonthPortugueseAndTellIfNextCharIsDot(resultValue);
		//if next char is a dot, remove it
		if (!string.IsNullOrEmpty(monthToAddDot) && nextCharIsDot) // tested in CorrectApplyOrRemoveDotFromPortugueseAbbreviatedMonth
			resultValue = resultValue.RemoveSubstringAfterThisFoundExcerpt(monthToAddDot, '.'.ToString());
		return resultValue;
	}

	internal static (string monthToAddDot, bool nextCharIsDot) GetAbbreviatedMonthPortugueseAndTellIfNextCharIsDot(
		string resultValue)
	{
		var monthToAddDot = ReturnFirstMatchOf(DocNameHelper.MonthsPortugueseAbbreviated, resultValue);
		//check if next char after monthToAddDot is a dot
		var dot = '.';
		var nextCharIsDot = resultValue.NextCharAfterThisExcerpt(monthToAddDot, dot);
		return (monthToAddDot, nextCharIsDot);
	}

	private static bool HasMonthFullPortuguese(string resultValue)
	{
		return !string.IsNullOrEmpty(ReturnFirstMatchOf(DocNameHelper.MonthsPortugueseFull, resultValue));
	}

	private static bool IsCulturePortuguese(string cultureInfo) => string.Equals(cultureInfo, "pt-BR", StringComparison.Ordinal);

	private static string ReturnFirstMatchOf(List<string> sequence, string textToLookupItemToMatch)
	{
		var match = string.Empty;
		foreach (var item in sequence.Where(item => textToLookupItemToMatch.ToLower().Contains(item)))
		{
			match = item;
			break;
		}
		return match;
	}

	internal static bool HasAbbreviatedMonth(string dateToTest, string cultureInfo)
	{
		if (HasFullMonth(dateToTest, cultureInfo))
			return false;
		//do not forget to test for the FULL month name before testing for the abbreviated
		var months = cultureInfo == "pt-BR" ? DocNameHelper.MonthsPortugueseAbbreviated : DocNameHelper.MonthsEnglishAbbreviated;
		return months.Any(month => dateToTest.ToLower().Contains(month));
	}
	internal static bool HasFullMonth(string dateToTest, string cultureInfo)
	{
		var months = cultureInfo == "pt-BR" ? DocNameHelper.MonthsPortugueseFull : DocNameHelper.MonthsEnglishFull;
		return months.Any(month => dateToTest.ToLower().Contains(month));
	}
	//internal static bool HasAbbreviatedMonth(string dateToTest, string cultureInfo)
	//{
	//    if (HasFullMonth(dateToTest, cultureInfo)) return false;
	//    var months = cultureInfo == "pt-BR" ? DocNameHelper.MonthsPortugueseAbbreviatedDictionary : DocNameHelper.MonthsEnglishAbbreviatedDictionary;
	//    return (months.ContainsKey(dateToTest.ToLower()));
	//}
	//internal static bool HasFullMonth(string dateToTest, string cultureInfo)
	//{
	//    var months = cultureInfo == "pt-BR" ? DocNameHelper.MonthsPortugueseFullDictionary : DocNameHelper.MonthsEnglishFullDictionary;
	//    return (months.ContainsKey(dateToTest.ToLower()));
	//}
	#endregion Private Methods

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

	#endregion
	#region Overrides of Object
	public override string ToString()
	{
		return $"{nameof(DateText)}: {DateText}, {nameof(DateAndTime)}: {DateAndTime.ToString(new CultureInfo(_cultureInfo))}, {nameof(Mask)}: {Mask.GetDescription()}, {nameof(CertaintyAbout)}: {CertaintyAbout}";
	}
	#endregion
}
//################################################################################### DateInSentence   End ##########################################################################################
//################################################################################### IntervalInSentence ##########################################################################################
public enum IntervalType
{
    NormalRange = 0, //"de 1203 até 20041999"
    TemporalClue, //"em 082021"
	RangeOnlyWithNoTemporalClue // "por 100 dias" || "em 2 meses"
}
public class IntervalInSentence : BaseElement// ValueObject
{

	#region Private Fields
	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 Fields

	#region Public Constants

	#endregion Public Constants

	#region Public Fields
	public bool HasInterval => ElementValue.IsSuccess;
	public IntervalType IntervalType { 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 CertaintyAboutElement CertaintyAboutDateBegin => DateBegin?.CertaintyAbout ?? CertaintyAboutElement.NonExisting;
	public CertaintyAboutElement CertaintyAboutDateEnd => DateEnd?.CertaintyAbout ?? CertaintyAboutElement.NonExisting;
	public bool DateBeginHadToGoBackOneYear { get; private set; }
	public int MaxPossibleYear { get; set; }
	public int MinPossibleYear { get; 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", int.MinValue, int.MaxValue);
			nullInterval.ElementValue = Result.Failure<string>(nullInterval._errorMsg);
			return nullInterval;
		}
	}
	//[JsonConstructor]
	private IntervalInSentence()
	{

	}
	private IntervalInSentence(string originalText, CultureInfo cultureInfo, bool sameFrameIntervalIsAllowed, bool forceBeginDatePreviousYearIfReasonable, string errorMsg, int maxPossibleYear, int minPossibleYear)
	{
		MaxPossibleYear = maxPossibleYear;
		MinPossibleYear = minPossibleYear;
		_cultureInfo = cultureInfo.Name;
		_sameFrameIntervalIsAllowed = sameFrameIntervalIsAllowed;
		_forceBeginDatePreviousYearIfReasonable = forceBeginDatePreviousYearIfReasonable;
		_errorMsg = errorMsg;
		OriginalText = originalText;
	}

	internal static IntervalInSentence CreateInstance(string interval, CultureInfo cultureInfo, int maxPossibleYear = int.MaxValue, int minPossibleYear = 1990, 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, maxPossibleYear, minPossibleYear);
		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(DocNameHelper.ForGrabDateIntervalFromPartOfFile.Value, partToTest, "interval",
			_errorMsg);
		if (hasInterval.IsSuccess)
		{
			ElementValue = hasInterval;
			_candidateBegin = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDateIntervalFromPartOfFile.Value, partToTest, "datebegin", _errorMsg);
			_candidateEnd = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDateIntervalFromPartOfFile.Value, partToTest, "dateend", _errorMsg);
			if (_candidateBegin.IsFailure || _candidateEnd.IsFailure) return false;
			var intervalDates = TryCompareIntervalDates(_candidateBegin.Value, _candidateEnd.Value);
			if (intervalDates.dateBegin.IsFailure && intervalDates.dateEnd.IsFailure) return false;
			DateBegin = intervalDates.dateBegin.Value;
			DateEnd = intervalDates.dateEnd.Value;
			TextTemporalRelation = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDateIntervalFromPartOfFile.Value, partToTest, "starting", _errorMsg).Value;
			TextBetween = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDateIntervalFromPartOfFile.Value, partToTest, "link", _errorMsg).Value;
			IntervalType = IntervalType.NormalRange;
			TimeFrame = string.Empty;
			return true; //return IsIntervalValid(partToTest); //? hasInterval : Result.Failure<string>(errorMsg);
		}
		if (hasInterval.IsFailure)
		{
			//var match = DocNameHelper.GetMatch(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "relationandinterval", _errorMsg, out var result);
			//Below cut around 100 ms
			var match = DocNameHelper.GetMatch(DocNameHelper.ForGrabDatesWithMonthsInLettersOrPureNumbersFromFile.Value, partToTest, "relationandinterval", _errorMsg, out var result);
			hasInterval = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDatesWithMonthsInLettersOrPureNumbersFromFile.Value, partToTest, "intervalordate", _errorMsg);
			if (result.Equals(hasInterval))
			{
				ElementValue = Result.Failure<string>(_errorMsg);
				return false;// Result.Failure<string>(errorMsg);
			}
			ElementValue = result;
			IntervalType = IntervalType.TemporalClue; // "em 08/2021"
			// TODO: decide if is IntervalType.TemporalClue OR is IntervalType.RangeOnlyWithNoTemporalClue // "por 100 dias" || "em 2 meses"
			_candidateBegin = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDatesWithMonthsInLettersOrPureNumbersFromFile.Value, partToTest, "intervalordate", _errorMsg);
			_candidateEnd = _candidateBegin;
			if (_candidateBegin.IsFailure) return false;
			TextTemporalRelation = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDatesWithMonthsInLettersOrPureNumbersFromFile.Value, partToTest, "temporalrelation", _errorMsg).Value;
			TextBetween = string.Empty;
			TimeFrame = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDatesWithMonthsInLettersOrPureNumbersFromFile.Value, partToTest, "timeframe", _errorMsg).Value;
			DateBegin = DateInSentence.CreateInstanceProvidingAllCorrectElements(_candidateBegin.Value, DateTime.MinValue, DetermineTimeFrameType(result.Value), _cultureInfo);
		}
		//if (_candidateBegin.IsFailure || _candidateEnd.IsFailure)
		//TextTemporalRelation = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "starting", _errorMsg).Value;
		//TextBetween = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "link", _errorMsg).Value;
		return _candidateBegin.IsSuccess && _candidateEnd.IsSuccess;
	}
	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.CreateInstanceProvidingAllCorrectElements(dateBegin, validDates.dateStarted, format, _cultureInfo))
									, Result.Success(DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEnd, validDates.dateEnded, format, _cultureInfo)));
						}
					}
					break;
				case 8: //ddMMyyyy
						//BUG if I allow date to be yyyyMMdd in interval, it will not be parsed at all
					var formatEnd = IsDDMM
						? DateFormat.ddMMyyyy
						: DateFormat.MMddyyyy;
					var dateEndIsyyyyMMdd = false;
					var dateEndIsDDMM = DateTime.TryParseExact(dateEnd, formatEnd.GetDescription(),
															   new CultureInfo(_cultureInfo), DateTimeStyles.None, out var dateEnded);
					if (dateEnded == DateTime.MinValue)
					{
						formatEnd = DateFormat.yyyyMMdd;
						dateEndIsyyyyMMdd = DateTime.TryParseExact(dateEnd, formatEnd.GetDescription(),
							new CultureInfo(_cultureInfo), DateTimeStyles.None, out dateEnded);
					}
					if (dateEnded == DateTime.MinValue) return (Result.Failure<DateInSentence>(errorMsg), Result.Failure<DateInSentence>(errorMsg));

					if (dateEnded > DateTime.MinValue)
					{
						switch (dateBegin.Length)
						{
							case 8 when !dateEndIsyyyyMMdd://ddMMyyyy
								{
									var beginDDMMDateIsInPreviousYear = CompareDatesWithSameFormat(dateBegin, dateEnd,
										out var format, out var validDates);
									if (beginDDMMDateIsInPreviousYear)
									{
										return (Result.Success(
												DateInSentence.CreateInstanceProvidingAllCorrectElements(dateBegin,
													validDates.dateStarted, format, _cultureInfo))
											, Result.Success(DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEnd, validDates.dateEnded, format, _cultureInfo)));
									}

									break;
								}
							case 8 when dateEndIsyyyyMMdd://ddMMyyyy
								{
									var beginDDMMDateIsInPreviousYear = CompareDatesWithSameFormat(dateBegin, dateEnd,
										out var format, out var validDates);
									if (beginDDMMDateIsInPreviousYear)
									{
										return (Result.Success(
												DateInSentence.CreateInstanceProvidingAllCorrectElements(dateBegin,
													validDates.dateStarted, format, _cultureInfo))
											, Result.Success(DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEnd, validDates.dateEnded, format, _cultureInfo)));
									}

									break;
								}
							case 6 when !dateEndIsyyyyMMdd://almost impossible MMyyyy
#if DEBUG
								throw new NotImplementedException("I did not implemented 'de MMyyyy até ddMMyyyy'");
#endif
								break;
							case 6 when dateEndIsyyyyMMdd://almost impossible yyyyMM
#if DEBUG
								throw new NotImplementedException("I did not implemented 'de yyyyMM até yyyyMMdd'");
#endif
								break;
							case 4 when !dateEndIsyyyyMMdd://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.CreateInstanceProvidingAllCorrectElements(dateBegin,
												ddMMBegin, formatBegin, _cultureInfo)),
											Result.Success(DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEnd,
												dateEnded, formatEnd, _cultureInfo))
										);
									}

									break;
								}
							case 2 when !dateEndIsyyyyMMdd://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.CreateInstanceProvidingAllCorrectElements(dateBegin,
												new DateTime(dateEnded.Year, dateEnded.Month, dayBegin), DateFormat.dd,
												_cultureInfo));
										return (dayInterval,
												Result.Success(DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEnd,
													dateEnded, formatEnd, _cultureInfo))
											);
									}

									errorMsg = "because BeginDate is After EndDate";
									break;
								}
						}
					}
					else //test DateEnd for yyyyMMdd
					{


					}

					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.CreateInstanceProvidingAllCorrectElements(dateBegin, ddMMBegin, formatEnd, _cultureInfo)),
									Result.Success(DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEnd, dateEnded, formatEnd, _cultureInfo))
								   );
						}
						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, _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;

			}

		}
		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, _cultureInfo, MaxPossibleYear, 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,
	   bool sameFrameIntervalIsAllowed = false)
	{
		var (isDateEndDubious, isDateBeginDubious, certaintyAboutYYYY) = DecideDegreeOfCertaintyAboutDates(dateBeginToTest, dateEndToTest);
		var dateBeginTry = DateInSentence.CreateInstance(dateBeginToTest, _cultureInfo, MaxPossibleYear, 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, 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, _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.CreateInstanceProvidingAllCorrectElements(dateBeginToTest, dateStarted, DateFormat.yyyy, _cultureInfo, certaintyAboutYYYY);
			dateEnd = DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEndToTest, dateEnded, DateFormat.yyyy, _cultureInfo, certaintyAboutYYYY);
		}
		else if (dateBeginIsDDMM)
		{
			if (!dateEndIsDDMM || !IsDDMMBeginDateReallyBeforeEndDate(dateBeginToTest, dateEndToTest, formatForDateBeginTry, sameFrameIntervalIsAllowed)) return (dateBegin, dateEnd);
			dateBegin = DateInSentence.CreateInstanceProvidingAllCorrectElements(dateBeginToTest, dateStarted, formatForDateBeginTry, _cultureInfo, certaintyAboutYYYY);
			dateEnd = DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEndToTest, dateEnded, formatForDateBeginTry, _cultureInfo, 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);
	}
	#endregion Private Methods

	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;
	}
	#region Draft
	private bool IsIntervalValid(string partToTest)
	{
		var validBeginInterval =
			DocNameHelper.DateTryParseExact(_candidateBegin.Value, out var beginInterval, new CultureInfo(_cultureInfo));
		var validEndInterval =
			DocNameHelper.DateTryParseExact(_candidateEnd.Value, out var endInterval, new CultureInfo(_cultureInfo));
		var isValid = beginInterval < endInterval;
		return isValid;
	}
	#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 OriginalText;
		yield return DateBeginHadToGoBackOneYear;
		yield return TextBetween;
		yield return TextTemporalRelation;
		yield return TimeFrame;
		yield return DateBegin;
		yield return DateEnd;
	}

	#endregion
	#region Overrides of Object
	public override string ToString()
	{
		return @$"{nameof(IntervalType)}: {IntervalType}
                , {nameof(TextTemporalRelation)}: {TextTemporalRelation}
                , {nameof(TextBetween)}: {TextBetween}
                , {nameof(TimeFrame)}: {TimeFrame}
                , {nameof(DateBegin)}: {DateBegin}
                , {nameof(CertaintyAboutDateBegin)}: {CertaintyAboutDateBegin}
                , {nameof(DateEnd)}: {DateEnd}
                , {nameof(CertaintyAboutDateEnd)}: {CertaintyAboutDateEnd}
                , {nameof(DateBeginHadToGoBackOneYear)}: {DateBeginHadToGoBackOneYear}
                , {nameof(MaxPossibleYear)}: {MaxPossibleYear}, {nameof(MinPossibleYear)}: {MinPossibleYear}";
	}
	#endregion Overrides of Object
}
//################################################################################### IntervalInSentence End ##########################################################################################
//################################################################################### BaseElement  ##########################################################################################
    public class BaseElement : ValueObject
    {
        private string _textValue => ElementValue.IsSuccess ? ElementValue.Value : "No value";
		public int StartIndex { get; set; }
        public int EndIndex
        {
            get
            {
                if (ElementValue.IsFailure) 
                    return StartIndex;
                return StartIndex + ElementValue.Value.Length;
            }

        }
        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");

        public static void CopyContextProperly(BaseElement tryDate, int oldIndex, string connector)
        {
            tryDate.StartIndex = oldIndex;
            tryDate.ConnectorBefore = connector;
        }

        #region Overrides of ValueObject

        protected override IEnumerable<IComparable> GetEqualityComponents()
        {
            yield return StartIndex;
            yield return ConnectorBefore;
            yield return OriginalText;
            yield return _textValue;//ElementValue;
        }

        #endregion
    }
//################################################################################### BaseElement  End ##########################################################################################
//################################################################################### Enums ##########################################################################################								  
    //https://stackoverflow.com/questions/3025361/c-sharp-datetime-to-yyyymmddhhmmss-format
    //https://learn.microsoft.com/en-us/dotnet/standard/base-types/custom-date-and-time-format-strings?redirectedfrom=MSDN
public enum DateFormat
{
	Unknown = -99,
	[Description("ano(s)")]
	NumYears = -4,
	[Description("mês/meses")]
	NumMonths = -3,
	[Description("dia(s)")]
	NumDays = -2,
	//Above is for RangeOnlyWithNoTemporalClue only 
	NoDate = -1,
	
	yyyy = 0,
	MMyyyy,
	[Description("MMM.yy")]
	MMMdotIncorrectTwoDigitsYear,
	MMMyyyy,
	[Description("MMM.yyyy")]
	MMMdotyyyy,
	MMMMyyyy,
	[Description("MMMM_yyyy")]
	MMMMyyyyIncorrectFormattedWithWildcard,
	[Description("MMMM.yyyy")]
	MMMMyyyyIncorrectFormattedWithDot,
	[Description("MMMM yyyy")]
	MMMMyyyyWithSpace,

	[Description("MMMyy")]
	MMMyyIncorrectTwoDigitsYear,
	//[Description("MMM.yy")]
	//MMMyyIncorrectTwoDigitsYearAndFormattedWithDot,

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

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

	dd,
	MM,
	MMM,
	MMMM,

	yyyyMM,
	yyyyMMM,
	yyyyMMMM,
	yyyyMMdd,
	[Description("yyyyMMddHHmmss")]
	sortable,
	[Description("dd/MM/yyyy HH:mm:ss")]
	completeUpToSeconds,
	[Description("MM/dd/yyyy HH:mm:ss")]
	completeUpToSecondsUS,
	[Description("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'")]
	universalSortable,
	[Description("yyyy_MMM_dd__HH_mm_ss")]
	personalizedForAnotaçãoOutlookBackup,
	[Description("yyyy_MMM._dd__HH_mm_ss")]
	personalizedForAnotaçãoOutlookBackupWithDot,
	[Description("dd_MM_yyyy")]
	FullDateIncorrectFormattedWithWildcardBR,
	[Description("MM_dd_yyyy")]
	FullDateIncorrectFormattedWithWildcardUS,
	[Description("dd.MM.yyyy")]
	FullDateIncorrectFormattedWithDotBR,
	[Description("MM.dd.yyyy")]
	FullDateIncorrectFormattedWithDotUS,
	[Description("dd.MM.yy")]
	FullDateIncorrectTwoDigitsYearAndFormattedWithDotBR,
	[Description("MM.dd.yy")]
	FullDateIncorrectTwoDigitsYearAndFormattedWithDotUS,

	[Description("dd_MM")]
	DDMMIncorrectFormattedWithWildcardBR,
	[Description("MM_dd")]
	DDMMIncorrectFormattedWithWildcardUS,
	[Description("dd.MM")]
	DDMMIncorrectFormattedWithDotBR,
	[Description("MM.dd")]
	DDMMIncorrectFormattedWithDotUS,
	[Description("dd.M")]
	DDMIncorrectFormattedWithDotBR,
	[Description("M.dd")]
	DDMIncorrectFormattedWithDotUS
}
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,
        SimplePart,
        WhicheverVersion,
        VersionNumberOnly,
        VersionWithPrefix,
        FileNameDate,
        FileNameInterval,
        GUID,
        DrugNameDose
    }
//################################################################################### Enums End ##########################################################################################	

    // 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
//################################################################################### DocNameHelper ##########################################################################################
public static class DocNameHelper
{
	#region private constants
	/// <summary>
	/// Should check for equality between relationandinterval and intervalordate; if so, the interval is invalid and should be ignored
	/// </summary>
	private 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]{1}\b))(?<timeframe> anos[ .]{0,1}| ano[ .]{0,1}| meses[ .]{0,1}| mês[ .]{0,1}| dias[ .]{0,1}| dia[ .]{0,1})?)";
	////https://regex101.com/r/ZuUZy3/16^^^^^^^^^^^^
	//private 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]{1}\b))(?<timeframe> anos[ .]{0,1}| ano[ .]{0,1}| mês[ .]{0,1}| meses[ .]{0,1}| dias[ .]{0,1}| dia[ .]{0,1})?)";
	////https://regex101.com/r/ZuUZy3/14^^^^^^^^^^^^
	//private 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 ^^^^^^ 
	private const string GrabDatesOrPureNumbersOrDatesWithCardFromPartOfFile = @"(?<date>\d{6,8}|\d{2,3}_{1,2})";
	//https://regex101.com/r/wGCR0g/2 ^^^^^^^^^^^^^^^^^^^^^^^^^^       20__ or 202_  ^^^^^^^^^
	/// <summary>
	/// Some Dates, as from Bronstein, are formatted with WildCardForDate, like Laudo Completo 18_07_2023.pdf
	/// </summary>
	private const string GrabDatesIncorrectFormattedWithInvalidChars = @"(?<![_.]{1})(?<date>\d{2}[_.]{1}\d{2}[_.]{1}(?:\d{4}|\d{2}))"; //(?<date>\d{2}[_.]{1}\d{2}[_.]{1}\d{4})";
																																		//https://regex101.com/r/pCbR7k/3 ^^^^^^^^^^^^^^^^^^^^^^^^^^
	private 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)?)";
	//https://regex101.com/r/DfGFk5/1 ^^^^^^^^^^^^^^^^^^^^^ https://www.utctime.net/ 
	//Use it only to extract from PartOfName
	//private const string GrabDateIntervalFromPartOfFile = @"(?<=\W)(?<interval>(?<starting>[ mçinícandouetr]+?)(?<datebegin>\d+)(?<link>[ eatéfimnldzou]+?)(?<=\W)(?<!\w-)(?<dateend>\d+))";
	////https://regex101.com/r/1UfbIM/1 ^^^^^^^^^^^^^^^^ 
	private const string GrabDateIntervalFromPartOfFile = @"(?<=\W)(?<interval>(?<starting>[ mçinícandouetr]+?)(?<datebegin>\d{2,8}|\d{14}(?!\d))(?<link>[ eatéfimnldzou]+?)(?<=\W)(?<!\w-)(?<dateend>\d{4,8}|\d{14})(?!\d))";
	//https://regex101.com/r/1UfbIM/3 ^^^^^^^^^^^^^^^^ 
	private 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 ^^^^^^^^^^^^^^^^
	private const string GrabDatePersonalizedForAnotaçãoOutlookBackup = @"backup_(?<date>(?<yyyy>(?:19|20)[0-9]{2})_(?<MMM>[JFMASONDjfmasond]{1}[aeiouAEIOUnNvVrRbBlLgGtTzZpPyYcC]{2})_(?<dd>0[1-9]|[12][0-9]|3[01])__(?<hh>0?[0-9]|[1][0-9]|[2][0-3])_(?<mm>[0-9]{2})_(?<ss>[0-9]{2}))";
	//https://regex101.com/r/KESkRm/5 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
	private const string GrabDatePersonalizedForAnotaçãoOutlookBackupWithDotAfterMMM = @"backup_(?<date>(?<yyyy>(?:19|20)[0-9]{2})_(?<MMM>[JFMASONDjfmasond]{1}[aeiouAEIOUnNvVrRbBlLgGtTzZpPyYcC]{2})._(?<dd>0[1-9]|[12][0-9]|3[01])__(?<hh>0?[0-9]|[1][0-9]|[2][0-3])_(?<mm>[0-9]{2})_(?<ss>[0-9]{2}))";
	//https://regex101.com/r/qF6UKF/1 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
	private const string GrabAbbreviatedMonthWithTwoOrFourDigitYearWithDotSeparatingThemOrNot = @"(?<date>(?<datewithdot>(?<MMM>jan|fev|feb|mar|abr|apr|mai|may|jun|jul|ago|aug|set|sep|out|oct|nov|dez|dec)\.(?<yyyy>(?:19|20){0,1}[0-9]{2}))|(?<datewithoutdot>(?<MMM>jan|fev|feb|mar|abr|apr|mai|may|jun|jul|ago|aug|set|sep|out|oct|nov|dez|dec)(?<yyyy>(?:19|20){0,1}[0-9]{2})))";
	//https://regex101.com/r/SaKlyS/4 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
	private const string GrabFullMonthWithTwoOrFourDigitYearWithSomeCharSeparatingThemOrNot = @"(?<date>(?:(?<datewithsomecharseparating>(?<MMM>janeiro|january|fevereiro|february|março|march|abril|april|maio|may|junho|julho|agosto|august|setembro|september|outubro|october|novembro|november|dezembro|december)[-._ ]{1})|(?<datewithoutseparation>(?<MMM>janeiro|january|fevereiro|february|março|march|abril|april|maio|may|junho|julho|agosto|august|setembro|september|outubro|october|novembro|november|dezembro|december)))(?<yyyy>(?:19|20){0,1}[0-9]{2}))";
	//https://regex101.com/r/01Y8JS/3 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

	private const string GrabVersionFromFile = @"(?<version>\sv[ersionão]*[\d@]+[\w@]*|[\d@]+v[ersionão]*[\w@]*)";
	//https://regex101.com/r/BfGfIY/2 ^^^^^^^^^^^^^^^^^^^ 

	//Used at DocName:
	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 -.]*)";

	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})";
	#endregion private constants
	#region Common
	internal static bool DifficultyToTestPart(string partToTest)
	{
		return (partToTest.Length > 10 && partToTest.DoesNotContainAnySpace());
	}
	//
	/// <summary>
	/// TESTED and it is faster than the overload that accepts string pattern
	/// </summary>
	/// <param name="rgx"></param>
	/// <param name="part"></param>
	/// <param name="groupName"></param>
	/// <param name="errorMsg"></param>
	/// <returns></returns>
	internal static Result<string> ReturnResult(Regex rgx, string part, string groupName, string errorMsg)
	{
		_ = GetMatch(rgx, part, groupName, errorMsg, out var result);
		return result;
	}
	//GetMatch is a poor name...
	//Used in App
	internal static Match GetMatch(Regex rgx, string part, string groupName, string errorMsg, out Result<string> result)
	{
		//Edge case: Laudo Ortopédico afastamento laborativo por 100 dias 24082015.pdf
		//Match 1:
		//Group relationandinterval: por 100 dias
		//Group temporalrelation: por
		//Group intervalordate: 100
		//Group timeframe: dias
		//Match 2:
		//Group relationandinterval: 24082015
		//Group temporalrelation:
		//Group intervalordate: 24082015
		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)
	{
		//set Regex flag to global, do not return after first match
		var rgx = new Regex(pattern, RegexOptions.Multiline);
		//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;
	}

	public static readonly Lazy<Regex> ForGrabFakeDelimiterWithoutAnySpaceAround = new(() =>
		new Regex(GrabFakeDelimiterWithoutAnySpaceAround, RegexOptions.Compiled | RegexOptions.IgnoreCase));
	public static readonly Lazy<Regex> ForGrabNameAndExtension = new(() =>
		new Regex(GrabNameAndExtension, RegexOptions.Compiled | RegexOptions.IgnoreCase));
	public static readonly Lazy<Regex> ForGrabDelimiterWithSpaceAround = new(() =>
				   new Regex(GrabDelimiterWithSpaceAround, RegexOptions.Compiled | RegexOptions.IgnoreCase));
	public static readonly Lazy<Regex> ForGrabPartsOfName = new(() =>
				   new Regex(GrabPartsOfName, RegexOptions.Compiled | RegexOptions.IgnoreCase));
	public static readonly Lazy<Regex> ForGrab_GUID_Treated = new(() =>
				new Regex(Grab_GUID_Treated, RegexOptions.Compiled | RegexOptions.IgnoreCase));
	public static List<string> MonthsPortugueseFull =>
		new()
		{
				"janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro", "outubro",
				"novembro", "dezembro"
		};
	//https://stackoverflow.com/questions/2020407/initializing-list-inline
	public static Dictionary<string, string> MonthsPortugueseFullDictionary =>
		MonthsPortugueseFull.ToDictionary(month => month, month => month);
	public static List<string> MonthsPortugueseAbbreviated =>
		new()
		{
				"jan", "fev", "mar", "abr", "mai", "jun", "jul", "ago", "set", "out", "nov", "dez"
		};
	public static Dictionary<string, string> MonthsPortugueseAbbreviatedDictionary =>
		MonthsPortugueseAbbreviated.ToDictionary(month => month, month => month);
	public static List<string> MonthsPortugueseAbbreviatedWithDot =>
		MonthsPortugueseAbbreviated.Select(month => month + ".").ToList();
	public static List<string> MonthsEnglishFull =>
		new()
		{
				"january", "february", "march", "april", "may", "june", "july", "august",
				"september", "october", "november", "december"
		};
	public static Dictionary<string, string> MonthsEnglishFullDictionary =>
		MonthsEnglishFull.ToDictionary(month => month, month => month);
	public static List<string> MonthsEnglishAbbreviated => new()
		{
			"jan", "feb", "mar", "apr", "may", "jun", "jul", "aug",
			"sep", "oct", "nov", "dec"
		};
	public static Dictionary<string, string> MonthsEnglishAbbreviatedDictionary =>
		MonthsEnglishAbbreviated.ToDictionary(month => month, month => month);
	public static bool IsMonthAbbreviationEqualsInPortugueseAndEnglish(string month) =>
		MonthsEnglishAbbreviated.FirstOrDefault(m => m == month) == MonthsPortugueseAbbreviated.FirstOrDefault(m => m == month);
	#endregion Common

	#region Interval and Date
	//public static bool DateMaskProvideYYYY (this DateInSentence thisDate) => thisDate.Mask.GetDescription().Contains("yyyy");
	//public static bool DateYearHasWildCard (this DateInSentence thisDate) => thisDate.DateAndTime == DateTime.MaxValue;
	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[] { "" };
	//								^^^^^^^^^^^^^^^^^^^^^^^^^^ ??
	public static readonly Lazy<Regex> ForGrabDatesWithMonthsInLettersOrPureNumbersFromFile = new(() =>
		new Regex(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, RegexOptions.Compiled | RegexOptions.IgnoreCase));
	public static readonly Lazy<Regex> ForGrabDatesUTC = new(() =>
		new Regex(GrabDatesUTC, RegexOptions.Compiled | RegexOptions.IgnoreCase));
	public static readonly Lazy<Regex> ForGrabDatePersonalizedForAnotaçãoOutlookBackup = new(() =>
		new Regex(GrabDatePersonalizedForAnotaçãoOutlookBackup, RegexOptions.Compiled | RegexOptions.IgnoreCase));
	public static readonly Lazy<Regex> ForGrabDatePersonalizedForAnotaçãoOutlookBackupWithDotAfterMMM = new(() =>
		new Regex(GrabDatePersonalizedForAnotaçãoOutlookBackupWithDotAfterMMM, RegexOptions.Compiled | RegexOptions.IgnoreCase));
	public static readonly Lazy<Regex> ForGrabDatesIncorrectFormattedWithInvalidChars = new(() =>
		new Regex(GrabDatesIncorrectFormattedWithInvalidChars, RegexOptions.Compiled | RegexOptions.IgnoreCase));
	public static readonly Lazy<Regex> ForGrabDatesOrPureNumbersOrDatesWithCardFromPartOfFile = new(() =>
		new Regex(GrabDatesOrPureNumbersOrDatesWithCardFromPartOfFile, RegexOptions.Compiled | RegexOptions.IgnoreCase));
	public static readonly Lazy<Regex> ForGrabDateIntervalFromPartOfFile = new(() =>
		new Regex(GrabDateIntervalFromPartOfFile, RegexOptions.Compiled));// | RegexOptions.IgnoreCase));
	public static readonly Lazy<Regex> ForGrabAbbreviatedMonthWithTwoOrFourDigitYearWithDotSeparatingThemOrNot = new(() =>
		new Regex(GrabAbbreviatedMonthWithTwoOrFourDigitYearWithDotSeparatingThemOrNot, RegexOptions.Compiled | RegexOptions.IgnoreCase));
	public static readonly Lazy<Regex> ForGrabFullMonthWithTwoOrFourDigitYearWithSomeCharSeparatingThemOrNot = new(() =>
		new Regex(GrabFullMonthWithTwoOrFourDigitYearWithSomeCharSeparatingThemOrNot, RegexOptions.Compiled | RegexOptions.IgnoreCase));

	#endregion Interval and Date																		

	#region Version
	public static readonly Lazy<Regex> ForGrabVersionFromFile = new(() =>
		new Regex(GrabVersionFromFile, RegexOptions.Compiled | RegexOptions.IgnoreCase));
	#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));
		if (dateWithoutSpace.DoesNotContainAnyNumbers()) { testDate = DateTime.MinValue; return false; }
		var yyyy = forceDDMM ? "dummyformat" : DateFormat.yyyy.GetDescription();
		// BEWARE!!! if you try to capture yyyy with empty format, it will give error when inside string[] dateFormats
		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();
		//https://stackoverflow.com/questions/13796917/datetime-tryparseexact-and-different-separators
		string[] dateFormatsLength4AndOnlyDigits = { yyyy, ddMM };
		string[] dateFormatsLength5 = { ddMMM };
		string[] dateFormatsLength6AndOnlyDigits = { DateFormat.MMyyyy.GetDescription() };
		string[] dateFormatsLength7 = { DateFormat.MMMyyyy.GetDescription() };
		string[] dateFormatsLength8AndOnlyDigits = { ddMMyyyy };
		string[] dateFormatsLength9 = { ddMMMyyyy };
		string[] dateFormatsLength14AndOnlyDigits = { DateFormat.sortable.GetDescription() };
		//string[] dateFormatsLengthMoreThen10 =
		//{
		//    ddMMyyyyHHmmssWithSlash, DateFormat.universalSortable.GetDescription(),
		//    ddMMMM, ddMMMMyyyy, DateFormat.MMMMyyyy.GetDescription(),
		//    //DateFormat.personalizedForAnotaçãoOutlookBackup.GetDescription(),
		//    //DateFormat.personalizedForAnotaçãoOutlookBackupWithDot.GetDescription(),
		//};
		//string[] dateFormatsForAnotaçãoOutlookBackup =
		//{
		//    DateFormat.personalizedForAnotaçãoOutlookBackup.GetDescription(),
		//    DateFormat.personalizedForAnotaçãoOutlookBackupWithDot.GetDescription(),
		//};
		string[] dateFormatsLengthMoreThen10 =
		{
				ddMMyyyyHHmmssWithSlash, DateFormat.universalSortable.GetDescription(),
				ddMMMM, ddMMMMyyyy, DateFormat.MMMMyyyy.GetDescription(),
				DateFormat.personalizedForAnotaçãoOutlookBackup.GetDescription(),
				DateFormat.personalizedForAnotaçãoOutlookBackupWithDot.GetDescription(),
			};
		string[] dateFormatsAll;
		if (dateWithoutSpace.StringHasOnlyNumbers())
		{
			dateFormatsAll = dateWithoutSpace.Length switch
			{
				4 => dateFormatsLength4AndOnlyDigits,
				6 => dateFormatsLength6AndOnlyDigits,
				8 => dateFormatsLength8AndOnlyDigits,
				14 => dateFormatsLength14AndOnlyDigits,
				_ => new[] { "UnforeseenCase" }
			};
		}
		else
		{

			dateFormatsAll = dateWithoutSpace.Length switch
			{
				5 => dateFormatsLength5,
				7 => dateFormatsLength7,
				9 => dateFormatsLength9,
				_ => dateFormatsLengthMoreThen10
				//Below add 100 ms to the test GenerateListOfCurrent_New_ChangedFiles
				//	"		                            "		TryParseExact		TryParse	
				//	"		                            "	"	    "	Max	Avg	    Max	Avg
				//	All	"	                                        "	847	38		281	10
				//	All	"	                                        "	751	27		312	9
				//	All	"	                                        "	777	32		232	9
				//	"		                            "	"	    "					
				//	dateFormatsLength4AndOnlyDigits	"	            "	777	89		232	27
				//	dateFormatsLength6AndOnlyDigits	"	            "	777	307		232	102
				//	dateFormatsLength8AndOnlyDigits	"	            "	777	48		232	15
				//	dateFormatsLength14AndOnlyDigits	"	        "	777	196		232	65
				//	UnforeseenCase	"	                            "	777	310	    232	129
				//	
				//	dateFormatsLength5	"	                        "	15	3	    15	3
				//	dateFormatsLength7	"	                        "	421	196	    139	69
				//	dateFormatsLength9	"	                        "	155	155	    139	139
				//	dateFormatsLengthMoreThen10	"	                "	777	37	    32	11
				//	
				//	With:
				//	GetProperFormatFor10OrMore	            "	    "	1001 41		188	9
				//	All	"	                                        "	857	33		157	6
				//	All	"	                                        "	862	33		205	8
				//	All	"	                                        "	1001 34		108	7
				//_ => GetProperFormatFor10OrMore(dateWithoutSpace, dateFormatsLengthMoreThen10, dateFormatsForAnotaçãoOutlookBackup)
			};
		}
		//TODO need to change strategy if time is in UTC or not
		//DateTimeStyles.AdjustToUniversal
		//TODO: see if filter mask by length turn it faster, because less formats to try
		var tryDate = DateTime.TryParseExact(dateWithoutSpace, dateFormatsAll, cultureInfo, DateTimeStyles.AssumeLocal, out testDate);
		return tryDate || DateTime.TryParse(dateWithoutSpace, cultureInfo, DateTimeStyles.None, 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"
	}

	private static string[] GetProperFormatFor10OrMore(string dateWithoutSpace, string[] dateFormatsLengthMoreThen10, string[] dateFormatsForAnotaçãoOutlookBackup)
	{
		return dateWithoutSpace.CountOccurrences("_") == 6 ? dateFormatsForAnotaçãoOutlookBackup : dateFormatsLengthMoreThen10;
	}

	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 End ##########################################################################################							  					  
public class TypeOfDoc
{
	//[JsonConstructor]
	public TypeOfDoc(
		string displayName,
		List<string> wordsThatPointsToType
	)
	{
		this.DisplayName = displayName;
		this.WordsThatPointsToType = wordsThatPointsToType;
	}

	public string DisplayName { get; set; }
	public IEnumerable<string> WordsThatPointsToType { get; set; }
}	
//################################################################################### MessageDialogService ##########################################################################################
public interface IMessageDialogService
{
	MessageDialogResult ShowOkCancelDialog(string text, string title,
	  MessageDialogResult defaultResult = MessageDialogResult.Ok);
	MessageDialogResult ShowYesNoDialog(string text, string title,
		MessageDialogResult defaultResult = MessageDialogResult.Yes);
	void ShowInfoDialog(string text, string title = "Info");
}

public enum MessageDialogResult
{
	Ok, //Mapped to Yes
	Cancel, //Mapped to No
	Yes,
	No
}
						  
    /// <summary>
    /// For automated tasks like serialization
    /// </summary>
    public class MessageDialogServiceNone : IMessageDialogService
    {
        #region Implementation of IMessageDialogService

        public MessageDialogResult ShowOkCancelDialog(string text, string title,
            MessageDialogResult defaultResult = MessageDialogResult.Ok)
        {
            return defaultResult;
        }

        public MessageDialogResult ShowYesNoDialog(string text, string title,
            MessageDialogResult defaultResult = MessageDialogResult.Yes)
        {
            return defaultResult;
        }

        public void ShowInfoDialog(string text, string title = "Info")
        {
            //do nothing;
        }

        #endregion
    }			
//################################################################################### MessageDialogService End ##########################################################################################						  
//################################################################################### WrappedCollection ##########################################################################################
public class WrappedCollection<T> : IList<T>
{
	private readonly IList<T> _list = new List<T>();

	public WrappedCollection(IList<T> wrappedCollection)
	{
		if (wrappedCollection == null)
		{
			throw new ArgumentNullException("wrappedCollection");
		}
		this._list = 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
	{
		get { return _list.Count; }
	}

	public bool IsReadOnly
	{
		get { return _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 { return _list[index]; }
		set { _list[index] = value; }
	}

	#endregion

	#region Your Added Stuff

	// Add new features to your collection.

	#endregion
}						  
//################################################################################### WrappedCollection End ##################################################################################

//################################################################################### MyExtensions ##########################################################################################						  

//################################################################################### MyExtensions End ##########################################################################################
// ###################            ##################################      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;
	{
		if (CultureInfo.CurrentCulture.Name.ToString() == "pt-BR")
			return Convert.ToDateTime("01/04/1601 00:00:00"); // ApplicationServices.OutlookDefaultDateForInvalid;
		return Convert.ToDateTime("04/01/1601 00:00:00");
	}
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)
	{
		string txtBefore = null;
		try
		{
			txtBefore = text.GetUntilOrEmpty(beforeThis);
			return txtBefore.Length > 0 ? text.GetUntilOrEmpty(beforeThis).Substring(txtBefore.Length - numberOfChars) : string.Empty;
		}
		catch (Exception ex)
		{
			//Console.WriteLine(ex.Message);
			Console.WriteLine($"GetNumberOfCharsJustBeforeSubstring error {ex.Message}: tried to subtract {txtBefore.Length} – { numberOfChars }");
			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 SubstituteSubstringAtSpecificPositionForAnother(this string text,
		string substringToReplace, string replacement, int position)
	{
		//https://stackoverflow.com/questions/8809354/replace-a-character-at-a-specific-index-in-a-string
		var sb = new StringBuilder(text);
		sb.Remove(position, substringToReplace.Length).Insert(position, replacement);
		return sb.ToString();
	}
	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 bool NextCharAfterThisExcerpt(this string text, string uniqueExcerpt, char dot)
	{
		return text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length < text.Length &&
			   text[text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length] == dot;
	}
	//TODO test it
	public static bool NextCharAfterThisExcerpt(this string text, string uniqueExcerpt, char[] chars)
	{
		return text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length < text.Length &&
			   chars.Contains(text[text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length]);
	}
	public static string AddSubstringAfterThisFoundExcerpt(this string text, string uniqueExcerpt, string toAdd)
	{
		return text.ToLower().Replace(uniqueExcerpt, uniqueExcerpt + toAdd);
	}

	public static string RemoveSubstringAfterThisFoundExcerpt(this string text, string uniqueExcerpt,
		string toRemove)
	{
		return text.ToLower().Replace(uniqueExcerpt + toRemove, uniqueExcerpt);
	}
	public static string AddSubstringAfterThisFirstFoundExcerpt(this string text, string uniqueExcerpt, string toAdd)
	{
		var index = text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal);
		if (index < 0) return text;
		var firstPart = text.Substring(0, index);
		var secondPart = text.Substring(index + uniqueExcerpt.Length);
		return firstPart + uniqueExcerpt + toAdd + secondPart;
	}
	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;
	}
	public static int CountOccurrences(this string text, string pattern)
	{
		//https://stackoverflow.com/questions/541954/how-would-you-count-occurrences-of-a-string-within-a-string-c
		return (text.Length - text.Replace(pattern, "").Length) / pattern.Length;
	}
	/// <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);
	public static bool DoesNotContainAnyNumbers(this string @this) => @this.ReturnOnlyNumbers().Length == 0;
	public static bool StringHasOnlyNumbers(this string @this) => @this.ReturnOnlyNumbers().Length == @this.Length;
	//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);
	//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');
	public static bool ContainsOnlyDigitsAndThisSubstring(this string @this, string substring)
	{
		var resultOk = @this.Contains(substring);
		if (!resultOk) return false;
		@this = @this.Replace(substring, string.Empty);
		return @this.IsDigit();
	}	
	/// <summary>
	/// inHexadecimal = false : returns a decimal hash code
	/// </summary>
	/// <param name="input"></param>
	/// <param name="hashSize"></param>
	/// <param name="inHexadecimal"></param>
	/// <returns></returns>

	public static string ReturnParentFolder(this string pathSource)
	{
		//https://stackoverflow.com/a/30902714/2752308
		return Path.GetFullPath(Path.Combine(pathSource, @"..\"));
	}
	/// <summary>
	/// Extension to use with Root path, adding distal path as argument
	/// </summary>
	/// <param name="pathWithRoot"></param>
	/// <param name="pathDistal"></param>
	/// <returns></returns>
	public static string CombinePaths(this string pathWithRoot, string pathDistal)
	{
		var networkFolder = !pathWithRoot.Contains(":");
		var pathOne = pathWithRoot.Split(@"\".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
		var pathTwo = pathDistal.Split(@"\".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
		var pathFinal = pathOne.Concat(pathTwo);
		var preFinalPath = Path.Combine(pathFinal.ToArray());
		if (networkFolder)
			return "\\\\" + preFinalPath;
		return preFinalPath.Contains(":\\") ? preFinalPath : preFinalPath.Replace(":", ":\\");
	}
}
// ###################            ##################################      StringTextExtensions      ##################################            ###################
// ###################            ##################################      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 End     ##################################            ###################
// ###################            ##################################      Guard      ##################################            ###################
public class Guard //https://stackoverflow.com/a/64768572/2752308
    {
        /// <summary>
        /// It will scan all Properties of Class, and will Throw if any are not initialized
        /// </summary>
        /// <param name="param"></param>
        /// <exception cref="ArgumentNullException"></exception>
        public static void ThrowIfNull(object param)
        {
            var props = param.GetType().GetProperties();
            foreach (var prop in props)
            {
                var name = prop.Name;
                var val = prop.GetValue(param, null);

                _ = val ?? throw new ArgumentNullException(name);
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="argumentValue"></param>
        /// <param name="argumentName">Call it with nameof()</param>
        /// <exception cref="ArgumentNullException"></exception>
        public static void ThrowIfNull(object argumentValue, string argumentName)
        {
            if (argumentValue == null)
            {
                throw new ArgumentNullException(argumentName);
            }
        }

        /// <summary>
        /// As name is telling, throws:
        /// ArgumentNullException
        /// ArgumentOutOfRangeException for string.Empty
        /// ArgumentException if it is not string
        /// </summary>
        /// <param name="argumentValue"></param>
        /// <param name="argumentName"></param>
        public static void ThrowIfStringNullOrEmptyOrNotString(object argumentValue, string argumentName)
        {
            // Working:
            //if (argumentValue == null)
            //    throw new ArgumentNullException(argumentName);
            ////if (argumentValue is string && ((string)argumentValue).Length == 0)
            //if (argumentValue is string { Length: 0 })
            //    throw new ArgumentOutOfRangeException(argumentName);
            //if (argumentValue is not string) 
            //    throw new ArgumentException(argumentName);

            switch (argumentValue)
            {
                case null:
                    throw new ArgumentNullException(argumentName);
                //if (argumentValue is string && ((string)argumentValue).Length == 0)
                case string { Length: 0 }:
                    throw new ArgumentOutOfRangeException(argumentName);
            }
            if (argumentValue is not string)
                throw new ArgumentException(argumentName);
        }
    }
// ###################            ##################################      Guard End    ##################################            ###################
//https://jsontostring.com/convert-json-to-one-line/
public class SourceJSON
{
	private readonly bool _fromFixString;
	private readonly Lazy<List<TypeOfDoc>> _deserializeObject;
	private SourceJSON(bool fromFixString)
	{
		_fromFixString = fromFixString;
		_deserializeObject = GetAllTypeOfDocs();
	}

	public static SourceJSON CreateInstance(bool fromFixString)
	{
		return new SourceJSON(fromFixString);
	}
	public IEnumerable<string> GetWordsThatPointsToType(string[] criteria)
	{
		var wordsThatPointToTypes = new List<string>();
		if (!_deserializeObject.IsValueCreated) return wordsThatPointToTypes;
		//var jArray = JsonConvert.DeserializeObject<JArray>(json);
		//https://stackoverflow.com/a/41810862/2752308
		//foreach (JObject item in jArray) // <-- Note that here we used JObject instead of usual JProperty
		foreach (var typeOfDoc in _deserializeObject.Value!)
		{
			//see PatientManagerMDWinForms.Tests.WinServices
			//      .GetWordsThatPointToType_FromDifferentLINQ_Methods_SameResult()

            //var displayName = item.GetValue("DisplayName").ToString();
            if (criteria.Contains(typeOfDoc.DisplayName))
            //if (criteria.Contains(displayName))
            {
                //wordsThatPointToTypes.AddRange(
                //    item.GetValue("WordsThatPointsToType")
                //        .Select(word => word.ToString()));
                wordsThatPointToTypes.AddRange(
                    typeOfDoc.WordsThatPointsToType.ToList());
            }
        }
        return wordsThatPointToTypes;
    }

	private Lazy<List<TypeOfDoc>> GetAllTypeOfDocs()
	{
		var json = _fromFixString ? TypeOfPatientDocKeyWordsFixed : TypeOfPatientDocKeyWords().Value;
		var deserializeObject = JsonConvert.DeserializeObject<List<TypeOfDoc>>(json);
		//        return deserializeObject == null ? new Lazy<List<TypeOfDoc>>() : new Lazy<List<TypeOfDoc>>(() => deserializeObject);
		return new Lazy<List<TypeOfDoc>>(() => deserializeObject);
	}


	private const string TypeOfPatientDocKeyWordsFixed = "[{\"DisplayName\":\"Exames Laboratoriais\",\"WordsThatPointsToType\":[\"Revisão\",\"laboratorial\",\"laboratório\",\"fatores de risco\",\"hemograma\",\"sangue\",\"urina\",\"fezes\"]},{\"DisplayName\":\"Exames de Imagem\",\"WordsThatPointsToType\":[\"tomografia\",\"ressonância\",\"cintilografia\",\"RM\",\"TC\",\"Duplex\",\"Densitometria\",\"carótidas\",\"ecocardiograma\",\"ecocardiografia\",\"eco\",\"Tomossíntese\",\"US\",\"Ultrassonografia\",\"Ultra-sonografia\"]},{\"DisplayName\":\"Exames Especiais\",\"WordsThatPointsToType\":[\"polissonografia\",\"Mapeamento retina\",\"Campo visual\",\"fundoscopia\",\"EDA\",\"colonoscopia\",\"Holter\",\"MAPA\",\"ergometria\",\"prova de esforço\",\"prova de função respiratória\",\"ergoespirometria\",\"Escore de cálcio\",\"ergometria\",\"espirometria\",\"EMNG\"]},{\"DisplayName\":\"ECG\",\"WordsThatPointsToType\":[\"eletrocardiograma\",\"ECG\",\"Pulsebit\",\"HeartCheck Report\"]},{\"DisplayName\":\"Exames outros em geral\",\"WordsThatPointsToType\":[\"exame\",\"notas e exames\"]},{\"DisplayName\":\"Receituário\",\"WordsThatPointsToType\":[\"Receituário\",\"Receita\"]},{\"DisplayName\":\"Receita de Controlados\",\"WordsThatPointsToType\":[\"RECEITUÁRIO CONTROLE ESPECIAL\"]},{\"DisplayName\":\"Receita de Antibióticos\",\"WordsThatPointsToType\":[\"AMICACINA\",\"AMOXICILINA ;CLAVULANATO DE POTÁSSIO\",\"AMOXICILINA\",\"AMOXICILINA;SULBACTAM\",\"AMPICILINA\",\"ANFOTERICINA B\",\"ANIDULAFUNGINA\",\"AXETIL CEFUROXIMA\",\"AXETILCEFUROXIMA\",\"AZITROMICINA\",\"AZTREONAM\",\"CASPOFUNGINA\",\"CEFACLOR\",\"CEFADROXILA\",\"CEFALEXINA\",\"CEFUROXIMA\",\"CETOCONAZOL\",\"CILASTATINA;IMIPENÉM\",\"CLAVULANATO DE POTÁSSIO;AMOXICILINA\",\"CLAVULANATO DE POTÁSSIO;ÁCIDO CLAVULÂNICO;AMOXICILINA\",\"CLORANFENICOL\",\"COLISTINA\",\"Ciprofloxacina\",\"Ciprofloxacino\",\"Cipro\",\"DAPTOMICINA\",\"DI ETAMBUTOL\",\"DOXICICLINA\",\"DOXICICLINA\",\"ERTAPENÉM\",\"ESTREPTOMICINA\",\"ETIONAMIDA\",\"FLUCONAZOL\",\"FOSFOMICINA\",\"FOSFOMICINA TROMETAMOL\",\"GENTAMICINA\",\"IMIPENÉM\",\"IMIPENÉM;CILASTATINA\",\"ISAVUCONAZÔNIO\",\"ISONIAZIDA\",\"ITRACONAZOL\",\"Levofloxacina\",\"Levofloxacino\",\"LIMECICLINA\",\"LINEZOLIDA\",\"MEROPENÉM\",\"MICAFUNGINA\",\"MINOCICLINA\",\"Metronidazol\",\"Moxifloxacina\",\"Moxifloxacino\",\"NISTATINA\",\"PIPERACILINA\",\"PIPERACILINA;TAZOBACTAM\",\"PIRAZINAMIDA\",\"POLIMIXINA B\",\"POSACONAZOL\",\"RIFAMPICINA\",\"SULBACTAM\",\"SULBACTAM;AMPICILINA\",\"SULFADIAZINA\",\"TAZOBACTAM\",\"TAZOBACTAM;PIPERACILINA\",\"TEDIZOLIDA\",\"TEICOPLANINA\",\"TERBINAFINA\",\"TETRACICLINA\",\"TIANFENICOL\",\"TIGECICLINA\",\"TOBRAMICINA\",\"VANCOMICINA\",\"VORICONAZOL\"]},{\"DisplayName\":\"Receita de Psicotrópicos\",\"WordsThatPointsToType\":[\"AGOMELATINA\",\"AMITRIPTILINA\",\"BUPROPIONA\",\"CARBONATO DE LÍTIO\",\"CITALOPRAM\",\"CLOMIPRAMINA\",\"DESVENLAFAXINA\",\"DONEPEZILA\",\"DULOXETINA\",\"ESCITALOPRAM\",\"FLUOXETINA\",\"FLUVOXAMINA\",\"IMIPRAMINA\",\"LÍTIO\",\"MAPROTILINA\",\"MEMANTINA\",\"MIRTAZAPINA\",\"MIRTAZAPINA\",\"NORTRIPTILINA\",\"PAROXETINA\",\"REBOXETINA\",\"SERTRALINA\",\"TIANEPTINA\",\"TRAZODONA\",\"VENLAFAXINA\",\"VILAZODONA\",\"VORTIOXETINA\"]},{\"DisplayName\":\"Pedido de Parecer ou Segunda Opinião\",\"WordsThatPointsToType\":[\"Parecer\"]},{\"DisplayName\":\"Encaminhamento de Paciente para Emergência, Internação ou Método Complementar\",\"WordsThatPointsToType\":[\"Encaminhamento\"]},{\"DisplayName\":\"Risco Cirúrgico\",\"WordsThatPointsToType\":[\"Risco Cirúrgico\",\"Avaliação de risco\"]},{\"DisplayName\":\"Atestados ou Dispensas\",\"WordsThatPointsToType\":[\"Atestado\",\"Dispensa\",\"Afastamento de trabalho\"]},{\"DisplayName\":\"Relatório Somente\",\"WordsThatPointsToType\":[\"Relatório\",\"Sumário de Alta\"]},{\"DisplayName\":\"Emissão de Laudo\",\"WordsThatPointsToType\":[\"Laudo\",\"Pericia\",\"Pericial\"]},{\"DisplayName\":\"Recibo somente\",\"WordsThatPointsToType\":[\"Recibo\"]},{\"DisplayName\":\"Relatório com recibo\",\"WordsThatPointsToType\":[\"Relatório com recibo\",\"Relatório e recibo\",\"Relatório + recibo\"]},{\"DisplayName\":\"Sinais de Alerta\",\"WordsThatPointsToType\":[\"Sinais de Alerta\"]},{\"DisplayName\":\"Pedido Especial\",\"WordsThatPointsToType\":[\"Pedido\",\"Solicitação\"]},{\"DisplayName\":\"Pedido de Transporte\",\"WordsThatPointsToType\":[\"Transporte\",\"Ambulância\"]},{\"DisplayName\":\"Pedido de Assistência Domiciliar ou Home-Care\",\"WordsThatPointsToType\":[\"Assistência Domiciliar\",\"Home-Care\"]},{\"DisplayName\":\"Receita em Formato Grade com aprazamento e checagem\",\"WordsThatPointsToType\":[\"Receita em Formato Grade\",\"Prescrição\"]},{\"DisplayName\":\"Grade de sinais vitais\",\"WordsThatPointsToType\":[\"Grade de sinais vitais\",\"Grade sinais\"]},{\"DisplayName\":\"Pendências para próxima consulta\",\"WordsThatPointsToType\":[\"Pendências\",\"Trazer próxima consulta\"]},{\"DisplayName\":\"Minhas Anotações\",\"WordsThatPointsToType\":[\"Anotação Outlook\",\"Anotação\",\"Consulta n\",\"Consulta em\",\"Evolução\"]}]";
	//public static Lazy<string> TypeOfPatientDocKeyWords(bool fromFixString) => fromFixString ? new Lazy<string>(() => TypeOfPatientDocKeyWordsFixed) : new Lazy<string>(GetTypeOfPatientDocKeyWords);
	public Lazy<string> TypeOfPatientDocKeyWords() => new(GetTypeOfPatientDocKeyWords);
	private string GetTypeOfPatientDocKeyWords()
	{
		var json = string.Empty;
		try
		{
			var patientsSourceFolder = "";//AuxiliaryFolderStructure.Data.Path;
			var docKeyWords = "";//patientsSourceFolder.CombinePaths("TypeOfPatientDocKeyWords.json");
			using var sr = new StreamReader(docKeyWords);
			json = sr.ReadToEnd();
		}
		catch (Exception)
		{
			Console.WriteLine($"Error reading TypeOfPatientDocKeyWords.json at {nameof(GetTypeOfPatientDocKeyWords)}");
			return string.Empty;
		}
		return json;
	}
}

​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 Newtonsoft.Json;
//  Line    ##########
//  154 Program End
//  155 DocName
//  905 NamePart
//  1621    InNameGUID
//  1706    MedicineAndDosageInSentence
//  1814    SimpleText
//  1831    VersionInSentence
//  1993    DateInSentence
//  2818    IntervalInSentence
//  3386    BaseElement
//  3429    Enums
//  3569    DocNameHelper
//  3956    TypeOfDoc
//  3972    MessageDialogService
//  4017    WrappedCollection
//  4128    MyExtensions
//  4132    DateTimeExtensions
//  4315    StringTextExtensions
//  4730    EasyOfficeFolderExtensions
//  4759    ObjectTextExtensions
//  4943    Guard
//  Line    ##########
#region private::tests
public class Program
{
    public static void Main()
    {
        // Set the current culture
        var culture = new CultureInfo("pt-BR"); //("en-US"); // it does capture interval "entre 3005 a 14062013" 
        //var culture = new CultureInfo("en-US"); // it does NOT capture interval "entre 3005 a 14062013" 
        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;
        //Console.WriteLine(System.Diagnostics.Debugger.IsAttached);
        Console.WriteLine(System.IO.Directory.GetLogicalDrives());
        TestNameParts();
    }
    public static void TestNameParts()
    {/**/
    (string name, string culture)[] nameTests = {
                        /**/  ("Laudo médico com afastamento por 2 meses 13042021.pdf", "pt-BR")
                        , ("Laudo médico com afastamento por 2 meses .pdf", "pt-BR")
                        , ("Laudo médico com afastamento por 100 dias.pdf", "pt-BR")
                        , ("Prontuário Itau com anotações entre 2007 e 2021.pdf", "pt-BR")
                        , ("Recibos comparecimento a Fisioterapia entre 052016 e 122019.pdf", "pt-BR")
                        , ("US abdominal˗cisto hepático_5f9a739a-0b2e-4fcc-9228-81035e6e50ea 23122022 v3.docx", "pt-BR")
                        , ("Ruy Quiroga_20230605161406.pdf", "pt-BR")
                        , ("Aderaldo Vieira Chaves - SOLICITAÇÃO DE EXAME_5f9a739a-0b2e-4fcc-9228-81035e6e50ea.pdf", "pt-BR")
                        , ("Nome do paciente D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL_5f9a739a-0b2e-4fcc-9228-81035e6e50ea durante internação Copa D'Or de 12 a 15052017 - Ciprofloxacino 500 mg 3 2017.pdf", "pt-BR")
                        , ("Nome do paciente - exame laboratorial amplo 3 - 23122022.docx", "pt-BR")
                        , ("Nome do paciente - exame laboratorial amplo - 23122022 2.docx", "pt-BR")
                        , ("Nome do paciente - exame laboratorial amplo - 122022 2.docx", "pt-BR")
                        , ("Nome do paciente - relatório internação de 12 a 20122022 - 2 20__.docx", "pt-BR")
                        , ("Nome do paciente - exame laboratorial amplo - 23122022 v2.docx", "pt-BR")
                        , ("Nome do paciente - exame laboratorial amplo v3 - 23122022.docx", "pt-BR")
                        , ("Nome do paciente - exame laboratorial amplo - 122022 v2.docx", "pt-BR")
                        , ("Nome do paciente - relatório internação de 12 a 20122022 - v2 20__.docx", "pt-BR")
                        , ("US abdominal-cisto hepático 23122022.docx", "pt-BR")
                        , ("US abdominal˗cisto hepático 23122022.docx", "pt-BR")
                        , ("US abdominal–cisto hepático 23122022.docx", "pt-BR")
                        , ("US abdominal - cisto hepático 23122022.docx", "pt-BR")
                        , ("US abdominal - cisto hepático v3 23122022.doc", "pt-BR")
                        , ("US abdominal 23122022.docx", "pt-BR")
                        , ("US abdominal - 23122022.docx", "pt-BR")
                        , ("Nome do paciente - exame laboratorial amplo v2 - 23122022.docx", "pt-BR")
                        , ("Nome do paciente - v2 23122022.docx", "pt-BR")
                        , ("Outro paciente - exame laboratorial amplo para home-care - v2 23122022.docx", "pt-BR")
                        , ("Nome do paciente - relatório internação de 12 a 20122022 - v2 23122022.docx", "pt-BR")
                        , ("Nome do paciente - exame laboratorial amplo - 202_ v3.docx", "pt-BR")
                        , ("Nome do paciente D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Ciprofloxacino 500 mg 2017.pdf", "pt-BR")
                        , ("Fulano Sicrano Beltrano - relatório internação - de 1208 até 20062021 - erosão traqueal - v2 12072021.docx", "pt-BR")
                        , ("Paulo Afonso Zavataro - Recibo PF referente ao período de 06 a 11082023 internação no Hospital Copa Star.pdf", "pt-BR")
                        , ("Paulo Afonso Zavataro - Recibo PJ referente ao período de 12 a 17082023 internação no Hospital Copa Star - NFSe_00003478_02874440.pdf", "pt-BR")
                        , ("Paulo Afonso Zavataro - Relatório e Recibo PF referente ao período de 06 a 11082023 internação no Hospital Copa Star - 77d93944-071c-4f01-8788-838d2a204a3d.pdf", "pt-BR")
                        , ("Waldenice de Albuquerque Haidamus - Relatório da internação entre 3005 a 14062013.docx", "pt-BR")
                        , ("Miuza de Holanda Fragelli - anotação Outlook_backup_2013_abr._20__13_38_12.pdf", "pt-BR")
                        , ("Miuza de Holanda Fragelli - anotação Outlook_backup_2013_apr_20__13_38_12.pdf", "en-US") 
                        , ("Miuza de Holanda Fragelli - anotação Outlook_backup_2013_abr_20__13_38_12.pdf", "pt-BR") 
                        , ("Gilda Elena Brandão Andrade D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Zolpidem SL 5 mg 082021.docx", "pt-BR") 
                        , ("Gilda Elena Brandão Andrade D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Zolpidem CR 6,25 mg.docx", "pt-BR") 
                        , ("x - RECEITUÁRIO CONTROLE ESPECIAL - trazodona retard 150 mg", "pt-BR") 
                        , ("x - RECEITUÁRIO CONTROLE ESPECIAL - Prolopa HBS 100_25 mg.docx", "pt-BR") 
                        , ("x - RECEITUÁRIO CONTROLE ESPECIAL - Prolopa orodispersível 125 mg.docx", "pt-BR") 
                        , ("x - RECEITUÁRIO CONTROLE ESPECIAL - Parkidopa 25_250 mg", "pt-BR") 
                        , ("x - RECEITUÁRIO CONTROLE ESPECIAL - Parkidopa 25_250 mg.docx", "pt-BR") 
                        , ("x - RECEITUÁRIO CONTROLE ESPECIAL - pramipexol Sifrol 1,5 mg.docx", "pt-BR") 
                        , ("x - RECEITUÁRIO CONTROLE ESPECIAL - Rivastigmina Exelon Patch 9 mg.docx", "pt-BR") 
                        , ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - 23.05.pdf", "pt-BR") 
                        , ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - 05.23.pdf", "en-US") 
                        , ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - 23.5.pdf", "pt-BR") 
                        , ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - 5.23.pdf", "en-US")
                        , ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - abr.2005.pdf", "pt-BR") 
                        , ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - abr2005.pdf", "pt-BR") 
                        , ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - apr2005.pdf", "en-US") 
                        , ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - march2021.pdf", "en-US") 
                        , ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - march.2021.pdf", "en-US") 
                        , ("CARLOS ANTONIO MENEZES AMARAL BARBOSA - março2021.pdf", "pt-BR") 
                        ,("CARLOS ANTONIO MENEZES AMARAL BARBOSA - março.2021.pdf", "pt-BR") 
                         /**/};
    var docs = new List<DocName>();
    foreach (var fileName in nameTests)
    {
        var docName = DocName.CreateInstance(fileName.name, new MessageDialogServiceNone(), false, fileName.culture);
        docs.Add(docName);
    }
        var orderedDocs = DocNameHelper.OrderDocsByDate(docs).ToArray();
        var allDates = orderedDocs.Select(doc => doc.GetDateTimeOrLastPartOfIntervalForOrderDoc()).ToList();
        foreach (var n in allDates)
        {
            Console.WriteLine(n);
        }
        Console.WriteLine();
        Console.WriteLine($"################################################  Ordered docs by Date ################################################");
        
        foreach (var n in orderedDocs)
        {
            //if    (string.IsNullOrEmpty(test)) { 
            Console.WriteLine($"######  {n.FullNameWithExtension}  ######");
            Console.WriteLine($"-------------------------------------------------------------------------------------");
            //TODO: implement ToString() for NamePart
            //n.Dump();         
            Console.WriteLine($"FirstPart: {(n.FirstPartName.IsSuccess ? n.FirstPartName.Value : n.FirstPartName.Error)}");// .ToString());//
            Console.WriteLine();
            Console.WriteLine($"MiddlePart: {(n.MiddlePartName.IsSuccess ? n.MiddlePartName.Value : n.MiddlePartName.Error)}");// .ToString());//
            Console.WriteLine();
            Console.WriteLine($"LastPart: {(n.LastPartName.IsSuccess ? n.LastPartName.Value : n.LastPartName.Error)}");// .ToString());//
            Console.WriteLine();
            Console.WriteLine($"Extension: {n.Extension}");// .ToString());//
            Console.WriteLine();
            //Console.WriteLine($"ToString: {n.ToString()}");// .ToString());//
            Console.WriteLine("######################################################################################"); Console.WriteLine();
        }
        Console.WriteLine();
    }
}
#endregion 
//################################################################################### Program End ##########################################################################################                          
#region private::Main
//################################################################################### DocName ##########################################################################################        
    public class DocName : ValueObject//<DocName>
    {
        private readonly IMessageDialogService _dialog;
        private readonly bool _raiseEvents;
        private readonly int _maxNumOfParts;
​
        #region Private Fields
        private string _name;
        private int _maxNumDelimiter;
        private string _patientNameFromDocType = NoNameFromDocType;
        private const string NoNameFromDocType = "No DisplayName From DocType";
        #endregion Private Fields 
​
        #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 Constructors and Destructor
        [JsonConstructor]
        private DocName() { }
​
    private DocName(string fullNameWithExtension, IMessageDialogService dialog, bool raiseEvents, string culture, int maxNumOfParts = 3)
    {
        if (string.IsNullOrEmpty(fullNameWithExtension))
            throw new ArgumentException("Value cannot be null or empty.", nameof(fullNameWithExtension));
        _dialog = dialog;
        _raiseEvents = raiseEvents;
        this._maxNumOfParts = maxNumOfParts;
        CultureInfoName = culture;
        OriginalNameBeforeTreat = fullNameWithExtension;
        GetParts(fullNameWithExtension);
    }
​
    /// <summary>
    /// If not specified, there are some calculations about both the maximum and minimum possible year for a date or interval in a sentence
    /// Currently, it is hardcoded 1990 as minimum value, but it should be added as configuration in the future
    /// </summary>
    /// <param name="fullNameWithExtension"></param>
    /// <param name="dialog"></param>
    /// <param name="raiseEvents"></param>
    /// <param name="culture"></param>
    /// <param name="maxPossibleYear"></param>
    /// <param name="minPossibleYear"></param>
    /// <returns></returns>
    public static DocName CreateInstance(string fullNameWithExtension, IMessageDialogService dialog,
        bool raiseEvents, string culture, int maxPossibleYear = int.MinValue, int minPossibleYear = int.MaxValue)
    {
        if (maxPossibleYear == int.MinValue)
            maxPossibleYear = DateInSentence.GetMaxPossibleYear();
        if (minPossibleYear == int.MaxValue)
            minPossibleYear = 1990; //TODO add this as configuration
        return new DocName(fullNameWithExtension, dialog, raiseEvents, culture) { MaxPossibleYear = maxPossibleYear, MinPossibleYear = minPossibleYear };
    }
    /// <summary>
    /// For Serialization ONLY; coding use the other without dialog Argument
    /// </summary>
    public static DocName None(IMessageDialogService dialog) => new(string.Empty, dialog, false, string.Empty);
    /// <summary>
    /// Null Obj Pattern
    /// </summary>
    public static DocName None() => new();
    #endregion Constructors and Destructor    
​
        #region Public Methods
        #region Common 
        /// <summary>
        /// Only works if there is no specific element at all
        /// </summary>
        /// <param name="whichElementItIs"></param>
        /// <param name="elemValue"></param>
        /// <param name="docNamePart"></param>
        /// <param name="position"></param>
        /// <returns></returns>
        public bool CreateElement(WhichElementItIs whichElementItIs, string elemValue, DocNamePart docNamePart, ElementRelativePosition position)
        {
            //if (OriginalNameCannotBeRehydrated) 
            //    return false;
            if (ElementExists(whichElementItIs)) return false;
            //get in which DocNamePart docNamePart element is
            
            var connector = position == ElementRelativePosition.First ? string.Empty : " " ;
            switch (docNamePart)
            {
                case DocNamePart.First:
                    FirstPartName.Value.CreateElement(whichElementItIs, elemValue, position, connector);
                    break;
                case DocNamePart.Middle:
                    MiddlePartName.Value.CreateElement(whichElementItIs, elemValue, position, connector);
                    break;
                case DocNamePart.Last:
                    LastPartName.Value.CreateElement(whichElementItIs, elemValue, position, connector);
                    break;
                case DocNamePart.NoPart:
                    break;
                case DocNamePart.Extension:
                    break;
            }
            return ElementExists(whichElementItIs);
        }
​
        internal bool UpdateElementAndConnectorBefore(WhichElementItIs whichElementItIs, string elemValue
            , string connectorBefore = " ")
        {
            //if (OriginalNameCannotBeRehydrated)
            //    return false;
            if (!ElementExists(whichElementItIs)) return false;
            DocNamePart docPart;
            if (FirstPartName.Value.ElementExists(whichElementItIs))
                docPart = DocNamePart.First;
            else if (MiddlePartName.IsSuccess && MiddlePartName.Value.ElementExists(whichElementItIs))
                docPart = DocNamePart.Middle;
            else if (LastPartName.IsSuccess && LastPartName.Value.ElementExists(whichElementItIs))
                docPart = DocNamePart.Last;
            else
                return false;
            switch (docPart)
            {
                case DocNamePart.First:
                    FirstPartName.Value.UpdateElementAndConnectorBefore(whichElementItIs, elemValue, connectorBefore);
                    break;
                case DocNamePart.Middle:
                    MiddlePartName.Value.UpdateElementAndConnectorBefore(whichElementItIs, elemValue, connectorBefore);
                    break;
                case DocNamePart.Last:
                    LastPartName.Value.UpdateElementAndConnectorBefore(whichElementItIs, elemValue, connectorBefore);
                    break;
                case DocNamePart.NoPart:
                    break;
                case DocNamePart.Extension:
                    break;
            }
            return ElementExists(whichElementItIs);
        }
        public bool DeleteElement(WhichElementItIs whichElementItIs)//, string connectorBeforeOtherIfNeeded = " ")
        {
​
            //if (OriginalNameCannotBeRehydrated)
            //    return false; 
            if (!ElementExists(whichElementItIs)) return false;
            DocNamePart docPart;
            if (FirstPartName.Value.ElementExists(whichElementItIs))
                docPart = DocNamePart.First;
            else if (MiddlePartName.IsSuccess && MiddlePartName.Value.ElementExists(whichElementItIs))
                docPart = DocNamePart.Middle;
            else if (LastPartName.IsSuccess && LastPartName.Value.ElementExists(whichElementItIs))
                docPart = DocNamePart.Last;
            else
                return false;
            switch (docPart)
            {
                case DocNamePart.First:
                    FirstPartName.Value.DeleteElementAndAdjustConnectorOfOtherAfterIfNeeded(whichElementItIs);//, connectorBeforeOtherIfNeeded);
                    break;
                case DocNamePart.Middle:
                    MiddlePartName.Value.DeleteElementAndAdjustConnectorOfOtherAfterIfNeeded(whichElementItIs);//, connectorBeforeOtherIfNeeded);
                    break;
                case DocNamePart.Last:
                    LastPartName.Value.DeleteElementAndAdjustConnectorOfOtherAfterIfNeeded(whichElementItIs);
                    break;
                case DocNamePart.NoPart:
                    break;
                case DocNamePart.Extension:
                    break;
            }
            return !ElementExists(whichElementItIs);
        }
        #endregion Common
​
        #region Version
        public VersionInSentence GetVersionInSentence()
        {
            if (!HasVersionInSentence) return VersionInSentence.NullVersion;
            if (FirstPartName.Value.VersionInPart.HasVersion)
                return FirstPartName.Value.VersionInPart;
            if (MiddlePartName.IsSuccess && MiddlePartName.Value.VersionInPart.HasVersion)
                return MiddlePartName.Value.VersionInPart;
            if (LastPartName.IsSuccess && LastPartName.Value.VersionInPart.HasVersion)
                return LastPartName.Value.VersionInPart;
            return VersionInSentence.NullVersion;
        }
        public string GetVersionPrefixInSentence() => GetVersionInSentence().VersionPrefix;
        public int? GetVersionNumberInSentence() => GetVersionInSentence().VersionNumber;
​
        public bool UpdateVersion(int version, bool withPrefix, string whichPrefix = "v", string connectorBefore = " ")
        {
            if (!HasVersionInSentence) return false;
            var newVersion = (withPrefix ? whichPrefix : string.Empty) +  (version + GetVersionNumberInSentence()).ToString();
            return UpdateElementAndConnectorBefore(WhichElementItIs.WhicheverVersion, newVersion, connectorBefore);
        }
        public bool HasVersionInSentence => FirstPartName.Value.VersionInPart.HasVersion ||
                                            (MiddlePartName.IsSuccess && MiddlePartName.Value.VersionInPart.HasVersion) ||
                                            (LastPartName.IsSuccess && LastPartName.Value.VersionInPart.HasVersion);
        public bool HasVersionInSentenceWithPrefix => FirstPartName.Value.VersionInPart.HasVersionWithPrefix ||
                                                      (MiddlePartName.IsSuccess && MiddlePartName.Value.VersionInPart
                                                          .HasVersionWithPrefix) || (LastPartName.IsSuccess &&
                                                          LastPartName.Value.VersionInPart.HasVersionWithPrefix);
        public bool HasVersionInSentenceNumberOnly => FirstPartName.Value.VersionInPart.HasVersionNumberOnly ||
                                                      (MiddlePartName.IsSuccess && MiddlePartName.Value.VersionInPart
                                                          .HasVersionNumberOnly) || (LastPartName.IsSuccess &&
                                                          LastPartName.Value.VersionInPart.HasVersionNumberOnly);
​
        #endregion Version
        #region GUID
        public InNameGUID GetGUID()
        {
            if (!HasGUID) return InNameGUID.NullGUID;
            if (FirstPartName.Value.GUIDInPart.HasGUID)
                return FirstPartName.Value.GUIDInPart;
            if (MiddlePartName.IsSuccess && MiddlePartName.Value.GUIDInPart.HasGUID)
                return MiddlePartName.Value.GUIDInPart;
            if (LastPartName.IsSuccess && LastPartName.Value.GUIDInPart.HasGUID)
                return LastPartName.Value.GUIDInPart;
            return InNameGUID.NullGUID;
        }
        public bool HasGUID => FirstPartName.Value.GUIDInPart.HasGUID ||
                               (MiddlePartName.IsSuccess && MiddlePartName.Value.GUIDInPart.HasGUID) ||
                               (LastPartName.IsSuccess && LastPartName.Value.GUIDInPart.HasGUID); 
        #endregion GUID
        #region Date
        public DateInSentence GetDateInSentence()
        {
            if (!HasDateInSentence) return DateInSentence.NullDate;
            if (FirstPartName.Value.DateInPart.HasDate)
                return FirstPartName.Value.DateInPart;
            if (MiddlePartName.IsSuccess && MiddlePartName.Value.DateInPart.HasDate)
                return MiddlePartName.Value.DateInPart;
            if (LastPartName.IsSuccess && LastPartName.Value.DateInPart.HasDate)
                return LastPartName.Value.DateInPart;
            return DateInSentence.NullDate;
        }
        public DateTime GetDateTime()
        {
            return !HasDateInSentence ? DateTime.MinValue : GetDateInSentence().DateAndTime;
        }
        /// <summary>
        /// field that merge Date and, if date is null, the Last part of interval, unless the interval == IntervalType.TemporalClue
        /// But if it is IntervalType.TemporalClue it may not provide useful "order" information like in "Atestado de afastamento do trabalho dias por 100.pdf"
        /// Actually, Date is missing from FileName, but it is client's fault
        /// </summary>
        /// <returns></returns>
        public DateTime GetDateTimeOrLastPartOfIntervalForOrderDoc()
        {
            if (HasDateInSentence)
                return GetDateInSentence().DateAndTime;
            return HasIntervalInSentence 
                ? (GetIntervalInSentence().IntervalType == IntervalType.TemporalClue ? GetIntervalInSentence().DateBegin.DateAndTime : GetIntervalInSentence().DateEnd.DateAndTime) 
                : DateTime.MinValue;
        }
​
        public bool HasDateInSentence => FirstPartName.Value.DateInPart.HasDate ||
                                         (MiddlePartName.IsSuccess && MiddlePartName.Value.DateInPart.HasDate) ||
                                         (LastPartName.IsSuccess && LastPartName.Value.DateInPart.HasDate);
        public bool UpdateExistingDate(string date, string connectorBefore = "") 
            => UpdateElementAndConnectorBefore(WhichElementItIs.FileNameDate, date, connectorBefore);
​
        public bool InsertDate(string date, DocNamePart docNamePart, ElementRelativePosition position)
        {
            if (!TryCreateDate(date, out var newDate)) return false;
            if (docNamePart == DocNamePart.First)
            {
                FirstPartName.Value.AddDateInSentence(newDate, position);
                return true;
            }
​
            if (MiddlePartName.IsSuccess && docNamePart == DocNamePart.Middle)
            {
                MiddlePartName.Value.AddDateInSentence(newDate, position);
                return true;
            }
​
            if (LastPartName.IsSuccess && docNamePart == DocNamePart.Last)
            {
                LastPartName.Value.AddDateInSentence(newDate, position);
                return true;
            }
            return false;
        }
​
    private bool TryCreateDate(string date, out DateInSentence newDate)
    {
        newDate = DateInSentence.NullDate;
        if (string.IsNullOrEmpty(date)) return false;
        newDate = DateInSentence.CreateInstance(date, CultureInfoName, null);
        return !newDate.ElementValue.IsFailure;
    }
​
    #endregion Date
    #region Interval
    public IntervalInSentence GetIntervalInSentence()
    {
        if (!HasIntervalInSentence) return IntervalInSentence.Null;
        if (FirstPartName.Value.IntervalInPart.HasInterval)
            return FirstPartName.Value.IntervalInPart;
        if (MiddlePartName.IsSuccess && MiddlePartName.Value.IntervalInPart.HasInterval)
            return MiddlePartName.Value.IntervalInPart;
        if (LastPartName.IsSuccess && LastPartName.Value.IntervalInPart.HasInterval)
            return LastPartName.Value.IntervalInPart;
        return IntervalInSentence.Null;
    }
    public bool HasIntervalInSentence => FirstPartName.Value.IntervalInPart.HasInterval ||
                                         (MiddlePartName.IsSuccess && MiddlePartName.Value.IntervalInPart.HasInterval) ||
                                         (LastPartName.IsSuccess && LastPartName.Value.IntervalInPart.HasInterval);
    #endregion Interval
    #region MedicineAndDosage
    public MedicineAndDosageInSentence GetDrugAndDoseInSentence()
    {
        if (!HasDrugAndDoseInSentence) return MedicineAndDosageInSentence.NullMedicine;
        if (FirstPartName.Value.MedicinesAndDosesInPart.HasDrugAndDose)
            return FirstPartName.Value.MedicinesAndDosesInPart;
        if (MiddlePartName.IsSuccess && MiddlePartName.Value.MedicinesAndDosesInPart.HasDrugAndDose)
            return MiddlePartName.Value.MedicinesAndDosesInPart;
        if (LastPartName.IsSuccess && LastPartName.Value.MedicinesAndDosesInPart.HasDrugAndDose)
            return LastPartName.Value.MedicinesAndDosesInPart;
        return MedicineAndDosageInSentence.NullMedicine;
    }
    public bool HasDrugAndDoseInSentence => FirstPartName.Value.MedicinesAndDosesInPart.HasDrugAndDose ||
                                            (MiddlePartName.IsSuccess && MiddlePartName.Value.MedicinesAndDosesInPart.HasDrugAndDose) ||
                                            (LastPartName.IsSuccess && LastPartName.Value.MedicinesAndDosesInPart.HasDrugAndDose);
    #endregion MedicineAndDosage
    public DocName TurnIntoGeneric()
    {
        FirstPartName = Result.Success(NamePart.DefinePart(GenericPrefix, DocNamePart.First, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
        return new DocName(FullName, _dialog, _raiseEvents, CultureInfoName) { MaxPossibleYear = this.MaxPossibleYear };
    }
    public DocName PromoteIntoPatientDoc(string fullName)
    {
        FirstPartName = Result.Success(NamePart.DefinePart(fullName, DocNamePart.First, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
        return new DocName(FullName, _dialog, _raiseEvents, CultureInfoName) { MaxPossibleYear = this.MaxPossibleYear };
    }
    /// <summary>
    /// In happy path it returns name from FirstPartName or or failure if no associated name
    /// In an edge case, where
    ///     Doc has one part only
    ///         AND
    ///     there is a patient name in FirstPartOnly
    /// the name will be set by _patientNameFromDocType7
    /// </summary>
    /// <returns></returns>
    public Result<string> GetNameOfPatientFromDoc()
    {
        if (IsGeneric)
        {
            return Result.Failure<string>("Doc has no patient associated; it is generic");
        }
        return FileNameHasOnlyOnePart
            ? DecideHowToReturnPatientNameIfFileNameHasOnlyOnePart()
            : Result.Success(FirstPartName.Value.PartText);
    }
​
    /// <summary>
    /// Use only to correct the error comprised of:
    /// 1) Doc has one part only
    /// 2) there is a patient name in this FirstPartOnly
    /// </summary>
    /// <param name="patientName"></param>
    /// <exception cref="InvalidOperationException"></exception>
    public void SetNameOfPatientFromDoc(string patientName)
    {
        if (IsGeneric)
            throw new InvalidOperationException(
                "Cannot use this method to turn Doc in Non-Generic; use PromoteIntoPatientDoc instead.");
        if (!FileNameHasOnlyOnePart)
            throw new InvalidOperationException(
                "Cannot use this method to rename patient in FirstPart; it has to be done in DocType or upper");
        _patientNameFromDocType = patientName;
    }
​
    #endregion Public Methods 
​
    #region Public Fields 
    public string CultureInfoName { get; private set; }
    public bool IsGeneric => FirstPartName.IsSuccess && FirstPartName.Value.PartText == GenericPrefix;
    public string GenericPrefix { get; set; } = "x";
    public string Delimiter { get; set; } = "-";
    public List<(string delimiter, int positionAt, DocNamePart whichPart)> WrongDelimiter { get; private set; } = new();
    public int MaxPossibleYear { get; private set; } = 2025;
    public int MinPossibleYear { get; private set; } = 1990;
    /// <summary>
    /// if WrongDelimiter.Any() || OriginalNumberOfParts > _maxNumOfParts
    /// </summary>
    public bool OriginalNameCannotBeRehydrated => WrongDelimiter.Any() || OriginalNumberOfParts > _maxNumOfParts || !OriginalNameBeforeTreat.Equals(FullNameWithExtension);
​
    public bool OriginalNameCanOnlyBeRehydratedIfPutEnDashHyphensBack()
    {
        if (!WrongDelimiter.Any()) return false;
        var stateBefore = RehydrateWithOriginalEnDashHyphen;
        RehydrateWithOriginalEnDashHyphen = true;
        var sameName = OriginalNameBeforeTreat.Equals(FullNameWithExtension);
        RehydrateWithOriginalEnDashHyphen = stateBefore;
        return sameName;
​
    }
    private readonly string[] _wrongDelimiters = { "˗", "–" };
    // public (string delimiter, int positionAt) OldDelimiter2 { get; private set; } = ("", -1);
    public string FakeDelimiter { get; set; } = "<>";
    //public NamePart NamePart  { get; private set; } = new();
    public Result<NamePart> FirstPartName { get; private set; }
    public Result<string> FirstPartNameOriginal { get; private set; }
    public Result<NamePart> MiddlePartName { get; private set; }
    public Result<string> MiddlePartNameOriginal { get; private set; }
​
    public int PositionOfMiddlePart { get; private set; }
    public Result<NamePart> LastPartName { get; private set; }
    public Result<string> LastPartNameOriginal { get; private set; }
    public int PositionOfLastPart { get; private set; }
​
    [JsonIgnore]
    public bool? VersionIsBeforeDate
    {
        get
        {
            if (!HasDateInSentence || !HasVersionInSentence) return null;
            if (FirstPartName.Value.CheckIfHasBothVersionAndDate())
                return FirstPartName.Value.CheckAtPartElementIfVersionIsFirst();
            if (MiddlePartName.IsSuccess && MiddlePartName.Value.CheckIfHasBothVersionAndDate())
                return MiddlePartName.Value.CheckAtPartElementIfVersionIsFirst();
            if (LastPartName.IsSuccess && LastPartName.Value.CheckIfHasBothVersionAndDate())
                return LastPartName.Value.CheckIfHasBothVersionAndDate();
            return null;
        }
    }
​
    public string Extension { get; private set; }
    public string ExtensionWithDot => "." + this.Extension;
    //https://stackoverflow.com/questions/73490836/how-can-you-use-a-character-comparison-against-a-dash-hyphen-character-in-powers
    public bool RehydrateWithOriginalEnDashHyphen { get; set; } = false;
    public string FullName => ConcatenateNameIncludingSimplePart().TrimEnd();
    public string FullNameWithExtension => ConcatenateNameIncludingSimplePart().TrimEnd() + "." + Extension;
    /// <summary>
    /// It has all the Original wrong delimiters, if any 
    /// </summary>
    public string OriginalNameBeforeTreat { get; private set; }
    public string OriginalNameBeforeTreatWithoutExtension { get; private set; }
    public string OriginalNameAfterEnsureLegalNumberOfPartsWithoutExtension { get; private set; }
    public bool NeededFakeDelimiter => WhichFakeDelimiter.Any();
    public List<(string delimiter, int positionAt)> WhichFakeDelimiter { get; private set; } = new();
    private InNameGUID PartHasGUID => GetGUID();
    public override string ToString()
    {
        return
            @$"FirstPartName: {FirstPartName}
                    MiddlePartName: {(MiddlePartName.IsSuccess ? MiddlePartName.Value : MiddlePartName.Error)}
                    MiddlePartNameOriginal: {(MiddlePartNameOriginal.IsSuccess ? MiddlePartNameOriginal.Value : MiddlePartNameOriginal.Error)}
                    LastPartName: {(LastPartName.IsSuccess ? LastPartName.Value : LastPartName.Error)}
                    LastPartNameOriginal: {(LastPartNameOriginal.IsSuccess ? LastPartNameOriginal.Value : LastPartNameOriginal.Error)}
                    FileVersion: {(HasVersionInSentence ? GetVersionInSentence().Version : "No file version")}
                    FileDate: {(HasDateInSentence ? GetDateInSentence().DateText : "No file date")}
                    FileDateInterval: {(HasIntervalInSentence ? GetIntervalInSentence().ElementValue.Value : "No file interval")}
                    MedicinesAndDoses: {(HasDrugAndDoseInSentence ? GetDrugAndDoseInSentence().ElementValue.Value : "No drug and dose in this file")}
                        PartHasGUID?        {PartHasGUID != null && !PartHasGUID.NoGUID}
                        GUID:               {(PartHasGUID != null ? PartHasGUID.GUID : "NO")}
                            ConnectorBeforeGUID: {(PartHasGUID != null && !PartHasGUID.NoGUID
                            ? PartHasGUID.ConnectorBefore : "NO")}          
                        HasInterval?        {HasIntervalInSentence}
                            ConnectorBeforeInterval: {(!GetIntervalInSentence().ElementValue.IsSuccess
                            ? "NO" : (GetIntervalInSentence().ConnectorBefore == " " ? "one empty space" : GetIntervalInSentence().ConnectorBefore))}       
                        HasDate?            {HasDateInSentence}
                            ConnectorBeforeDate: {(!GetDateInSentence().ElementValue.IsSuccess
                            ? "NO" : (GetDateInSentence().ConnectorBefore == " " ? "one empty space" : GetDateInSentence().ConnectorBefore))}
                        HasVersion?         {HasVersionInSentence}
                        VersionNumberOnly?  {HasVersionInSentenceNumberOnly}
                        VersionWithPrefix?  {HasVersionInSentenceWithPrefix}                        
                            ConnectorBeforeVersion: {(!GetVersionInSentence().ElementValue.IsSuccess
                            ? "NO" : (GetVersionInSentence().ConnectorBefore == " " ? "one empty space" : GetVersionInSentence().ConnectorBefore))}
                ";
    }
    #endregion Public Fields 
​
    #region Private Methods
    private bool ElementExists(WhichElementItIs whichElementItIs)
    {
        switch (whichElementItIs)
        {
            case WhichElementItIs.VersionWithPrefix when HasVersionInSentence:
            case WhichElementItIs.VersionNumberOnly when HasVersionInSentence:
            case WhichElementItIs.WhicheverVersion when HasVersionInSentence:
                return true;
            case WhichElementItIs.DrugNameDose when HasDrugAndDoseInSentence:
                return true;
            case WhichElementItIs.FileNameDate when HasDateInSentence:
                return true;
            case WhichElementItIs.FileNameInterval when HasIntervalInSentence:
                return true;
            case WhichElementItIs.GUID when HasGUID:
                return true;
            case WhichElementItIs.DoesNotExist:
                break;
        }
        return false;
    }
    private string FixWrongDelimiters(string originalNameBeforeTreat)
    {
        for (var i = 0; i < _wrongDelimiters.Count(); i++)
        {
            if (!originalNameBeforeTreat.Contains(_wrongDelimiters[i])) continue;
            var wrong = _wrongDelimiters[i];
            foreach (var position in originalNameBeforeTreat.AllIndexesOf(wrong))
            {
                WrongDelimiter.Add((wrong, position, i == 0 ? DocNamePart.Middle : DocNamePart.Last));
                // above is wrong; but I do not know number of parts here; so, I have to fix it after...
            }
            originalNameBeforeTreat = originalNameBeforeTreat.Replace(wrong, "-");
        }
        return originalNameBeforeTreat;
    }
    private Result<string> DecideHowToReturnPatientNameIfFileNameHasOnlyOnePart()
    {
        return _patientNameFromDocType != NoNameFromDocType
            ? Result.Success(_patientNameFromDocType)
            : Result.Failure<string>("Doc has no patient associated; it has only one part");
    }
​
    private void GetParts(string fullNameWithExtension)
    {
        fullNameWithExtension = FixWrongDelimiters(fullNameWithExtension);
        var input = fullNameWithExtension;
        (OriginalNameBeforeTreatWithoutExtension, Extension) = DivideDocNameFromExtension(input);
        List<(string delimiter, int positionAt)> temp = new();
        (var matches, OriginalNameAfterEnsureLegalNumberOfPartsWithoutExtension) = EnsureLegalNumberOfParts(OriginalNameBeforeTreatWithoutExtension.Trim(), ref temp);
        WhichFakeDelimiter = temp;
        if (matches.Count == 0) return;
        var matchesList =
            (from Match itemMatch in matches
             where !string.IsNullOrEmpty(itemMatch.Value)
             select itemMatch.Value).ToList();
        if (!matchesList.Any()) return;
        FirstPartName = Result.Success(NamePart.DefinePart(matchesList[0].Trim(), DocNamePart.First, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
        FirstPartNameOriginal = matchesList[0].Trim();
        OriginalNumberOfParts = matchesList.Count;
        NumberOfParts = OriginalNumberOfParts;
        switch (matchesList.Count)
        {
            case 3:
                var i = 1;
                MiddlePartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(matchesList[i].Trim()));
                MiddlePartName = Result.Success(NamePart.DefinePart(matchesList[i].Trim(), DocNamePart.Middle, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
                i = 2;
                LastPartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(matchesList[i].Trim()));
                LastPartName = Result.Success(NamePart.DefinePart(matchesList[i].Trim(), DocNamePart.Last, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
                break;
            case 2:
                MiddlePartNameOriginal = Result.Failure<string>("No middle part");
                MiddlePartName = Result.Failure<NamePart>("No middle part");
                i = 1;
                LastPartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(matchesList[i].Trim()));
                LastPartName = Result.Success(NamePart.DefinePart(matchesList[i].Trim(), DocNamePart.Last, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
                break;
            case 1:
                MiddlePartNameOriginal = Result.Failure<string>("No middle part");
                MiddlePartName = Result.Failure<NamePart>("No middle part");
                LastPartNameOriginal = Result.Failure<string>("No last part");
                LastPartName = Result.Failure<NamePart>("No last part");
                break;
            default:
                //if (_raiseEvents)
                //{
                //EventAggregator.Instance.Publish(
                //   new DocNameWithIllegalNumberOfPartsMessage(OriginalNameBeforeTreat, matches.Count));
                //}
                var joinMiddleParts = string.Empty;
                for (var j = 1; j < matchesList.Count - 1; j++)
                {
                    joinMiddleParts += matchesList[j].Trim() + (j < matchesList.Count ? " " : string.Empty);
                }
                NumberOfParts = _maxNumOfParts;
                MiddlePartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(joinMiddleParts.Trim()));
                MiddlePartName = Result.Success(NamePart.DefinePart(joinMiddleParts.Trim(), DocNamePart.Middle, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
                LastPartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(matchesList[matchesList.Count - 1].Trim()));
                LastPartName = Result.Success(NamePart.DefinePart(matchesList[matchesList.Count - 1].Trim(), DocNamePart.Last, CultureInfoName, Delimiter, FakeDelimiter, MaxPossibleYear, MinPossibleYear));
                break;
        }
        if (MiddlePartNameOriginal.IsSuccess)
            PositionOfMiddlePart = OriginalNameAfterEnsureLegalNumberOfPartsWithoutExtension.IndexOf(MiddlePartNameOriginal.Value, StringComparison.Ordinal);
        if (LastPartNameOriginal.IsSuccess)
            PositionOfLastPart = OriginalNameAfterEnsureLegalNumberOfPartsWithoutExtension.IndexOf(LastPartNameOriginal.Value, StringComparison.Ordinal);
        CorrectWrongDelimitersAfterKnowHowManyPartsAre();
    }
​
    private void CorrectWrongDelimitersAfterKnowHowManyPartsAre()
    {
        if (!WrongDelimiter.Any()) return;
        switch (NumberOfParts)
        {
            case 1:
                for (int i = 0; i < WrongDelimiter.Count; i++)
                {
                    WrongDelimiter[i] = (WrongDelimiter[i].delimiter, WrongDelimiter[i].positionAt, DocNamePart.First);
                    // Beware of this case: 1 part, but wrong delimiter is in the middle of the name; and maybe there are more then one wrong delimiter
                    // I'm substituting ok, but not rehydrating Ok; should be by positionAt, not implemented yet
                }
                break;
            case 2:
                {
                    if (WrongDelimiter.Any(x => x.whichPart == DocNamePart.Middle))
                    {
                        WrongDelimiter[0] = (WrongDelimiter[0].delimiter, WrongDelimiter[0].positionAt, DocNamePart.Last);
                    }
                    break;
                }
            case 3:
                {
                    var numSpacesThatWhereTrimmedFromOriginalNameToLastPart = 3;
                    var numSpacesThatWhereTrimmedFromOriginalNameToMiddlePart = 2;
                    for (int i = 0; i < WrongDelimiter.Count; i++)
                    {
                        if (WrongDelimiter[i].positionAt >= PositionOfMiddlePart - numSpacesThatWhereTrimmedFromOriginalNameToMiddlePart && WrongDelimiter[i].positionAt < PositionOfLastPart - numSpacesThatWhereTrimmedFromOriginalNameToLastPart)
                            WrongDelimiter[i] = (WrongDelimiter[i].delimiter, WrongDelimiter[i].positionAt, DocNamePart.Middle);
                        else if (WrongDelimiter[i].positionAt >= PositionOfLastPart - numSpacesThatWhereTrimmedFromOriginalNameToLastPart)
                            WrongDelimiter[i] = (WrongDelimiter[i].delimiter, WrongDelimiter[i].positionAt, DocNamePart.Last);
                    }
                    break;
                }
        }
    }
​
    private static (string name, string extension) DivideDocNameFromExtension(string input)
    {
        var rgx = DocNameHelper.ForGrabNameAndExtension.Value;
        var match = rgx.Match(input);
        if (match.Success) return (match.Groups["fullname"].Value, match.Groups["extension"].Value);
        return (string.Empty, string.Empty);
    }
    private bool FileNameHasThreeParts => LastPartName.IsSuccess && MiddlePartName.IsSuccess;
    private bool FileNameHasTwoParts => LastPartName.IsSuccess && MiddlePartName.IsFailure;
    private bool FileNameHasOnlyOnePart => LastPartName.IsFailure && MiddlePartName.IsFailure;
​
    internal int OriginalNumberOfParts { get; private set; }
    internal int NumberOfParts { get; private set; }
    private string GetMiddlePartOfFileName() =>
        LastPartName.IsFailure ? FirstPartName.Value.PartText : LastPartName.Value.PartText;
    private string GetLastPartOfFileName() =>
        LastPartName.IsFailure ? FirstPartName.Value.PartText : LastPartName.Value.PartText;
    private string IfNeededReplaceFakeDelimiter(List<string> matchesList, int i)
    {
        return NeededFakeDelimiter
            ? matchesList[i].Trim().Replace(FakeDelimiter, Delimiter)
            : matchesList[i].Trim();
    }
    private string IfNeededReplaceFakeDelimiter(string partToReturnToOriginal)
    {
        return NeededFakeDelimiter
            ? partToReturnToOriginal.Replace(FakeDelimiter, Delimiter).Trim()
            : partToReturnToOriginal.Trim();
    }
    private static (MatchCollection matches, string treatedName) EnsureLegalNumberOfParts(string nameBeforeTreat, ref List<(string delimiter, int positionAt)> whichFakeDelimiter)
    {
        var rgxFakeDelimiter = DocNameHelper.ForGrabFakeDelimiterWithoutAnySpaceAround.Value;
        var treatedName = nameBeforeTreat;
        // NeededFakeDelimiter = rgxFakeDelimiter.Matches(treatedName).Count > 0;
        foreach (Match match in rgxFakeDelimiter.Matches(treatedName))
        {
            whichFakeDelimiter.Add((match.Value, match.Index));
        }
        while (rgxFakeDelimiter.Matches(treatedName).Count > 0)
        {
            treatedName = rgxFakeDelimiter.Replace(treatedName, (string)TemporarySubstitutionForFakeDelimiter);
        }
        var rgx = DocNameHelper.ForGrabPartsOfName.Value;
        var matches = rgx.Matches(treatedName);
        return (matches, treatedName);
    }
    private static void ShowMatches(Regex r, Match m)
    {
        var names = r.GetGroupNames();
        Console.WriteLine("Named Groups:");
        foreach (var name in names)
        {
            var grp = m.Groups[name];
            if (!string.IsNullOrEmpty(grp.Value))
                Console.WriteLine($@" {name}: '{grp.Value}'");
        }
    }
​
    private string ConcatenateNameIncludingSimplePart()
    {
        return
            $"{GeneratePartOfNameIncludingSimplePartConcatenated(FirstPartName, DocNamePart.First)}"
            + $"{GeneratePartOfNameIncludingSimplePartConcatenated(MiddlePartName, DocNamePart.Middle)}"
            + $"{GeneratePartOfNameIncludingSimplePartConcatenated(LastPartName, DocNamePart.Last)}";
    }
    private string GeneratePartOfNameIncludingSimplePartConcatenated(Result<NamePart> part, DocNamePart whichPart)
    {
        string? name;
        if (whichPart == DocNamePart.First)
        {
            name = part.IsFailure
                ? string.Empty
                : @$"{GetCorrectEnDashHyphen(part.Value.GetPartNameElements)}";
            //: @$"{part.Value.GetConcatenatedPartNameElements(FakeDelimiter, Delimiter)}";
        }
        else
        {
            var delimiter = GrabChosenDelimiter(whichPart);
            name = part.IsFailure
                ? string.Empty
                : @$" {delimiter}{(string.IsNullOrEmpty(part.Value.GetPartNameElements) ? "" : " ")}{GetCorrectEnDashHyphen(part.Value.GetPartNameElements.Trim())}";
        }
        return name;//.RemoveUnnecessarySpaces();
    }
​
    private string GetCorrectEnDashHyphen(string partValue)
    {
        if (!RehydrateWithOriginalEnDashHyphen) return partValue;
        for (var i = 0; i < WrongDelimiter.Count; i++)
        {
            if (partValue.Contains(Delimiter))
            {
                var toReplace = partValue.IndexOf(Delimiter, StringComparison.CurrentCulture);
                // remove exactly the WrongDelimiter[i].delimiter at the position of toReplace and concatenate the correct delimiter
                partValue = partValue.SubstituteSubstringAtSpecificPositionForAnother(Delimiter, WrongDelimiter[i].delimiter, toReplace);
            }
        }
        return partValue;
    }
​
    private string GrabChosenDelimiter(DocNamePart whichPart)
    {
        if (!RehydrateWithOriginalEnDashHyphen) return Delimiter;
        foreach (var (wrongDelimiter, _, position) in WrongDelimiter)
        {
            if (position == whichPart) return wrongDelimiter;
        }
        return Delimiter;
    }
​
        #endregion Private Methods
​
        #region Overrides of ValueObject
​
        protected override IEnumerable<IComparable> GetEqualityComponents()
        {
            yield return OriginalNameBeforeTreat;
            yield return FullNameWithExtension;
        }
        #endregion Overrides of ValueObject
​
    }
//################################################################################### DocName End ##########################################################################################                          
//################################################################################### NamePart ##########################################################################################
public class NamePart : ValueObject//<DocName>
{
    private string _partText;
​
    #region Public Fields 
    public int MaxPossibleYear { get; set; }
    public int MinPossibleYear { get; set; }
    public string PartOriginalText { get; private set; }
    /// <summary>
    /// Original Text BUT with NO Elements
    /// </summary>
    public string PartText
    {
        get => _partText;
        private set => _partText = value;
    }
    public string GetOnlySimplePartNameElements => GetConcatenatedSimplePartNameElements(FakeDelimiter, FakeDelimiter);
    public string GetOnlySimplePartNameElementsOriginal => GetConcatenatedSimplePartNameElements(FakeDelimiter, Delimiter);
    public string GetPartNameElements => GetConcatenatedPartNameElements(FakeDelimiter, Delimiter);
    //TODO: Make this a list of SimpleText and use it instead of above; concatenate Part will be much easier
    public List<SimpleText> PartSimpleText { get; private set; } = new List<SimpleText>();
    public IntervalInSentence IntervalInPart { get; private set; }
    public DateInSentence DateInPart { get; private set; }
    public VersionInSentence VersionInPart { get; private set; }
    public InNameGUID GUIDInPart { get; private set; }
    public MedicineAndDosageInSentence MedicinesAndDosesInPart { get; private set; }
    public DocNamePart WhichPart { get; private set; }
    public string CultureInfoName { get; private set; }
    public bool HasVersion => HasVersionWithPrefix || HasVersionNumberOnly;
    public bool HasVersionWithPrefix => VersionInPart.HasVersionWithPrefix;
    public bool HasVersionNumberOnly => VersionInPart.HasVersionNumberOnly;
    public bool HasDate => DateInPart.HasDate;
    public bool HasInterval => IntervalInPart.HasInterval;
    public bool HasDrugAndDose => MedicinesAndDosesInPart.HasDrugAndDose;
    public bool HasGUID => GUIDInPart.HasGUID;
​
    public string Delimiter { get; private set; }
    public string FakeDelimiter { get; private set; }
​
    #endregion Public Fields 
​
​
    #region Public Methods
    public override string ToString()
    {
​
        return
            @$"PartOriginalText: {PartOriginalText}
        PartText: {PartText}
        GetOnlySimplePartNameElementsOriginal: {GetOnlySimplePartNameElementsOriginal}
        GetOnlySimplePartNameElements: {GetOnlySimplePartNameElements}
        GetPartNameElements: {GetPartNameElements}
        FileVersion: {(HasVersion ? VersionInPart.Version : "No file version")}
        FileDate: {(HasDate ? DateInPart.DateText + " (date mask has YYYY: " + DateInPart.DateMaskProvidesYYYY + " and it is " + (DateInPart.DateYearHasWildCard ? "" : "not ") + "with wildcard)" : "No file date")}
        FileDateInterval: {(HasInterval ? IntervalInPart.ElementValue.Value  + " (date begin mask has YYYY: " + IntervalInPart.DateBegin.DateMaskProvidesYYYY + ")" /*  + " (date end mask has YYYY: " + IntervalInPart.DateEnd.DateMaskProvideYYYY() + ")" */ : "No file interval")}
        MedicinesAndDoses: {(HasDrugAndDose ? MedicinesAndDosesInPart.ElementValue.Value : "No drug and dose in this file")}
        PartHasGUID?        {HasGUID && !GUIDInPart.NoGUID}
        GUID:               {(HasGUID ? GUIDInPart.GUID : "NO")}
        ConnectorBeforeGUID: {(HasGUID && !GUIDInPart.NoGUID
            ? GUIDInPart.ConnectorBefore : "NO")}           
        HasInterval?        {HasInterval}
        ConnectorBeforeInterval: {(!IntervalInPart.ElementValue.IsSuccess
            ? "NO" : (IntervalInPart.ConnectorBefore == " " ? "one empty space" : IntervalInPart.ConnectorBefore))}     
        HasDate?            {HasDate}
        ConnectorBeforeDate: {(!DateInPart.ElementValue.IsSuccess
            ? "NO" : (DateInPart.ConnectorBefore == " " ? "one empty space" : DateInPart.ConnectorBefore))}
        HasVersion?         {HasVersion}
        VersionNumberOnly?  {HasVersionNumberOnly}
        VersionWithPrefix?  {HasVersionWithPrefix}                      
        ConnectorBeforeVersion: {(!VersionInPart.ElementValue.IsSuccess
            ? "NO" : (VersionInPart.ConnectorBefore == " " ? "one empty space" : VersionInPart.ConnectorBefore))}
        ";
    }
    #endregion Public Methods
​
    #region Constructors and Destructor
    private NamePart()
    {
    }
​
    internal static NamePart DefinePart(string part, DocNamePart whichPart, string culture, string delimiter, string fakeDelimiter, int maxPossibleYear, int minPossibleYear)
    {
        if (string.IsNullOrEmpty(part))
            throw new ArgumentException("Value cannot be null or empty.", nameof(part));
        var instance = new NamePart
        {
            PartText = part,
            PartOriginalText = part,
            WhichPart = whichPart,
            CultureInfoName = culture,
            Delimiter = delimiter,
            FakeDelimiter = fakeDelimiter,
            MaxPossibleYear = maxPossibleYear,
            MinPossibleYear = minPossibleYear
        };
        instance.GetAllElementsFromPart();
        return instance;
    }
    /// <summary>
    /// For Serialization or Null Obj Pattern ONLY
    /// </summary>
    public static NamePart None() => new();
    #endregion Constructors and Destructor
​
    #region Private Methods
​
    #region Common
    private void GetAllElementsFromPart()
​
    {
        GUIDInPart = InNameGUID.CreateInstance(_partText, WhichPart);
        if (!GUIDInPart.NoGUID)
        {
            _partText = StripOfElementAndUpdateBaseElement(GUIDInPart, _partText, PartOriginalText);
        }
        MedicinesAndDosesInPart = MedicineAndDosageInSentence.CreateInstance(_partText);
        if (MedicinesAndDosesInPart != MedicineAndDosageInSentence.NullMedicine)
        {
            _partText = StripOfElementAndUpdateBaseElement(MedicinesAndDosesInPart, _partText, PartOriginalText);
        }
        var intervalInSentence = IntervalInSentence.CreateInstance(_partText, new CultureInfo(CultureInfoName), MaxPossibleYear, MinPossibleYear);
        //Below is the slowest place in the whole program, because of the DateTime.TryParseExact
        var dateInSentence =
            DateInSentence.CreateInstanceFromSentence(_partText, CultureInfoName, (GUIDInPart.StartIndex, GUIDInPart.EndOriginal), MaxPossibleYear, minPossibleYear: MinPossibleYear);
        TreatIntervalComparingItWithDate(ref intervalInSentence, ref dateInSentence, PartOriginalText);
        IntervalInPart = intervalInSentence;
        if (intervalInSentence.ElementValue.IsSuccess)
        {
            _partText = StripOfElementAndUpdateBaseElement(intervalInSentence, _partText, PartOriginalText);
            //After Strip of Interval from part, let's see if fileDate still exists:
            dateInSentence = DateInSentence.CreateInstanceFromSentence(_partText, CultureInfoName, (GUIDInPart.StartIndex, GUIDInPart.EndOriginal), MaxPossibleYear, minPossibleYear: MinPossibleYear);
        }
        if (dateInSentence.ElementValue.IsSuccess)
        {
            _partText = StripOfElementAndUpdateBaseElement(dateInSentence, _partText, PartOriginalText);
        }
        VersionInPart = VersionInSentence.CreateInstance(_partText);
        DateInPart = dateInSentence;
        if (VersionInPart.ElementValue.IsSuccess)
        {
            _partText = StripOfElementAndUpdateBaseElement(VersionInPart, _partText, PartOriginalText);
        }
        PartSimpleText = GetPartSimpleTextElements();
        _partText = _partText.RemoveUnnecessarySpaces();
    }
​
    private List<SimpleText> GetPartSimpleTextElements()
    {
        var draftList = new List<SimpleText>();
        var partWithoutElements = PartWithoutElements(PartOriginalText);
        //test by how much substrings of partWithoutElements is partOriginalToTest made of
        while (partWithoutElements.Length > 0)
        {
            for (var i = 0; i <= partWithoutElements.Length; i++)
            {
                var substring = partWithoutElements.Substring(0, i);
                var start = PartOriginalText.IndexOf(substring.Trim(), StringComparison.Ordinal);
                var end = start + substring.Length;
                if (PartOriginalText.Contains(substring))
                {
                    //draftList.Add(substring);
                    if (partWithoutElements.Equals(substring))
                    {
                        var connectorBefore = start == 0 ? string.Empty : PartOriginalText.Substring(start - 1, 1);
                        draftList.Add(SimpleText.CreateInstance(substring.TrimEnd(), start, connectorBefore));
                        partWithoutElements = partWithoutElements.Replace(substring, string.Empty).TrimEnd();
                        break;
                    }
                }
                else //if (start > -1)
                {
                    var connectorBefore = start <= 0 ? string.Empty : PartOriginalText.Substring(start - 1, 1);
                    if (start == -1)
                    {
                        substring = substring.TrimLastCharacter();
                        start = 0;
                    }
                    draftList.Add(SimpleText.CreateInstance(substring.TrimEnd(), start, connectorBefore));
                    partWithoutElements = partWithoutElements.Replace(substring, string.Empty).TrimEnd();
                    break;
                }
            }
        }
        return draftList;
    }
    private string PartWithoutElements(string partOriginalToTest)
    {
        foreach (var element in ListOfElements())
        {
            //calculate start index of element substring in name
​
            var elementValue = element.ElementValue.Value;
            var startIndex = partOriginalToTest.IndexOf(elementValue, StringComparison.Ordinal);
            if (startIndex == -1) continue;
            var endIndex = startIndex + elementValue.Length;
            if (startIndex == 0)
                //partOriginalToTest = partOriginalToTest.Replace(elementValue, string.Empty);
                partOriginalToTest = partOriginalToTest.Substring(endIndex);
            else
            {
                var partLength = partOriginalToTest.Length;
                var part1 = partOriginalToTest.Substring(0, startIndex - 1);
                var part2 = partOriginalToTest.Substring(endIndex);
                partOriginalToTest = part1 + part2;
            }
        }
        return partOriginalToTest;
    }
    private string StripOfElementAndUpdateBaseElement(BaseElement elem, string part, string partOriginal)
    {
        (part, var connector) = StripOffPartWithConnectorAndReturnIt(part, elem.ElementValue.Value);
        elem.ConnectorBefore = connector;
        elem.StartIndex = partOriginal.IndexOf(elem.ElementValue.Value, StringComparison.Ordinal);
        return part;
    }
    internal bool ElementExists(WhichElementItIs whichElementItIs)
    {
        switch (whichElementItIs)
        {
            case WhichElementItIs.VersionWithPrefix when HasVersion:
            case WhichElementItIs.VersionNumberOnly when HasVersion:
            case WhichElementItIs.WhicheverVersion when HasVersion:
                return true;
            case WhichElementItIs.DrugNameDose when HasDrugAndDose:
                return true;
            case WhichElementItIs.FileNameDate when HasDate:
                return true;
            case WhichElementItIs.FileNameInterval when HasInterval:
                return true;
            case WhichElementItIs.GUID when HasGUID:
                return true;
            case WhichElementItIs.DoesNotExist:
                break;
        }
        return false;
    }
​
    private static WhichElementItIs TypeOfElement(BaseElement elem)
    {
        return elem switch
        {
            //detect which type of this element is
            VersionInSentence => WhichElementItIs.WhicheverVersion,
            MedicineAndDosageInSentence => WhichElementItIs.DrugNameDose,
            DateInSentence => WhichElementItIs.FileNameDate,
            IntervalInSentence => WhichElementItIs.FileNameInterval,
            InNameGUID => WhichElementItIs.GUID,
            SimpleText => WhichElementItIs.SimplePart,
            _ => WhichElementItIs.DoesNotExist
        };
    }
    internal bool ElementIsFirst(WhichElementItIs whichElementItIs)
    {
        //detect if element is the first in the part
        var firstElement = ListOfElements().OrderBy(x => x.StartIndex).FirstOrDefault();
        if (firstElement == null) return false;
        return TypeOfElement(firstElement) == whichElementItIs;
    }
    /// <summary>
    /// I'm not calculating exactly Indexes here; just approximating them
    /// </summary>
    /// <param name="elem"></param>
    /// <param name="elementRelativePosition"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentOutOfRangeException"></exception>
    private int ReturnNewIndexToPositioningElementInSentence(BaseElement elem, ElementRelativePosition elementRelativePosition)
    {
        var allElements = ListOfElements();
        // get an ordered array with StartIndex of all elements
        var orderedElements = allElements.OrderBy(x => x.StartIndex).ToArray();
        // calculate the index as modal of the nearer indexes depending of the elementRelativePosition
        var sizeOfPartWithoutElem = PartWithoutElementLength();
        var index = -1;
        if (orderedElements.Length > 1)
        {
            index = elementRelativePosition switch
            {
                //Instead of that, I should positioned it after EndIndex of the previous element and dislodge the next by elem.Length
                ElementRelativePosition.Middle => (orderedElements.Max(x => x.StartIndex) -
                                                   orderedElements.Min(x => x.StartIndex)),
                ElementRelativePosition.First => 0,
                ElementRelativePosition.Last => orderedElements.Max(x => x.StartIndex) + 1,
                _ => throw new ArgumentOutOfRangeException(nameof(elementRelativePosition), elementRelativePosition,
                    null)
            };
        }
        else if (orderedElements.Length == 1)
        {
            index = elementRelativePosition switch
            {
                ElementRelativePosition.First => 0,
                //Instead of that, I should positioned it after EndIndex of the previous element and dislodge the next by elem.Length
                _ => orderedElements.FirstOrDefault().EndIndex + 1
            };
        }
        else if (orderedElements.Length == 0)
        {
            index = elementRelativePosition switch
            {
                ElementRelativePosition.First => 0,
                //Instead of that, I should positioned it after EndIndex of the previous element and dislodge the next by elem.Length
                _ => sizeOfPartWithoutElem
            };
        }
        return index;
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="whichElementItIs"></param>
    /// <param name="elemValue"></param>
    /// <param name="position"></param>
    /// <param name="connectorBefore">it only works if it not is an element in First position</param>
    /// <param name="connectorBeforeDisplacedExFirstElement"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentOutOfRangeException"></exception>
    internal bool CreateElement(WhichElementItIs whichElementItIs, string elemValue,
        ElementRelativePosition position, string connectorBefore = " ", string connectorBeforeDisplacedExFirstElement = " ")
    {
        if (string.IsNullOrEmpty(elemValue)) return false;
        //if element is to be create in first position, we should assure that it's connector is null and the connector of the element to be displaced should be inserted as space
        if (position == ElementRelativePosition.First)
        {
            connectorBefore = string.Empty;
            var firstElementThatWillBecomeSecond = ListOfElements().FirstOrDefault();
            if (firstElementThatWillBecomeSecond != null)
            {
                firstElementThatWillBecomeSecond.ConnectorBefore = connectorBeforeDisplacedExFirstElement;
            }
        }
        switch (whichElementItIs)
        {
            case WhichElementItIs.DoesNotExist:
                break;
            case WhichElementItIs.WhicheverVersion:
            case WhichElementItIs.VersionNumberOnly:
            case WhichElementItIs.VersionWithPrefix:
                CreateVersionInSentence(elemValue, position, connectorBefore);
                return HasVersion;
            case WhichElementItIs.FileNameDate:
                break;
            case WhichElementItIs.FileNameInterval:
                break;
            case WhichElementItIs.GUID:
                break;
            case WhichElementItIs.DrugNameDose:
                break;
            default:
                throw new ArgumentOutOfRangeException(nameof(whichElementItIs), whichElementItIs, null);
        }
        return false;
    }
    internal bool UpdateElementAndConnectorBefore(WhichElementItIs whichElementItIs, string elemValue, string connectorBefore = "")
    {
        if (string.IsNullOrEmpty(elemValue)) return false;
        switch (whichElementItIs)
        {
            case WhichElementItIs.DoesNotExist:
                break;
            case WhichElementItIs.WhicheverVersion:
            case WhichElementItIs.VersionNumberOnly:
            case WhichElementItIs.VersionWithPrefix:
                UpdateVersionInSentence(elemValue, connectorBefore);
                return HasVersion;
            case WhichElementItIs.FileNameDate:
                UpdateDateInSentence(elemValue, connectorBefore);
                break;
            case WhichElementItIs.FileNameInterval:
                break;
            case WhichElementItIs.GUID:
                break;
            case WhichElementItIs.DrugNameDose:
                break;
            default:
                throw new ArgumentOutOfRangeException(nameof(whichElementItIs), whichElementItIs, null);
        }
        return false;
    }
    internal bool DeleteElementAndAdjustConnectorOfOtherAfterIfNeeded(WhichElementItIs whichElementItIs)
    {
        if (!ElementExists(whichElementItIs)) return false;
        if (ElementIsFirst(whichElementItIs))
        {
            var secondElement = ListOfElements().OrderBy(x => x.StartIndex).Skip(1).FirstOrDefault();
            if (secondElement != null)
            {
                secondElement.ConnectorBefore = string.Empty;
            }
        }
        switch (whichElementItIs)
        {
            case WhichElementItIs.DoesNotExist:
                break;
            case WhichElementItIs.WhicheverVersion:
            case WhichElementItIs.VersionNumberOnly:
            case WhichElementItIs.VersionWithPrefix:
                DeleteVersionInSentence();
                return HasVersion;
            case WhichElementItIs.FileNameDate:
                DeleteDateInSentence();
                return HasDate;
            case WhichElementItIs.FileNameInterval:
                break;
            case WhichElementItIs.GUID:
                break;
            case WhichElementItIs.DrugNameDose:
                break;
            default:
                throw new ArgumentOutOfRangeException(nameof(whichElementItIs), whichElementItIs, null);
        }
        return false;
    }
​
    private int PartWithoutElementLength() => _partText.Length;
    private int ElementEndIndex(BaseElement baseElement) => baseElement.EndIndex;
    #region Decompose elements from Part
​
    private static (string partStripped, string connector) StripOffPartWithConnectorAndReturnIt(string partToBeStrippedOff, string partToStrip)
    {
        var connector = partToBeStrippedOff.GetNumberOfCharsJustBeforeSubstring(partToStrip, 1);
        partToBeStrippedOff = StripOffPart(partToBeStrippedOff, partToStrip, connector);
        return (partToBeStrippedOff, string.IsNullOrEmpty(connector) ? " " : connector);
    }
    private 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();
    }
    #endregion Decompose elements from Part
    
    #region Compose back Elements
    private IEnumerable<BaseElement> ListOfElements()
    {
        var elemToReturn = new List<BaseElement>();
        if (!GUIDInPart.NoGUID)
        {
            elemToReturn.Add(GUIDInPart);
        }
        if (DateInPart.ElementValue.IsSuccess)
        {
            elemToReturn.Add(DateInPart);
        }
        if (VersionInPart.ElementValue.IsSuccess)
        {
            elemToReturn.Add(VersionInPart);
        }
        if (IntervalInPart.ElementValue.IsSuccess)
        {
            elemToReturn.Add(IntervalInPart);
        }
        if (MedicinesAndDosesInPart.ElementValue.IsSuccess)
        {
            elemToReturn.Add(MedicinesAndDosesInPart);
        }
        return elemToReturn.OrderBy(x => x.StartIndex);
    }
​
    private IEnumerable<BaseElement> ListOfElementsIncludingSimpleParts()
    {
        var elemToReturn = ListOfElements().ToList();
        elemToReturn.AddRange(PartSimpleText);
        return elemToReturn.OrderBy(x => x.StartIndex);
    }
​
    private string GetConcatenatedPartNameElements(string fakeDelimiter, string delimiter)
    {
        var partText = new StringBuilder();
        foreach (var element in ListOfElementsIncludingSimpleParts())
        {
            partText.Append(element.ConnectorBefore);
            partText.Append(element.ElementValue.Value.Replace(fakeDelimiter, delimiter));
        }
        return Regex.Replace(partText.ToString(), @"\s{2,}", " ");
    }
​
    private string GetConcatenatedSimplePartNameElements(string fakeDelimiter, string delimiter)
    {
        var partText = new StringBuilder();
        foreach (var element in ListOfElementsIncludingSimpleParts().Where(e => e is SimpleText))
        {
            partText.Append(element.ConnectorBefore);
            partText.Append(element.ElementValue.Value.Replace(fakeDelimiter, delimiter));
        }
        return Regex.Replace(partText.ToString(), @"\s{2,}", " ");
    }
    #endregion Compose back Elements
​
    #endregion Common
​
​
    #region Version
    /// <summary>
    /// Use it after NamePart processed, like there in DocName  
    /// </summary>
    /// <returns></returns>
    internal bool CheckAtPartElementIfVersionIsFirst()
    {
        //By default, version always should be first, before date
        if (!HasVersion || !HasDate) return true;
        var whereVersion = _partText.IndexOf(VersionInPart.Version, StringComparison.CurrentCulture);
        var whereDate = _partText.IndexOf(DateInPart.DateText, StringComparison.CurrentCulture);
        return whereVersion < whereDate;
    }
​
    /// <summary>
    /// Only to Update; to delete Version, use Delete Version Method...
    /// If it fails, it will not corrupt the current version, rather it will maintaining it as it is
    /// </summary>
    /// <param name="newVersionValue"></param>
    /// <param name="connectorBefore"></param>
    internal bool UpdateVersionInSentence(string newVersionValue, string connectorBefore = "")
    {
        var newVersion = VersionInSentence.UpdateInstance(newVersionValue, VersionInPart, connectorBefore);
        if (newVersion == VersionInSentence.NullVersion) return false;
        VersionInPart = newVersion;
        return true;
    }
    internal void CreateVersionInSentence(string newVersionValue, ElementRelativePosition elementRelativePosition, string connectorBefore = " ")
    {
        if (string.IsNullOrEmpty(newVersionValue)) return;
        VersionInPart = VersionInSentence.CreateInstance(newVersionValue);
        VersionInPart.StartIndex =
            ReturnNewIndexToPositioningElementInSentence(VersionInPart, elementRelativePosition);
        VersionInPart.ConnectorBefore = connectorBefore;
    }
    internal void DeleteVersionInSentence()
    {
        VersionInPart = VersionInSentence.NullVersion;
    }
    #endregion Version
    internal bool CheckIfHasBothVersionAndDate() => HasVersion && HasDate;
​
    #region Interval and Date
    private void TreatIntervalComparingItWithDate(ref IntervalInSentence intervalInSentence,
        ref DateInSentence dateInSentence, string partOriginal)
    {
        if (dateInSentence == DateInSentence.NullDate) return;// intervalInSentence.Interval;
        if (intervalInSentence.ElementValue.IsFailure) return;// Result.Failure<string>("No interval date stamp in this file name");
        if (InvalidIntervalBecauseSupposedToBeComposedButHasOnlyOneDate(intervalInSentence, dateInSentence) 
            || InvalidIntervalBecauseSupposedToBeTemporalClueButDateInvalid(intervalInSentence, dateInSentence))
        {
            intervalInSentence = IntervalInSentence.Null;
            return ;//Result.Failure<string>("No interval date stamp in this file name");
        }
        if (InvalidDateBecauseItIsIdenticalToIntervalThatIsAllowedToHaveOnlyOneDate(intervalInSentence, dateInSentence))
        {
            dateInSentence = DateInSentence.NullDate;
        }
​
        if (!InvalidDateBecauseItIsCapturedInsideBeginOfInterval(intervalInSentence, dateInSentence)) return;
        if (CapturedElementsAreSuperposedInSamePlaceOfStringSoOneIsInvalid(intervalInSentence, dateInSentence, partOriginal))
        {
            dateInSentence = DateInSentence.NullDate;
        }
    }
​
private static bool CapturedElementsAreSuperposedInSamePlaceOfStringSoOneIsInvalid(BaseElement elem1, BaseElement elem2, string partOriginal)
{
    return partOriginal.IndexOf(elem1.ElementValue.Value, StringComparison.Ordinal)
           == partOriginal.IndexOf(elem2.ElementValue.Value, StringComparison.Ordinal);
}
​
private static bool InvalidDateBecauseItIsCapturedInsideBeginOfInterval(IntervalInSentence intervalInSentence, DateInSentence dateInSentence)
{
    return intervalInSentence.IntervalType == IntervalType.NormalRange && dateInSentence.DateText == intervalInSentence.DateEnd.DateText;
}
​
private static bool InvalidDateBecauseItIsIdenticalToIntervalThatIsAllowedToHaveOnlyOneDate(IntervalInSentence intervalInSentence, DateInSentence dateInSentence)
{
    return intervalInSentence.IntervalType == IntervalType.TemporalClue && dateInSentence.DateText == intervalInSentence.DateBegin.DateText;
}
​
private static bool InvalidIntervalBecauseSupposedToBeComposedButHasOnlyOneDate(IntervalInSentence intervalInSentence, DateInSentence dateInSentence)
{
    return intervalInSentence.IntervalType == IntervalType.NormalRange && dateInSentence.DateText == intervalInSentence.ElementValue.Value;
}
private static bool InvalidIntervalBecauseSupposedToBeTemporalClueButDateInvalid(IntervalInSentence intervalInSentence, DateInSentence dateInSentence)
{
    return intervalInSentence.IntervalType == IntervalType.TemporalClue
           && dateInSentence.DateText.Length > intervalInSentence.ElementValue.Value.Length;
}               //                 15.05.2021                                    em 15  
​
/// <summary>
/// Only to Update; to delete Date, use Delete Date Method...
/// </summary>
/// <param name="value"></param>
internal void UpdateDateInSentence(DateInSentence value)
{
    if (value == DateInSentence.NullDate) return;
    DateInPart = value;
}
internal bool UpdateDateInSentence(string value, string connectorBefore)
{
    var newDate = DateInSentence.UpdateInstance(value, DateInPart, connectorBefore);
    if (newDate == DateInSentence.NullDate) return false;
    DateInPart = newDate;
    return true;
}
internal void AddDateInSentence(DateInSentence value, ElementRelativePosition position, string connectorBefore = " ")
{
    if (value == DateInSentence.NullDate) return;
    value.StartIndex = ReturnNewIndexToPositioningElementInSentence(value, position);
    value.ConnectorBefore = connectorBefore;
    DateInPart = value;
}
internal void DeleteDateInSentence()
{
    DateInPart = DateInSentence.NullDate;
}
#endregion Interval and Date
​
#region GUID
​
public bool ThisPartHasGUID() => !GUIDInPart.NoGUID;
#endregion GUID
​
#endregion Private Methods
​
#region Overrides of ValueObject
protected override IEnumerable<IComparable> GetEqualityComponents()
{
    yield return PartText;
    yield return PartOriginalText;
    yield return GUIDInPart;
    yield return DateInPart;
    yield return VersionInPart;
    yield return IntervalInPart;
    yield return MedicinesAndDosesInPart;
}
#endregion Overrides of ValueObject
​
#region draft
/// <summary>
/// After strip GUID from part, let's see if it was removed from the beginning of the part;
/// if not, let's see if it was removed exactly from the end of the part;
/// if not, it means that the GUID was in the middle of the part, so let's modify PartSimpleText[0] to reflect this and add other part to second element of PartSimpleText
///  TODO: try to figure how to split the part in more than 2 parts, if necessary
/// </summary>
/// <param name="partOriginal"></param>
/// <param name="elem"></param>
private void AdjustPartSimpleText(string partOriginal, BaseElement elem)
{
    //string toHelpDecideIfElemSplitPart;
    if (elem.StartIndex == 0)
    {
        PartSimpleText[0] =
            SimpleText.CreateInstance(partOriginal.Substring(0, elem.StartIndex), 0, string.Empty);
        //toHelpDecideIfElemSplitPart = partOriginal.Substring(0, elem.StartIndex);
    }
    else if (elem.EndIndex == partOriginal.Length)
    {
        switch (PartSimpleText.Count)
        {
            case 1:
                PartSimpleText[0] =
                    SimpleText.CreateInstance(partOriginal.Substring(elem.EndIndex), 0, string.Empty);
                break;
            case 2 when elem.ElementValue.Value.Equals(PartSimpleText[1].ElementValue.Value):
                PartSimpleText.RemoveAt(1);
                break;
            case 2:
                PartSimpleText[1] =
                    SimpleText.CreateInstance(partOriginal.Substring(elem.EndIndex), 0, string.Empty);
                break;
        }
    }
    else
    {
        IncreaseSimplePartNumberBySplittingOneOfThem(partOriginal, elem);
    }
}
private void IncreaseSimplePartNumberBySplittingOneOfThem(string partOriginal, BaseElement elem)
{
    if (PartSimpleText.Count == 1)
    {
        //   PartSimpleText.Add(SimpleText.CreateInstance(string.Empty, 0, string.Empty));
        PartSimpleText[0] =
            SimpleText.CreateInstance(partOriginal.Substring(0, elem.StartIndex - 1), 0, string.Empty);
        var newDistalPart =
            SimpleText.CreateInstance(partOriginal.Substring(elem.EndIndex + 1), elem.EndIndex + 1, string.Empty);
        newDistalPart.ConnectorBefore = partOriginal.Substring(elem.EndIndex, 1);
        PartSimpleText.Add(newDistalPart);
    }
    else if (PartSimpleText.Count == 2)
    {
        //Detect in which SimplePart the elem.substring is
        var partWithSubstring = PartSimpleText.FirstOrDefault(p => p.OriginalText.Contains(elem.ElementValue.Value));
        if (partWithSubstring != null)
        {
            var index = PartSimpleText.IndexOf(partWithSubstring);
            PartSimpleText[index] =
                SimpleText.CreateInstance(partOriginal.Substring(0, elem.StartIndex - 1), 0, string.Empty);
            var newDistalPart =
                SimpleText.CreateInstance(partOriginal.Substring(elem.EndIndex + 1), 0, string.Empty);
            newDistalPart.ConnectorBefore = partOriginal.Substring(elem.EndIndex, 1);
            PartSimpleText.Add(newDistalPart);
        }
        else
        {
            throw new ArgumentOutOfRangeException(nameof(PartSimpleText), PartSimpleText.Count,
                                       "PartSimpleText.Count is 2, but none of the SimpleTexts contains the substring");
        }
    }
    else
    {
        throw new ArgumentOutOfRangeException(nameof(PartSimpleText), PartSimpleText.Count,
                               "PartSimpleText.Count is greater than 2");
    }
}
#endregion draft
}
//################################################################################### NamePart End ##########################################################################################
#endregion
//################################################################################### InNameGUID ##########################################################################################
public class InNameGUID : BaseElement//ValueObject
{
    private InNameGUID(int startIndex, int end, DocNamePart part, string guid)
    {
        StartIndex = startIndex;
        EndOriginal = end;
        Part = part;
        GUID = guid;
    }
    private InNameGUID(string originalText, DocNamePart part)
    {
        Part = part;
        OriginalText = originalText;
    }
    public static InNameGUID CreateInstance(string originalText, DocNamePart part)
    {
        if (string.IsNullOrEmpty(originalText))
            return NullGUID;
        var instance = new InNameGUID(originalText, part);
        instance.GetGUID();
        return instance.ElementValue.IsFailure
            ? NullGUID : instance;
    }
    //public static InNameGUID CreateInstance(int start, int end, DocNamePart part, string guid)
    //{
    //    return new InNameGUID(start, end, part, guid);
    //}
​
    public bool NoGUID => string.IsNullOrEmpty(GUID);
    public bool HasGUID => !string.IsNullOrEmpty(GUID);
    public static InNameGUID NullGUID => new(-1, -1, DocNamePart.NoPart, string.Empty);
​
    private void GetGUID()//string part, DocNamePart namePart)
    {
        //var rgx = new Regex(Grab_GUID_treated);
        var rgx = DocNameHelper.ForGrab_GUID_Treated.Value;
        var match = rgx.Match(OriginalText);
        //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
        //var result = match.Success
        //    ? CreateInstance(match.Groups["GUID"].Index, match.Groups["GUID"].Length - 1, Part, match.Groups["GUID"].Value)
        //    : NullGUID;
        if (!match.Success) return;
        //Check if this below line is coherent with 
        StartIndex = match.Groups["GUID"].Index;
        EndOriginal = match.Groups["GUID"].Index + match.Groups["GUID"].Length - 4;
        LengthOriginal = match.Groups["GUID"].Length - 4;
        //end is not end; end is Length...and length of treated GUID, with <> instead of - (to compensate the 4 <> for 4 -, delete 4 from Length)
        EndTreated = match.Groups["GUID"].Index + match.Groups["GUID"].Length;
        LengthTreated = match.Groups["GUID"].Length;
        //Part = part;
        GUID = match.Groups["GUID"].Value.Trim();
        //      1   2           
        //  0   1   2   3   4   5
        //? Result.Success(match.Groups["GUID"].Value.Trim())
        //: Result.Failure<string>("No GUID in this part");
        ElementValue = Result.Success(GUID);
        //return result;
    }
    //public int StartIndex { get; private set; }
    public int EndOriginal { get; private set; }
    public int LengthOriginal { get; private set; }
    public int LengthTreated { get; private set; }
    public int EndTreated { get; private set; }
    public DocNamePart Part { get; private set; }
    public string GUID { get; private set; }
    protected override IEnumerable<IComparable> GetEqualityComponents()
    {
        yield return Part;
        yield return EndOriginal;
        yield return StartIndex;
        yield return GUID;
        yield return NoGUID;
    }
}
//################################################################################### InNameGUID End ##########################################################################################                       
//################################################################################### 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 bool HasDrugAndDose => ElementValue.IsSuccess;
        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()
        {
            var rgx = new Regex(GrabDoseAndUnitOfMedicinesFromPartOfFile);
            var match = rgx.Match(OriginalText);
            if (match.Success)
            {
                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";
                ElementValue = Result.Success(OriginalText);
            }
        else
        {
            var criteria = new string[] { "Receita de Antibióticos", "Receita de Psicotrópicos" };
            var source = SourceJSON.CreateInstance(true);
            var medicines = source.GetWordsThatPointsToType(criteria);
            foreach (var medicine in medicines)
            {
                if (!OriginalText.ToLowerInvariant().Contains(medicine.ToLowerInvariant()))
                    continue;
                Name = medicine.CapitalizeFirstLetter();
                ElementValue = Result.Success(Name);
                Dosage = "N/A";
                Unit = "N/A";
                Form = "N/A";
            }
        }
    }
​
        #endregion Private Methods
        #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
    }
//################################################################################### MedicineAndDosageInSentence  End ##########################################################################################
//################################################################################### SimpleText  ##########################################################################################
    public class SimpleText : BaseElement
    {
        private SimpleText(string text, int startIndex, string connector)
        {
            OriginalText = text;
            StartIndex = startIndex;
            ConnectorBefore = connector;
            ElementValue = text;
        }
​
        public static SimpleText CreateInstance(string text, int startIndex, string connector)
        {
            return new SimpleText(text, startIndex, connector);
        }
    }
//################################################################################### SimpleText   End ##########################################################################################
//################################################################################### VersionInSentence  ##########################################################################################
public class VersionInSentence : BaseElement//ValueObject
{
    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
    #region Public Fields
    public bool HasVersion => !string.IsNullOrEmpty(Version);
    public bool HasVersionWithPrefix => !string.IsNullOrEmpty(VersionPrefix);
    public bool HasVersionNumberOnly => HasVersion && !HasVersionWithPrefix;
    public string Version { get; private set; } = string.Empty;
    //[JsonIgnore]
    public string VersionPrefix => Version.ReturnOnlyNonNumericCharacters();
    //[JsonIgnore]
    public int VersionNumber => Version.ReturnOnlyNumbersAsInt()!.Value;
    #endregion Public Fields
    #region Constructors
    private VersionInSentence(string partToTest, string parsedVersion = "")
    {
        _originalSentenceToParseDate = partToTest;
        Version = parsedVersion;
    }
​
    private VersionInSentence(string partToTest)
    {
        OriginalText = partToTest;
    }
​
    public static VersionInSentence CreateInstance(string partToTest)
    {
        if (string.IsNullOrEmpty(partToTest))
            return NullVersion;
        var instance = new VersionInSentence(partToTest);
        //I do not know but below code increased time in almost 900 ms...
        //instance._rgxForGrabVersionFromFile = new Regex(GrabVersionFromFile, RegexOptions.Compiled | RegexOptions.IgnoreCase);
        instance.GetVersion();
        return instance.ElementValue.IsFailure ? NullVersion : instance;
    }
    /// <summary>
    /// It returns the same Version if it would fail to parse the new partToTest
    /// </summary>
    /// <param name="partToTest"></param>
    /// <param name="oldVersionInSentence"></param>
    /// <returns></returns>
    internal static VersionInSentence UpdateInstance(string partToTest, VersionInSentence oldVersionInSentence, string connectorBefore = "")
    {
        var oldIndex = oldVersionInSentence.StartIndex;
        var connector = connectorBefore == "" ? oldVersionInSentence.ConnectorBefore : connectorBefore;
        var instance = CreateInstance(partToTest);
        if (instance.ElementValue.IsFailure)
            return oldVersionInSentence; //NullVersion
        CopyContextProperly(instance, oldIndex, connector);
        return instance;
    }
    /// <summary>
    /// It returns the same Version if it would fail to parse the new partToTest
    /// </summary>
    /// <param name="partToTest"></param>
    /// <param name="oldVersionInSentence"></param>
    /// <returns></returns>
    public static VersionInSentence TryUpdateInstanceFailingIfNull(string partToTest, VersionInSentence oldVersionInSentence)
    {
        var instance = CreateInstance(partToTest);
        return instance.ElementValue.IsFailure ? oldVersionInSentence : UpdateInstance(partToTest, oldVersionInSentence);
    }
    public static VersionInSentence NullVersion => new(string.Empty, string.Empty);
​
    #endregion Constructors
​
    #region Private Methods
    private void GetVersion()
    {
        Result<string> version;
        if (string.IsNullOrEmpty(OriginalText) || DocNameHelper.DifficultyToTestPart(OriginalText))
            version=  Result.Failure<string>("No file version");
        version = GetVersionFromPart(OriginalText);
        if (!version.IsFailure && version.Value.IsNumber())
        {
            version = TestVersionNumberOnly(version.Value);
        }
​
        if (version.IsFailure && OriginalText.Length < 3 && OriginalText.IsNumber())
        {
            version = TestVersionNumberOnly(OriginalText);
        }
​
        if (version.IsFailure && OriginalText.ReturnOnlyNumbers().Length > 0 && OriginalText.ReturnOnlyNumbers().Length < 3 && OriginalText.ReturnOnlyNumbers().IsNumber())
        {
            version = TestVersionNumberOnly(OriginalText.ReturnOnlyNumbers());
        }
        ElementValue = version; // "2017"
        if (ElementValue.IsSuccess)
            Version = ElementValue.Value;
    }
​
    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 Result<string> GetVersionFromPart(string partToTest)
    {
        var version = DocNameHelper.ReturnResult(DocNameHelper.ForGrabVersionFromFile.Value, partToTest, "version", "No file version");
        if (version.IsFailure && !char.IsWhiteSpace(partToTest, 0))
            version = DocNameHelper.ReturnResult(DocNameHelper.ForGrabVersionFromFile.Value, $" {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");
    }
    #endregion Private Methods
​
    #region Overrides of ValueObject
​
    protected override IEnumerable<IComparable> GetEqualityComponents()
    {
        yield return _originalSentenceToParseDate;
        yield return Version;
    }
​
    #endregion
}
//################################################################################### VersionInSentence End ##########################################################################################
//################################################################################### DateInSentence  ##########################################################################################
public class DateInSentence : BaseElement// ValueObject
{
    #region Private fields
    private readonly string _cultureInfo;
    private readonly int? _maxPossibleYear;
    private readonly bool _forceDdmMorMmdd;
    private readonly int _minPossibleYear;
    private readonly bool _acceptWildCard;
    private bool _useTestDateInsteadOfResult;
    #endregion Private fields
​
    #region Private Constants
    private const string WildCardForDate = "_";
    #endregion Private Constants
​
    #region Public Fields
​
​
    public bool PortugueseMonthErroneouslyAbbreviatedWithoutDot { get; set; }
    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);
    [JsonIgnore]
    public bool DateMaskProvidesYYYY => this.Mask.GetDescription().Contains("yyyy");
    [JsonIgnore]
    public bool DateYearHasWildCard => this.DateAndTime == DateTime.MaxValue;
​
    public DateFormat Mask { get; private set; } = DateFormat.NoDate;
    public CertaintyAboutElement CertaintyAbout { get; private set; } = CertaintyAboutElement.NonExisting;
    public bool IsDDMM => _cultureInfo == "pt-BR";
    public bool HasDate => DateAndTime != DateTime.MinValue;
    #endregion Public Fields
​
    #region Constructors
    [JsonConstructor]
    private DateInSentence()
    {
​
    }
    private DateInSentence(string originalSentenceToParseDate, string cultureInfo, int? maxPossibleYear,
        bool forceDDMMorMMDD, int minPossibleYear, bool acceptWildCard)
    {
        OriginalText = originalSentenceToParseDate;
        _cultureInfo = cultureInfo;
        _maxPossibleYear = maxPossibleYear ??= GetMaxPossibleYear();
        _forceDdmMorMmdd = forceDDMMorMMDD;
        _minPossibleYear = minPossibleYear;
        _acceptWildCard = acceptWildCard;
    }
    public static DateInSentence NullDate =>
        new(string.Empty, string.Empty, int.MaxValue, false, int.MinValue, false)
        {
            DateText = string.Empty,
            DateAndTime = DateTime.MinValue,
            Mask = DateFormat.NoDate,
            CertaintyAbout = CertaintyAboutElement.NonExisting
        };
    //public static DateInSentence NullDate =>
    //    new(string.Empty, DateTime.MinValue, DateFormat.NoDate, CertaintyAboutElement.NonExisting);
    public static DateInSentence ChangeToYYYY(DateInSentence date, DateFormat newMask, string cultureInfo)
    {
        if (date.DateText.Length != 4) throw new ArgumentException("Can only change mask of DDMM or MMDD to YYYY");
        return ChangeMask(date, DateFormat.yyyy, date._cultureInfo);
    }
​
    public static DateInSentence ChangeToMMDD(DateInSentence date, DateFormat newMask, string cultureInfo)
    {
        if (date.DateText.Length != 4) throw new ArgumentException("Can only change mask of DDMM or YYYY to MMDD");
        return ChangeMask(date, DateFormat.MMdd, date._cultureInfo);
    }
    public static DateInSentence ChangeToDDMM(DateInSentence date, DateFormat newMask, string cultureInfo)
    {
        if (date.DateText.Length != 4) throw new ArgumentException("Can only change mask of MMDD or YYYY to DDMM");
        return ChangeMask(date, DateFormat.ddMM, date._cultureInfo);
    }
    private static DateInSentence ChangeMask(DateInSentence date, DateFormat newMask, string cultureInfo)
    {
        return CreateInstanceProvidingAllCorrectElements(date.DateText, date.DateAndTime, newMask, cultureInfo
            , date.CertaintyAbout, date._maxPossibleYear.HasValue ? date._maxPossibleYear.Value : GetMaxPossibleYear()
            , date._forceDdmMorMmdd, date._minPossibleYear, date._acceptWildCard);
    }
​
    /// <summary>
    /// As name implies, it will return a date that is a combination of correct arguments; it will not test for validity
    /// </summary>
    /// <param name="dateText"></param>
    /// <param name="dateTime"></param>
    /// <param name="mask"></param>
    /// <param name="cultureInfo"></param>
    /// <param name="certaintyAbout"></param>
    /// <param name="maxPossibleYear"></param>
    /// <param name="forceDDMMorMMDD"></param>
    /// <param name="minPossibleYear"></param>
    /// <param name="acceptWildCard"></param>
    /// <returns></returns>
    public static DateInSentence CreateInstanceProvidingAllCorrectElements(string dateText, DateTime dateTime,
        DateFormat mask, string cultureInfo, CertaintyAboutElement certaintyAbout = CertaintyAboutElement.AbsolutelyCertain
        , int maxPossibleYear = int.MaxValue, bool forceDDMMorMMDD = false, int minPossibleYear = 1990, bool acceptWildCard = false)
    {
        return //new DateInSentence(dateText, dateTime, mask, certaintyAbout);
​
        new(dateText, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard)
        {
            DateText = dateText,
            DateAndTime = dateTime,
            Mask = mask,
            CertaintyAbout = certaintyAbout
        };
    }
​
    public static DateInSentence CreateInstanceFromSentence(string dateToParse, string cultureInfo
        , (int start, int end) forbiddenZoneCoordinates, int? maxPossibleYear
        , bool forceDDMMorMMDD = false, int minPossibleYear = 1990, bool acceptWildCard = true)
    {
        var dateBeforeParsing = new DateInSentence(dateToParse, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
        //Below is the slowest place in the whole program, because of the DateTime.TryParseExact
        var hasDate = dateBeforeParsing.GetDate(dateToParse, forbiddenZoneCoordinates);
        //Console.WriteLine($"hasDate at CreateInstanceFromSentence: {hasDate}");
        //var hasDateStatic = GetDateStatic(dateToParse, cultureInfo, forbiddenZoneCoordinates, acceptWildCard);
        if (hasDate.IsFailure)
            return DateInSentence.NullDate;
        var instance = CreateInstance(hasDate.Value, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
        return instance;
    }
    /// <summary>
    /// Create Instance inferring Mask and Format for Date Parsing
    /// </summary>
    public static DateInSentence CreateInstance(string dateToParse, string cultureInfo, int? maxPossibleYear,
        bool forceDDMMorMMDD = false, int minPossibleYear = 1990, bool acceptWildCard = true)
    {
        var dateParsing = new DateInSentence(dateToParse, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
        var raw = dateParsing.OriginalText;
        // 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())
        {
            TryParseNumericOnlyDates(cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, raw, dateParsing);
            //if (DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None,
            //        out var parsedDate))
            //{
            //    dateParsing.DateAndTime = parsedDate;
            //    dateParsing.DateText = raw;
            //    dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
            //}
        }
        else //if (!raw.IsDigit()) MMM or MMMM or ddd or dd or tt
        {
            TryParseDatesWithNonDigits(cultureInfo, raw, dateParsing);
#if DEBUG
            if (string.IsNullOrEmpty(dateParsing.DateText))
                Console.WriteLine($"InferMaskAndFormatForDateParsing: dateParsing {raw} is not digit, ie, MMM or MMMM or ddd or dd or tt");
            //throw new NotImplementedException($"InferMaskAndFormatForDateParsing: dateParsing {raw} is not digit, ie, MMM or MMMM or ddd or dd or tt");
#endif
        }
        //if (!string.IsNullOrEmpty(dateParsing.DateText)) 
        //Below only works because 202_ is a valid date BUT originally DateTime.MinValue and I changed to DateTime.MaxValue
        if (dateParsing.DateAndTime == DateTime.MinValue) return NullDate; // dateParsing;
        dateParsing.ElementValue = Result.Success(dateParsing.DateText);
        return dateParsing;
        //DateInSentence.CreateInstance(raw, parsedDate, dateParsing.Mask, dateParsing.CertaintyAbout);
    }
​
    private static void TryParseDatesWithNonDigits(string cultureInfo, string raw, DateInSentence dateParsing)
    {
        if (raw.Contains(WildCardForDate))
            TryParseDatesWithWildCard(cultureInfo, raw, dateParsing);
        else //if (!raw.Contains(WildCardForDate))
            TryParseDatesWithNonDigitsOtherThanWildCard(cultureInfo, raw, dateParsing);
        //GrabDatesWithMonthsInLettersOrPureNumbersFromFile
        //grab: 202_
        //[Description("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'")]
        //universalSortable             
    }
    private static DateInSentence TryParseDatesWithWildCard(string cultureInfo, string raw, DateInSentence dateParsing)
    {
        DateTime parsedDate;
        switch (raw.Length)
        {
            // 202_ or 20__ or 20_
            case 3 or 4:
                {
                    dateParsing.Mask = DateFormat.yyyy;
                    //Below is the way to work because 202_ is a valid date BUT originally DateTime.MinValue and I changed to DateTime.MaxValue
                    dateParsing.DateAndTime = DateTime.MaxValue;
                    dateParsing.DateText = raw;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
                    break;
                }
            case 5: //"18_09".Length
                {
                    dateParsing.Mask = IsCulturePortuguese(cultureInfo) ? DateFormat.DDMMIncorrectFormattedWithWildcardBR : DateFormat.DDMMIncorrectFormattedWithWildcardUS;
                    _ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
                    dateParsing.DateAndTime = parsedDate;
                    dateParsing.DateText = raw;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
                    break;
                }
            case 10: //"18_09_2023".Length
                {
                    dateParsing.Mask = IsCulturePortuguese(cultureInfo) ? DateFormat.FullDateIncorrectFormattedWithWildcardBR : DateFormat.FullDateIncorrectFormattedWithWildcardUS;
                    _ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
                    dateParsing.DateAndTime = parsedDate;
                    dateParsing.DateText = raw;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
                    break;
                }
            case >= 7 and <= 14 when HasFullMonth(raw, cultureInfo)://may2021 || fevereiro-2021
                {
                    dateParsing.Mask = DateFormat.MMMMyyyyIncorrectFormattedWithWildcard;
                    //dateParsing.DateAndTime = DateTime.Parse(raw);
                    var couldParseDate = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(),
                        new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
                    dateParsing.DateText = couldParseDate ? parsedDate.ToString(dateParsing.Mask.GetDescription()) : raw;
                    dateParsing.DateAndTime = parsedDate;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
                    break;
                }
            case 22 when cultureInfo == "pt-BR":// 2023_abr._10__13_38_12
                {
                    //LinqPad uses it but it does not parse date, but VS uses and it parses...
                    dateParsing.Mask = DateFormat.personalizedForAnotaçãoOutlookBackupWithDot;
                    _ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
                    //To circumvent this weary thing, I'm using mask without dot to get date with dot in LinQPad...
                    if (parsedDate == DateTime.MinValue)
                        _ = DateTime.TryParseExact(raw, DateFormat.personalizedForAnotaçãoOutlookBackup.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
                    dateParsing.DateText = raw;
                    dateParsing.DateAndTime = parsedDate;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
                    break;
                }
            // 2023_abr_10__13_38_12 OR 2023_apr_10__13_38_12
            case 21:
                {
                    //LinqPad uses it but it does not parse date, but VS uses and it parses...
                    dateParsing.Mask = DateFormat.personalizedForAnotaçãoOutlookBackup;
                    var (_, nextCharIsDot) = DateInSentence.GetAbbreviatedMonthPortugueseAndTellIfNextCharIsDot(raw);
                    var rawTreated = string.Empty;
                    if (!nextCharIsDot)
                        rawTreated = cultureInfo == "en-US" ? raw : DateInSentence.AdjustStringForMMMAddingDot(raw, cultureInfo);
                    var couldParseDate = DateTime.TryParseExact(rawTreated, IsCulturePortuguese(cultureInfo) ? DateFormat.personalizedForAnotaçãoOutlookBackupWithDot.GetDescription() : dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
                    //To circumvent this weary thing, I'm using mask without dot to get date with dot in LinQPad...
                    if (parsedDate == DateTime.MinValue)
                        _ = DateTime.TryParseExact(rawTreated, DateFormat.personalizedForAnotaçãoOutlookBackup.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
                    dateParsing.DateText = raw;
                    dateParsing.DateAndTime = parsedDate;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
                    break;
                }
        }
​
        return dateParsing;
    }
    private static DateInSentence TryParseDatesWithNonDigitsOtherThanWildCard(string cultureInfo, string raw, DateInSentence dateParsing)
    {
        DateTime parsedDate;
        if (raw.ContainsOnlyDigitsAndThisSubstring("."))
        {
            switch (raw.Length)
            {
                case 10://"18.09.2023".Length)
                    dateParsing.Mask = IsCulturePortuguese(cultureInfo) ? DateFormat.FullDateIncorrectFormattedWithDotBR : DateFormat.FullDateIncorrectFormattedWithDotUS;
                    _ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
                    dateParsing.DateAndTime = parsedDate;
                    dateParsing.DateText = raw;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
                    break;
                case 8://"18.09.23".Length)
                    dateParsing.Mask = IsCulturePortuguese(cultureInfo) ? DateFormat.FullDateIncorrectTwoDigitsYearAndFormattedWithDotBR : DateFormat.FullDateIncorrectTwoDigitsYearAndFormattedWithDotUS;
                    _ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
                    dateParsing.DateAndTime = parsedDate;
                    dateParsing.DateText = raw;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.InformedGuess;
                    break;
                case 5:// "18.09".Length)
                    dateParsing.Mask = IsCulturePortuguese(cultureInfo) ? DateFormat.DDMMIncorrectFormattedWithDotBR : DateFormat.DDMMIncorrectFormattedWithDotUS;
                    _ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
                    dateParsing.DateAndTime = parsedDate;
                    dateParsing.DateText = raw;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
                    break;
                case 4://"23.5".Length)
                    dateParsing.Mask = IsCulturePortuguese(cultureInfo) ? DateFormat.DDMIncorrectFormattedWithDotBR : DateFormat.DDMIncorrectFormattedWithDotUS;
                    _ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
                    dateParsing.DateAndTime = parsedDate;
                    dateParsing.DateText = raw;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.NotSure;
                    break;
            }
        }
        else
        {
            switch (raw.Length)
            {
                case 19 when raw.Contains("/") && raw.Contains(":") && raw.Contains(" ")://"dd/mm/yyyy hh:mm:ss".Length)
                                                                                         //10/04/2023 16:38:12
                    dateParsing.Mask = DateFormat.personalizedForAnotaçãoOutlookBackup;
                    //dateParsing.DateAndTime = DateTime.Parse(raw);
                    var couldParseDate = DateTime.TryParseExact(raw, cultureInfo == "en-US" ? DateFormat.completeUpToSecondsUS.GetDescription() : DateFormat.completeUpToSeconds.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
                    dateParsing.DateText = couldParseDate ? parsedDate.ToString(dateParsing.Mask.GetDescription()) : raw;
                    dateParsing.DateAndTime = parsedDate;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
                    break;
                case >= 7 and <= 14 when HasFullMonth(raw, cultureInfo)://may2021 || fevereiro-2021
                    if (raw.Contains(" "))
                    {
                        dateParsing.Mask = DateFormat.MMMMyyyyWithSpace;
                    }
                    else if (raw.Contains("."))
                    {
                        dateParsing.Mask = DateFormat.MMMMyyyyIncorrectFormattedWithDot;
                    }
                    else
                    {
                        dateParsing.Mask = DateFormat.MMMMyyyy;
                    }
                    //dateParsing.DateAndTime = DateTime.Parse(raw);
                    couldParseDate = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
                    dateParsing.DateText = couldParseDate ? parsedDate.ToString(dateParsing.Mask.GetDescription()) : raw;
                    dateParsing.DateAndTime = parsedDate;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
                    break;
                case 7 or 8 when HasAbbreviatedMonth(raw, cultureInfo)://fev.2021 || fev2021
                    dateParsing.Mask = DateFormat.MMMyyyy;
                    _ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo),
                        DateTimeStyles.None, out parsedDate);
                    if (parsedDate == DateTime.MinValue)
                        parsedDate = AdjustStringForMonthAndDot(cultureInfo, raw, dateParsing);
                    dateParsing.DateText = raw;
                    dateParsing.DateAndTime = parsedDate;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
                    break;
                case 5 or 6 when HasAbbreviatedMonth(raw, cultureInfo)://fev.21 || fev21
                    dateParsing.Mask = DateFormat.MMMyyIncorrectTwoDigitsYear;
                    _ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo),
                        DateTimeStyles.None, out parsedDate);
                    if (parsedDate == DateTime.MinValue)
                        parsedDate = AdjustStringForMonthAndDot(cultureInfo, raw, dateParsing);
                    dateParsing.DateText = raw;
                    dateParsing.DateAndTime = parsedDate;
                    dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
                    break;
            }
        }
        return dateParsing;
    }
​
    private static DateTime AdjustStringForMonthAndDot(string cultureInfo, string raw, DateInSentence dateParsing)
    {
        DateTime parsedDate;
        if (raw.Contains("."))
        {
            _ = DateTime.TryParseExact(DateInSentence.AdjustStringForMMMRemovingDot(raw, cultureInfo)
                , dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
        }
        else
        {
            _ = DateTime.TryParseExact(DateInSentence.AdjustStringForMMMAddingDot(raw, cultureInfo)
                , dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out parsedDate);
        }
​
        return parsedDate;
    }
​
    private static void TryParseNumericOnlyDates(string cultureInfo, int? maxPossibleYear, bool forceDDMMorMMDD,
        int minPossibleYear, string raw, DateInSentence dateParsing)
    {
        dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
        var parsedDate = DateTime.MinValue;
        const int sortableLength = 14;//DateFormat.sortable.GetDescription().Length;//yyyyMMddHHmmss
        switch (raw.Length)
        {
            //[Description("dd/MM/yyyy HH:mm:ss")]
            //completeUpToSeconds,
            //[Description("MM/dd/yyyy HH:mm:ss")]
            //completeUpToSecondsUS,
            //ddmmyyyy or mmddyyyy
            case sortableLength:
                //[Description("yyyyMMddHHmmss")]
                //sortable,
                dateParsing.Mask = DateFormat.sortable;
                break;
            case 8:
                {
                    dateParsing.Mask = dateParsing.IsDDMM ? DateFormat.ddMMyyyy : DateFormat.MMddyyyy;
                    if (DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None,
                            out parsedDate))
                    {
                        dateParsing.DateAndTime = parsedDate;
                        dateParsing.DateText = raw;
                    }
                    else
                    {
                        dateParsing.Mask = DateFormat.yyyyMMdd;
                        if (DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None,
                                out parsedDate))
                        {
                            dateParsing.DateAndTime = parsedDate;
                            dateParsing.DateText = raw;
                        }
                        else
                        {
                            dateParsing.Mask = DateFormat.NoDate;
                            dateParsing.CertaintyAbout = CertaintyAboutElement.NonExisting;
                        }
                    }
                    return;
                }
            //MMyyyy 
            case 6:
                dateParsing.Mask = DateFormat.MMyyyy;
                break;
            //ddMM OR MMdd OR yyyy
            case 4:
                {
                    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(), new CultureInfo(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;
                    }
​
                    break;
                }
            //dd OR MM OR yy
            case 2:
                throw new NotImplementedException($"InferMaskAndFormatForDateParsing: {raw} dateParsing.Length == 2");
        }
        if (DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None,
                out parsedDate))
        {
            dateParsing.DateAndTime = parsedDate;
            dateParsing.DateText = raw;
            //dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
        }
    }
​
    public static Result<DateInSentence> Update(string date, DateInSentence valueDateInSentence)
    {
        var oldIndex = valueDateInSentence.StartIndex;
        var connector = valueDateInSentence.ConnectorBefore;
        var tryDate = CreateInstance(date, valueDateInSentence._cultureInfo, valueDateInSentence._maxPossibleYear
            , valueDateInSentence._forceDdmMorMmdd, valueDateInSentence._minPossibleYear, valueDateInSentence._acceptWildCard);
        if (tryDate == NullDate)
            return Result.Failure<DateInSentence>("Invalid date");
        CopyContextProperly(tryDate, oldIndex, connector);
        return Result.Success(tryDate);
    }
    /// <summary>
    /// It returns the same Date if it would fail to parse the new partToTest
    /// </summary>
    /// <param name="date"></param>
    /// <param name="valueDateInSentence"></param>
    /// <param name="connectorBefore"></param>
    /// <returns></returns>
    public static DateInSentence UpdateInstance(string date, DateInSentence valueDateInSentence, string connectorBefore = "")
    {
        var oldIndex = valueDateInSentence.StartIndex;
        var connector = connectorBefore == "" ? valueDateInSentence.ConnectorBefore : connectorBefore;
        var tryDate = CreateInstance(date, valueDateInSentence._cultureInfo, valueDateInSentence._maxPossibleYear
            , valueDateInSentence._forceDdmMorMmdd, valueDateInSentence._minPossibleYear, valueDateInSentence._acceptWildCard);
        if (tryDate == NullDate)
            return valueDateInSentence;//NullDate;
        CopyContextProperly(tryDate, oldIndex, connector);
        return tryDate;
    }
    #endregion Constructors
​
    #region Private Methods
    private Result<string> GetDate(string partToTest, (int start, int end) forbiddenZoneCoordinates)
    {
        _useTestDateInsteadOfResult = false;
        PortugueseMonthErroneouslyAbbreviatedWithoutDot = false;
        if (string.IsNullOrEmpty(partToTest) || partToTest.DoesNotContainAnyNumbers() || DocNameHelper.DifficultyToTestPart(partToTest))
            return Result.Failure<string>("No date stamp in this file name");
        var hasDate = ReturnDateResult(DocNameHelper.ForGrabDatesUTC.Value, partToTest, "dateUTC",
            "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates, _useTestDateInsteadOfResult);
        //"No date stamp in this file name", partName, partHasGUID);
        if (hasDate.IsFailure)
        {
            _useTestDateInsteadOfResult = false;
            hasDate = ReturnDateResult(DocNameHelper.ForGrabDatePersonalizedForAnotaçãoOutlookBackup.Value, partToTest, "date",
                "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates, _useTestDateInsteadOfResult);
            if (hasDate.IsSuccess)
            {
                Mask = DateFormat.personalizedForAnotaçãoOutlookBackup;
                PortugueseMonthErroneouslyAbbreviatedWithoutDot = true;
            }
            if (hasDate.IsFailure)
            {
                hasDate = ReturnDateResult(DocNameHelper.ForGrabDatePersonalizedForAnotaçãoOutlookBackupWithDotAfterMMM.Value, partToTest,
                    "date",
                    "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates,
                    _useTestDateInsteadOfResult);
                if (hasDate.IsSuccess)
                    Mask = DateFormat.personalizedForAnotaçãoOutlookBackupWithDot;
            }
            //"2013_abr._20__13_38_12" for "Miuza de Holanda Fragelli - anotação Outlook_backup_2013_abr._20__13_38_12.pdf"
            //"20/04/2013 13:38:12" for "Miuza de Holanda Fragelli - anotação Outlook_backup_2013_abr_20__13_38_12.pdf"
            //"20/04/2013 13:38:12" for "Miuza de Holanda Fragelli - anotação Outlook_backup_2013_apr_20__13_38_12.pdf"
        }
        if (hasDate.IsFailure)
        {
            _useTestDateInsteadOfResult = false;
            hasDate = ReturnDateResult(DocNameHelper.ForGrabAbbreviatedMonthWithTwoOrFourDigitYearWithDotSeparatingThemOrNot.Value, partToTest, "date",
                "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates, _useTestDateInsteadOfResult);
            if (hasDate.IsSuccess)
            {
                var length = hasDate.Value.Length;
                var numOfDots = hasDate.Value.CountOccurrences(".");
                PortugueseMonthErroneouslyAbbreviatedWithoutDot = false;
                switch (length)
                {
                    case 10 when numOfDots == 2: //15.05.2021
                        Mask = IsCulturePortuguese(_cultureInfo)
                            ? DateFormat.FullDateIncorrectFormattedWithDotBR
                            : DateFormat.FullDateIncorrectFormattedWithDotUS;
                        break;
                    case 8 when numOfDots == 2: //15.05.21
                        Mask = DateFormat.FullDateIncorrectTwoDigitsYearAndFormattedWithDotBR;
                        break;
                    case 8 when numOfDots == 1: //fev.2021
                        Mask = DateFormat.MMMdotyyyy;
                        break;
                    case 7 when numOfDots == 0://fev2021
                        Mask = DateFormat.MMMyyyy;
                        PortugueseMonthErroneouslyAbbreviatedWithoutDot = IsCulturePortuguese(_cultureInfo) ? true : false;
                        break;
                    case 6://fev.21
                        Mask = DateFormat.MMMdotIncorrectTwoDigitsYear;
                        break;
                    case 5://fev21
                        Mask = DateFormat.MMMyyIncorrectTwoDigitsYear;
                        PortugueseMonthErroneouslyAbbreviatedWithoutDot = IsCulturePortuguese(_cultureInfo) ? true : false;
                        break;
                }
            }
            if (hasDate.IsFailure)
            {
                hasDate = ReturnDateResult(DocNameHelper.ForGrabDatePersonalizedForAnotaçãoOutlookBackupWithDotAfterMMM.Value, partToTest,
                    "date",
                    "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates,
                    _useTestDateInsteadOfResult);
                if (hasDate.IsSuccess)
                    Mask = DateFormat.personalizedForAnotaçãoOutlookBackupWithDot;
            }
            //"2013_abr._20__13_38_12" for "Miuza de Holanda Fragelli - anotação Outlook_backup_2013_abr._20__13_38_12.pdf"
            //"20/04/2013 13:38:12" for "Miuza de Holanda Fragelli - anotação Outlook_backup_2013_abr_20__13_38_12.pdf"
            //"20/04/2013 13:38:12" for "Miuza de Holanda Fragelli - anotação Outlook_backup_2013_apr_20__13_38_12.pdf"
        }
        if (hasDate.IsFailure)
        {
            _useTestDateInsteadOfResult = false;
            hasDate = ReturnDateResult(DocNameHelper.ForGrabDatesIncorrectFormattedWithInvalidChars.Value, partToTest, "date",
                "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates, _useTestDateInsteadOfResult);
            if (hasDate.IsSuccess)
            {
                var length = hasDate.Value.Length;
                var numOfDots = hasDate.Value.CountOccurrences(".");
                PortugueseMonthErroneouslyAbbreviatedWithoutDot = false;
                Mask = length switch
                {
                    8 when numOfDots == 2 => //15.05.21
                        DateFormat.FullDateIncorrectTwoDigitsYearAndFormattedWithDotBR,
                    10 when numOfDots == 2 => //15.05.2021
                        IsCulturePortuguese(_cultureInfo)
                            ? DateFormat.FullDateIncorrectFormattedWithDotBR
                            : DateFormat.FullDateIncorrectFormattedWithDotUS,
                    _ => Mask
                };
            }
​
        }
        if (hasDate.IsFailure)
        {
            _useTestDateInsteadOfResult = false;
            hasDate = ReturnDateResult(DocNameHelper.ForGrabDatesOrPureNumbersOrDatesWithCardFromPartOfFile.Value, partToTest, "date",
                "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates, _useTestDateInsteadOfResult);
            //"No date stamp in this file name", partName, partHasGUID);                
        }
        if (hasDate.IsFailure)
        {
            _useTestDateInsteadOfResult = false;
            hasDate = ReturnDateResult(DocNameHelper.ForGrabFullMonthWithTwoOrFourDigitYearWithSomeCharSeparatingThemOrNot.Value, partToTest, "date",
                "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates, _useTestDateInsteadOfResult);
            //"No date stamp in this file name", partName, partHasGUID);                
        }
        if (hasDate.IsFailure)
        {
            _useTestDateInsteadOfResult = false;
            hasDate = ReturnDateResult(DocNameHelper.ForGrabDatesWithMonthsInLettersOrPureNumbersFromFile.Value, partToTest, "intervalordate",
                "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates, _useTestDateInsteadOfResult);
            //"No date stamp in this file name", partName, partHasGUID);                
        }
        if (hasDate.IsSuccess && !_useTestDateInsteadOfResult)
        {
            hasDate = FilterAbsurdDates(hasDate, _cultureInfo, Mask, _acceptWildCard, "No date stamp in this file name");
        }
        return hasDate;
    }
​
    internal static int GetCurrentYearPlus(int toAddCurrent) => DateTime.Now.Year + toAddCurrent;
    internal static int GetMaxPossibleYear(int yearsAhead = 2) => DateTime.Now.Year + yearsAhead;
    internal static bool IsItPossibleToBeDDMMOrMMDD(string dateToTest, string cultureInfo)
    {
        if (dateToTest.Length != 4) return false;
        return DateTime.TryParseExact(dateToTest, DateFormat.ddMM.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out _) ||
               DateTime.TryParseExact(dateToTest, DateFormat.MMdd.GetDescription(), new CultureInfo(cultureInfo), DateTimeStyles.None, out _);
    }
​
    internal static Result<string> FilterAbsurdDates(
        Result<string> hasDate, string cultureInfo, DateFormat mask, 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 (string.IsNullOrEmpty(dateWithoutSpace)) return Result.Failure<string>(errorMsg);
        if (DocNameHelper.DateTryParseExact(dateWithoutSpace, out testDate, new CultureInfo(cultureInfo)))
        //if (DateTime.TryParseExact(dateWithoutSpace, "yyyy", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out testDate)     )
        {
            return TestIfDateIsInsideBoundaries(errorMsg, numberOfYearsToConsiderAbsurd, testDate, dateWithoutSpace);
        }
        else if (acceptWildCard && dateWithoutSpace.Contains(WildCardForDate))
        {
            return Result.Success(dateWithoutSpace);
        }
        else if (mask == DateFormat.MMMyyyy && !dateWithoutSpace.Contains("."))
        { // proved to be incorrect assumptions
            mask = DateFormat.MMMdotyyyy;
            var dateWithDot = AdjustStringForMMMAddingDot(dateWithoutSpace, cultureInfo);
            if (DocNameHelper.DateTryParseExact(AdjustStringForMMMAddingDot(dateWithDot, cultureInfo), out testDate, new CultureInfo(cultureInfo)))
            {
                return TestIfDateIsInsideBoundaries(errorMsg, numberOfYearsToConsiderAbsurd, testDate, dateWithoutSpace);
            }
        }
        //Console.WriteLine("DateTryParseExact FAILURE: " + testDate);
        return Result.Failure<string>($"Invalid date resulting in {testDate.ToString()}");
    }
​
    private static Result<string> TestIfDateIsInsideBoundaries(string errorMsg, int numberOfYearsToConsiderAbsurd,
        DateTime testDate, string dateWithoutSpace)
    {
        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);
    }
    private static bool InTimeRangeAllowed(int numberOfYearsToConsiderAbsurd, DateTime testDate)
    {
        try
        {
            var tested = Math.Abs(testDate.YearsBetweenNowAndDate());
            return tested < numberOfYearsToConsiderAbsurd;
        }
        catch (Exception)
        {
            return false;
        }
    }
​
    private Result<string> ReturnDateResult(Regex rgx, string part, string groupName, string errorMsg
        , string cultureInfo, (int start, int end) forbiddenZoneCoordinates, bool useTestDateInsteadOfResult)
    {
        Result<string> result;
        var match = DocNameHelper.GetMatch(rgx, part, groupName, errorMsg, out result);
        if (!result.IsFailure && result.Value.Length <= 1) return Result.Failure<string>(errorMsg);
        if (!result.IsFailure && DocNameHelper.OutOfForbiddenZoneIfSamePart(groupName, match, forbiddenZoneCoordinates.start, forbiddenZoneCoordinates.end)) return result;
        if ((useTestDateInsteadOfResult && result.IsSuccess) || result.IsSuccess && DocNameHelper.DateTryParseExact(result.Value, out _, new CultureInfo(cultureInfo)))
        {
            //use https://regex101.com/r/KESkRm/5 to solve backup_2023_dec_10__13_38_12.pdf
            if (result.Value.Length > 1) part = result.Value;//AdjustStringForMMM(result.Value);
        }
        //https://stackoverflow.com/questions/38948394/datetime-tryparse-fails-at-yyyy-only
        var dateParsed = (DocNameHelper.DateTryParseExact(part, out var testDate, new CultureInfo(cultureInfo)));
        //Above is the slowest place in the whole program, because of the DateTime.TryParseExact
        if (dateParsed && !testDate.IsThisDateNullOrDefault())
            result = Result.Success(!useTestDateInsteadOfResult ? part : testDate.ToString(CultureInfo.CurrentCulture));
        //it works in Outlook_backup_2023_apr_10__13_38_12, but I suspect that it is coincidence ^^^^^^^^^^^ 
        return result;
    }
​
    internal static string AdjustStringForMMMAddingDot(string resultValue, string cultureInfo)
    {
        //_backup_2023_abr._10__13_38_12 OR _backup_2023_abr_10__13_38_12
        if (!IsCulturePortuguese(cultureInfo) || HasMonthFullPortuguese(resultValue))
            return resultValue;
        var (monthToAddDot, nextCharIsDot) = GetAbbreviatedMonthPortugueseAndTellIfNextCharIsDot(resultValue);
        //if next char is not a dot, add it
        if (!string.IsNullOrEmpty(monthToAddDot) && !nextCharIsDot) // tested in CorrectApplyOrRemoveDotFromPortugueseAbbreviatedMonth
            resultValue = resultValue.AddSubstringAfterThisFoundExcerpt(monthToAddDot, '.'.ToString());
        return resultValue;
    }
    internal static string AdjustStringForMMMRemovingDot(string resultValue, string cultureInfo)
    {
        //_backup_2023_abr._10__13_38_12 OR _backup_2023_abr_10__13_38_12
        if (!IsCulturePortuguese(cultureInfo) || HasMonthFullPortuguese(resultValue))
            return resultValue;
        var (monthToAddDot, nextCharIsDot) = GetAbbreviatedMonthPortugueseAndTellIfNextCharIsDot(resultValue);
        //if next char is a dot, remove it
        if (!string.IsNullOrEmpty(monthToAddDot) && nextCharIsDot) // tested in CorrectApplyOrRemoveDotFromPortugueseAbbreviatedMonth
            resultValue = resultValue.RemoveSubstringAfterThisFoundExcerpt(monthToAddDot, '.'.ToString());
        return resultValue;
    }
​
    internal static (string monthToAddDot, bool nextCharIsDot) GetAbbreviatedMonthPortugueseAndTellIfNextCharIsDot(
        string resultValue)
    {
        var monthToAddDot = ReturnFirstMatchOf(DocNameHelper.MonthsPortugueseAbbreviated, resultValue);
        //check if next char after monthToAddDot is a dot
        var dot = '.';
        var nextCharIsDot = resultValue.NextCharAfterThisExcerpt(monthToAddDot, dot);
        return (monthToAddDot, nextCharIsDot);
    }
​
    private static bool HasMonthFullPortuguese(string resultValue)
    {
        return !string.IsNullOrEmpty(ReturnFirstMatchOf(DocNameHelper.MonthsPortugueseFull, resultValue));
    }
​
    private static bool IsCulturePortuguese(string cultureInfo) => string.Equals(cultureInfo, "pt-BR", StringComparison.Ordinal);
​
    private static string ReturnFirstMatchOf(List<string> sequence, string textToLookupItemToMatch)
    {
        var match = string.Empty;
        foreach (var item in sequence.Where(item => textToLookupItemToMatch.ToLower().Contains(item)))
        {
            match = item;
            break;
        }
        return match;
    }
​
    internal static bool HasAbbreviatedMonth(string dateToTest, string cultureInfo)
    {
        if (HasFullMonth(dateToTest, cultureInfo))
            return false;
        //do not forget to test for the FULL month name before testing for the abbreviated
        var months = cultureInfo == "pt-BR" ? DocNameHelper.MonthsPortugueseAbbreviated : DocNameHelper.MonthsEnglishAbbreviated;
        return months.Any(month => dateToTest.ToLower().Contains(month));
    }
    internal static bool HasFullMonth(string dateToTest, string cultureInfo)
    {
        var months = cultureInfo == "pt-BR" ? DocNameHelper.MonthsPortugueseFull : DocNameHelper.MonthsEnglishFull;
        return months.Any(month => dateToTest.ToLower().Contains(month));
    }
    //internal static bool HasAbbreviatedMonth(string dateToTest, string cultureInfo)
    //{
    //    if (HasFullMonth(dateToTest, cultureInfo)) return false;
    //    var months = cultureInfo == "pt-BR" ? DocNameHelper.MonthsPortugueseAbbreviatedDictionary : DocNameHelper.MonthsEnglishAbbreviatedDictionary;
    //    return (months.ContainsKey(dateToTest.ToLower()));
    //}
    //internal static bool HasFullMonth(string dateToTest, string cultureInfo)
    //{
    //    var months = cultureInfo == "pt-BR" ? DocNameHelper.MonthsPortugueseFullDictionary : DocNameHelper.MonthsEnglishFullDictionary;
    //    return (months.ContainsKey(dateToTest.ToLower()));
    //}
    #endregion Private Methods
​
    #region Overrides of ValueObject
    protected override IEnumerable<IComparable> GetEqualityComponents()
    {
        yield return DateText;
        yield return DateAndTime;
        yield return Mask;
        yield return CertaintyAbout;
        yield return _cultureInfo;
    }
​
    #endregion
    #region Overrides of Object
    public override string ToString()
    {
        return $"{nameof(DateText)}: {DateText}, {nameof(DateAndTime)}: {DateAndTime.ToString(new CultureInfo(_cultureInfo))}, {nameof(Mask)}: {Mask.GetDescription()}, {nameof(CertaintyAbout)}: {CertaintyAbout}";
    }
    #endregion
}
//################################################################################### DateInSentence   End ##########################################################################################
//################################################################################### IntervalInSentence ##########################################################################################
public enum IntervalType
{
    NormalRange = 0, //"de 1203 até 20041999"
    TemporalClue, //"em 082021"
    RangeOnlyWithNoTemporalClue // "por 100 dias" || "em 2 meses"
}
public class IntervalInSentence : BaseElement// ValueObject
{
​
    #region Private Fields
    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 Fields
​
    #region Public Constants
​
    #endregion Public Constants
​
    #region Public Fields
    public bool HasInterval => ElementValue.IsSuccess;
    public IntervalType IntervalType { 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 CertaintyAboutElement CertaintyAboutDateBegin => DateBegin?.CertaintyAbout ?? CertaintyAboutElement.NonExisting;
    public CertaintyAboutElement CertaintyAboutDateEnd => DateEnd?.CertaintyAbout ?? CertaintyAboutElement.NonExisting;
    public bool DateBeginHadToGoBackOneYear { get; private set; }
    public int MaxPossibleYear { get; set; }
    public int MinPossibleYear { get; 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", int.MinValue, int.MaxValue);
            nullInterval.ElementValue = Result.Failure<string>(nullInterval._errorMsg);
            return nullInterval;
        }
    }
    //[JsonConstructor]
    private IntervalInSentence()
    {
​
    }
    private IntervalInSentence(string originalText, CultureInfo cultureInfo, bool sameFrameIntervalIsAllowed, bool forceBeginDatePreviousYearIfReasonable, string errorMsg, int maxPossibleYear, int minPossibleYear)
    {
        MaxPossibleYear = maxPossibleYear;
        MinPossibleYear = minPossibleYear;
        _cultureInfo = cultureInfo.Name;
        _sameFrameIntervalIsAllowed = sameFrameIntervalIsAllowed;
        _forceBeginDatePreviousYearIfReasonable = forceBeginDatePreviousYearIfReasonable;
        _errorMsg = errorMsg;
        OriginalText = originalText;
    }
​
    internal static IntervalInSentence CreateInstance(string interval, CultureInfo cultureInfo, int maxPossibleYear = int.MaxValue, int minPossibleYear = 1990, 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, maxPossibleYear, minPossibleYear);
        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(DocNameHelper.ForGrabDateIntervalFromPartOfFile.Value, partToTest, "interval",
            _errorMsg);
        if (hasInterval.IsSuccess)
        {
            ElementValue = hasInterval;
            _candidateBegin = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDateIntervalFromPartOfFile.Value, partToTest, "datebegin", _errorMsg);
            _candidateEnd = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDateIntervalFromPartOfFile.Value, partToTest, "dateend", _errorMsg);
            if (_candidateBegin.IsFailure || _candidateEnd.IsFailure) return false;
            var intervalDates = TryCompareIntervalDates(_candidateBegin.Value, _candidateEnd.Value);
            if (intervalDates.dateBegin.IsFailure && intervalDates.dateEnd.IsFailure) return false;
            DateBegin = intervalDates.dateBegin.Value;
            DateEnd = intervalDates.dateEnd.Value;
            TextTemporalRelation = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDateIntervalFromPartOfFile.Value, partToTest, "starting", _errorMsg).Value;
            TextBetween = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDateIntervalFromPartOfFile.Value, partToTest, "link", _errorMsg).Value;
            IntervalType = IntervalType.NormalRange;
            TimeFrame = string.Empty;
            return true; //return IsIntervalValid(partToTest); //? hasInterval : Result.Failure<string>(errorMsg);
        }
        if (hasInterval.IsFailure)
        {
            //var match = DocNameHelper.GetMatch(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "relationandinterval", _errorMsg, out var result);
            //Below cut around 100 ms
            var match = DocNameHelper.GetMatch(DocNameHelper.ForGrabDatesWithMonthsInLettersOrPureNumbersFromFile.Value, partToTest, "relationandinterval", _errorMsg, out var result);
            hasInterval = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDatesWithMonthsInLettersOrPureNumbersFromFile.Value, partToTest, "intervalordate", _errorMsg);
            if (result.Equals(hasInterval))
            {
                ElementValue = Result.Failure<string>(_errorMsg);
                return false;// Result.Failure<string>(errorMsg);
            }
            ElementValue = result;
            IntervalType = IntervalType.TemporalClue; // "em 08/2021"
            // TODO: decide if is IntervalType.TemporalClue OR is IntervalType.RangeOnlyWithNoTemporalClue // "por 100 dias" || "em 2 meses"
            _candidateBegin = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDatesWithMonthsInLettersOrPureNumbersFromFile.Value, partToTest, "intervalordate", _errorMsg);
            _candidateEnd = _candidateBegin;
            if (_candidateBegin.IsFailure) return false;
            TextTemporalRelation = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDatesWithMonthsInLettersOrPureNumbersFromFile.Value, partToTest, "temporalrelation", _errorMsg).Value;
            TextBetween = string.Empty;
            TimeFrame = DocNameHelper.ReturnResult(DocNameHelper.ForGrabDatesWithMonthsInLettersOrPureNumbersFromFile.Value, partToTest, "timeframe", _errorMsg).Value;
            DateBegin = DateInSentence.CreateInstanceProvidingAllCorrectElements(_candidateBegin.Value, DateTime.MinValue, DetermineTimeFrameType(result.Value), _cultureInfo);
        }
        //if (_candidateBegin.IsFailure || _candidateEnd.IsFailure)
        //TextTemporalRelation = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "starting", _errorMsg).Value;
        //TextBetween = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "link", _errorMsg).Value;
        return _candidateBegin.IsSuccess && _candidateEnd.IsSuccess;
    }
    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.CreateInstanceProvidingAllCorrectElements(dateBegin, validDates.dateStarted, format, _cultureInfo))
                                    , Result.Success(DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEnd, validDates.dateEnded, format, _cultureInfo)));
                        }
                    }
                    break;
                case 8: //ddMMyyyy
                        //BUG if I allow date to be yyyyMMdd in interval, it will not be parsed at all
                    var formatEnd = IsDDMM
                        ? DateFormat.ddMMyyyy
                        : DateFormat.MMddyyyy;
                    var dateEndIsyyyyMMdd = false;
                    var dateEndIsDDMM = DateTime.TryParseExact(dateEnd, formatEnd.GetDescription(),
                                                               new CultureInfo(_cultureInfo), DateTimeStyles.None, out var dateEnded);
                    if (dateEnded == DateTime.MinValue)
                    {
                        formatEnd = DateFormat.yyyyMMdd;
                        dateEndIsyyyyMMdd = DateTime.TryParseExact(dateEnd, formatEnd.GetDescription(),
                            new CultureInfo(_cultureInfo), DateTimeStyles.None, out dateEnded);
                    }
                    if (dateEnded == DateTime.MinValue) return (Result.Failure<DateInSentence>(errorMsg), Result.Failure<DateInSentence>(errorMsg));
​
                    if (dateEnded > DateTime.MinValue)
                    {
                        switch (dateBegin.Length)
                        {
                            case 8 when !dateEndIsyyyyMMdd://ddMMyyyy
                                {
                                    var beginDDMMDateIsInPreviousYear = CompareDatesWithSameFormat(dateBegin, dateEnd,
                                        out var format, out var validDates);
                                    if (beginDDMMDateIsInPreviousYear)
                                    {
                                        return (Result.Success(
                                                DateInSentence.CreateInstanceProvidingAllCorrectElements(dateBegin,
                                                    validDates.dateStarted, format, _cultureInfo))
                                            , Result.Success(DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEnd, validDates.dateEnded, format, _cultureInfo)));
                                    }
​
                                    break;
                                }
                            case 8 when dateEndIsyyyyMMdd://ddMMyyyy
                                {
                                    var beginDDMMDateIsInPreviousYear = CompareDatesWithSameFormat(dateBegin, dateEnd,
                                        out var format, out var validDates);
                                    if (beginDDMMDateIsInPreviousYear)
                                    {
                                        return (Result.Success(
                                                DateInSentence.CreateInstanceProvidingAllCorrectElements(dateBegin,
                                                    validDates.dateStarted, format, _cultureInfo))
                                            , Result.Success(DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEnd, validDates.dateEnded, format, _cultureInfo)));
                                    }
​
                                    break;
                                }
                            case 6 when !dateEndIsyyyyMMdd://almost impossible MMyyyy
#if DEBUG
                                throw new NotImplementedException("I did not implemented 'de MMyyyy até ddMMyyyy'");
#endif
                                break;
                            case 6 when dateEndIsyyyyMMdd://almost impossible yyyyMM
#if DEBUG
                                throw new NotImplementedException("I did not implemented 'de yyyyMM até yyyyMMdd'");
#endif
                                break;
                            case 4 when !dateEndIsyyyyMMdd://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.CreateInstanceProvidingAllCorrectElements(dateBegin,
                                                ddMMBegin, formatBegin, _cultureInfo)),
                                            Result.Success(DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEnd,
                                                dateEnded, formatEnd, _cultureInfo))
                                        );
                                    }
​
                                    break;
                                }
                            case 2 when !dateEndIsyyyyMMdd://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.CreateInstanceProvidingAllCorrectElements(dateBegin,
                                                new DateTime(dateEnded.Year, dateEnded.Month, dayBegin), DateFormat.dd,
                                                _cultureInfo));
                                        return (dayInterval,
                                                Result.Success(DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEnd,
                                                    dateEnded, formatEnd, _cultureInfo))
                                            );
                                    }
​
                                    errorMsg = "because BeginDate is After EndDate";
                                    break;
                                }
                        }
                    }
                    else //test DateEnd for yyyyMMdd
                    {
​
​
                    }
​
                    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.CreateInstanceProvidingAllCorrectElements(dateBegin, ddMMBegin, formatEnd, _cultureInfo)),
                                    Result.Success(DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEnd, dateEnded, formatEnd, _cultureInfo))
                                   );
                        }
                        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, _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;
​
            }
​
        }
        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, _cultureInfo, MaxPossibleYear, 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,
       bool sameFrameIntervalIsAllowed = false)
    {
        var (isDateEndDubious, isDateBeginDubious, certaintyAboutYYYY) = DecideDegreeOfCertaintyAboutDates(dateBeginToTest, dateEndToTest);
        var dateBeginTry = DateInSentence.CreateInstance(dateBeginToTest, _cultureInfo, MaxPossibleYear, 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, 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, _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.CreateInstanceProvidingAllCorrectElements(dateBeginToTest, dateStarted, DateFormat.yyyy, _cultureInfo, certaintyAboutYYYY);
            dateEnd = DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEndToTest, dateEnded, DateFormat.yyyy, _cultureInfo, certaintyAboutYYYY);
        }
        else if (dateBeginIsDDMM)
        {
            if (!dateEndIsDDMM || !IsDDMMBeginDateReallyBeforeEndDate(dateBeginToTest, dateEndToTest, formatForDateBeginTry, sameFrameIntervalIsAllowed)) return (dateBegin, dateEnd);
            dateBegin = DateInSentence.CreateInstanceProvidingAllCorrectElements(dateBeginToTest, dateStarted, formatForDateBeginTry, _cultureInfo, certaintyAboutYYYY);
            dateEnd = DateInSentence.CreateInstanceProvidingAllCorrectElements(dateEndToTest, dateEnded, formatForDateBeginTry, _cultureInfo, 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);
    }
    #endregion Private Methods
​
    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;
    }
    #region Draft
    private bool IsIntervalValid(string partToTest)
    {
        var validBeginInterval =
            DocNameHelper.DateTryParseExact(_candidateBegin.Value, out var beginInterval, new CultureInfo(_cultureInfo));
        var validEndInterval =
            DocNameHelper.DateTryParseExact(_candidateEnd.Value, out var endInterval, new CultureInfo(_cultureInfo));
        var isValid = beginInterval < endInterval;
        return isValid;
    }
    #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 OriginalText;
        yield return DateBeginHadToGoBackOneYear;
        yield return TextBetween;
        yield return TextTemporalRelation;
        yield return TimeFrame;
        yield return DateBegin;
        yield return DateEnd;
    }
​
    #endregion
    #region Overrides of Object
    public override string ToString()
    {
        return @$"{nameof(IntervalType)}: {IntervalType}
                , {nameof(TextTemporalRelation)}: {TextTemporalRelation}
                , {nameof(TextBetween)}: {TextBetween}
                , {nameof(TimeFrame)}: {TimeFrame}
                , {nameof(DateBegin)}: {DateBegin}
                , {nameof(CertaintyAboutDateBegin)}: {CertaintyAboutDateBegin}
                , {nameof(DateEnd)}: {DateEnd}
                , {nameof(CertaintyAboutDateEnd)}: {CertaintyAboutDateEnd}
                , {nameof(DateBeginHadToGoBackOneYear)}: {DateBeginHadToGoBackOneYear}
                , {nameof(MaxPossibleYear)}: {MaxPossibleYear}, {nameof(MinPossibleYear)}: {MinPossibleYear}";
    }
    #endregion Overrides of Object
}
//################################################################################### IntervalInSentence End ##########################################################################################
//################################################################################### BaseElement  ##########################################################################################
    public class BaseElement : ValueObject
    {
        private string _textValue => ElementValue.IsSuccess ? ElementValue.Value : "No value";
        public int StartIndex { get; set; }
        public int EndIndex
        {
            get
            {
                if (ElementValue.IsFailure) 
                    return StartIndex;
                return StartIndex + ElementValue.Value.Length;
            }
​
        }
        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");
​
        public static void CopyContextProperly(BaseElement tryDate, int oldIndex, string connector)
        {
            tryDate.StartIndex = oldIndex;
            tryDate.ConnectorBefore = connector;
        }
​
        #region Overrides of ValueObject
​
        protected override IEnumerable<IComparable> GetEqualityComponents()
        {
            yield return StartIndex;
            yield return ConnectorBefore;
            yield return OriginalText;
            yield return _textValue;//ElementValue;
        }
​
        #endregion
    }
//################################################################################### BaseElement  End ##########################################################################################
//################################################################################### Enums ##########################################################################################                                
    //https://stackoverflow.com/questions/3025361/c-sharp-datetime-to-yyyymmddhhmmss-format
    //https://learn.microsoft.com/en-us/dotnet/standard/base-types/custom-date-and-time-format-strings?redirectedfrom=MSDN
public enum DateFormat
{
    Unknown = -99,
    [Description("ano(s)")]
    NumYears = -4,
    [Description("mês/meses")]
    NumMonths = -3,
    [Description("dia(s)")]
    NumDays = -2,
    //Above is for RangeOnlyWithNoTemporalClue only 
    NoDate = -1,
    
    yyyy = 0,
    MMyyyy,
    [Description("MMM.yy")]
    MMMdotIncorrectTwoDigitsYear,
    MMMyyyy,
    [Description("MMM.yyyy")]
    MMMdotyyyy,
    MMMMyyyy,
    [Description("MMMM_yyyy")]
    MMMMyyyyIncorrectFormattedWithWildcard,
    [Description("MMMM.yyyy")]
    MMMMyyyyIncorrectFormattedWithDot,
    [Description("MMMM yyyy")]
    MMMMyyyyWithSpace,
​
    [Description("MMMyy")]
    MMMyyIncorrectTwoDigitsYear,
    //[Description("MMM.yy")]
    //MMMyyIncorrectTwoDigitsYearAndFormattedWithDot,
​
    MMdd,
    MMMdd,
    MMMMdd,
    MMddyyyy,
    MMMddyyyy,
    MMMMddyyyy,
​
    ddMM,
    ddMMM,
    ddMMMM,
    ddMMyyyy,
    ddMMMyyyy,
    ddMMMMyyyy,
​
    dd,
    MM,
    MMM,
    MMMM,
​
    yyyyMM,
    yyyyMMM,
    yyyyMMMM,
    yyyyMMdd,
    [Description("yyyyMMddHHmmss")]
    sortable,
    [Description("dd/MM/yyyy HH:mm:ss")]
    completeUpToSeconds,
    [Description("MM/dd/yyyy HH:mm:ss")]
    completeUpToSecondsUS,
    [Description("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'")]
    universalSortable,
    [Description("yyyy_MMM_dd__HH_mm_ss")]
    personalizedForAnotaçãoOutlookBackup,
    [Description("yyyy_MMM._dd__HH_mm_ss")]
    personalizedForAnotaçãoOutlookBackupWithDot,
    [Description("dd_MM_yyyy")]
    FullDateIncorrectFormattedWithWildcardBR,
    [Description("MM_dd_yyyy")]
    FullDateIncorrectFormattedWithWildcardUS,
    [Description("dd.MM.yyyy")]
    FullDateIncorrectFormattedWithDotBR,
    [Description("MM.dd.yyyy")]
    FullDateIncorrectFormattedWithDotUS,
    [Description("dd.MM.yy")]
    FullDateIncorrectTwoDigitsYearAndFormattedWithDotBR,
    [Description("MM.dd.yy")]
    FullDateIncorrectTwoDigitsYearAndFormattedWithDotUS,
​
    [Description("dd_MM")]
    DDMMIncorrectFormattedWithWildcardBR,
    [Description("MM_dd")]
    DDMMIncorrectFormattedWithWildcardUS,
    [Description("dd.MM")]
    DDMMIncorrectFormattedWithDotBR,
    [Description("MM.dd")]
    DDMMIncorrectFormattedWithDotUS,
    [Description("dd.M")]
    DDMIncorrectFormattedWithDotBR,
    [Description("M.dd")]
    DDMIncorrectFormattedWithDotUS
}
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,
        SimplePart,
        WhicheverVersion,
        VersionNumberOnly,
        VersionWithPrefix,
        FileNameDate,
        FileNameInterval,
        GUID,
        DrugNameDose
    }
//################################################################################### Enums End ##########################################################################################  
​
    // 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
//################################################################################### DocNameHelper ##########################################################################################
public static class DocNameHelper
{
    #region private constants
    /// <summary>
    /// Should check for equality between relationandinterval and intervalordate; if so, the interval is invalid and should be ignored
    /// </summary>
    private 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]{1}\b))(?<timeframe> anos[ .]{0,1}| ano[ .]{0,1}| meses[ .]{0,1}| mês[ .]{0,1}| dias[ .]{0,1}| dia[ .]{0,1})?)";
    ////https://regex101.com/r/ZuUZy3/16^^^^^^^^^^^^
    //private 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]{1}\b))(?<timeframe> anos[ .]{0,1}| ano[ .]{0,1}| mês[ .]{0,1}| meses[ .]{0,1}| dias[ .]{0,1}| dia[ .]{0,1})?)";
    ////https://regex101.com/r/ZuUZy3/14^^^^^^^^^^^^
    //private 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 ^^^^^^ 
    private const string GrabDatesOrPureNumbersOrDatesWithCardFromPartOfFile = @"(?<date>\d{6,8}|\d{2,3}_{1,2})";
    //https://regex101.com/r/wGCR0g/2 ^^^^^^^^^^^^^^^^^^^^^^^^^^       20__ or 202_  ^^^^^^^^^
    /// <summary>
    /// Some Dates, as from Bronstein, are formatted with WildCardForDate, like Laudo Completo 18_07_2023.pdf
    /// </summary>
    private const string GrabDatesIncorrectFormattedWithInvalidChars = @"(?<![_.]{1})(?<date>\d{2}[_.]{1}\d{2}[_.]{1}(?:\d{4}|\d{2}))"; //(?<date>\d{2}[_.]{1}\d{2}[_.]{1}\d{4})";
                                                                                                                                        //https://regex101.com/r/pCbR7k/3 ^^^^^^^^^^^^^^^^^^^^^^^^^^
    private 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)?)";
    //https://regex101.com/r/DfGFk5/1 ^^^^^^^^^^^^^^^^^^^^^ https://www.utctime.net/ 
    //Use it only to extract from PartOfName
    //private const string GrabDateIntervalFromPartOfFile = @"(?<=\W)(?<interval>(?<starting>[ mçinícandouetr]+?)(?<datebegin>\d+)(?<link>[ eatéfimnldzou]+?)(?<=\W)(?<!\w-)(?<dateend>\d+))";
    ////https://regex101.com/r/1UfbIM/1 ^^^^^^^^^^^^^^^^ 
    private const string GrabDateIntervalFromPartOfFile = @"(?<=\W)(?<interval>(?<starting>[ mçinícandouetr]+?)(?<datebegin>\d{2,8}|\d{14}(?!\d))(?<link>[ eatéfimnldzou]+?)(?<=\W)(?<!\w-)(?<dateend>\d{4,8}|\d{14})(?!\d))";
    //https://regex101.com/r/1UfbIM/3 ^^^^^^^^^^^^^^^^ 
    private 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 ^^^^^^^^^^^^^^^^
    private const string GrabDatePersonalizedForAnotaçãoOutlookBackup = @"backup_(?<date>(?<yyyy>(?:19|20)[0-9]{2})_(?<MMM>[JFMASONDjfmasond]{1}[aeiouAEIOUnNvVrRbBlLgGtTzZpPyYcC]{2})_(?<dd>0[1-9]|[12][0-9]|3[01])__(?<hh>0?[0-9]|[1][0-9]|[2][0-3])_(?<mm>[0-9]{2})_(?<ss>[0-9]{2}))";
    //https://regex101.com/r/KESkRm/5 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    private const string GrabDatePersonalizedForAnotaçãoOutlookBackupWithDotAfterMMM = @"backup_(?<date>(?<yyyy>(?:19|20)[0-9]{2})_(?<MMM>[JFMASONDjfmasond]{1}[aeiouAEIOUnNvVrRbBlLgGtTzZpPyYcC]{2})._(?<dd>0[1-9]|[12][0-9]|3[01])__(?<hh>0?[0-9]|[1][0-9]|[2][0-3])_(?<mm>[0-9]{2})_(?<ss>[0-9]{2}))";
    //https://regex101.com/r/qF6UKF/1 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    private const string GrabAbbreviatedMonthWithTwoOrFourDigitYearWithDotSeparatingThemOrNot = @"(?<date>(?<datewithdot>(?<MMM>jan|fev|feb|mar|abr|apr|mai|may|jun|jul|ago|aug|set|sep|out|oct|nov|dez|dec)\.(?<yyyy>(?:19|20){0,1}[0-9]{2}))|(?<datewithoutdot>(?<MMM>jan|fev|feb|mar|abr|apr|mai|may|jun|jul|ago|aug|set|sep|out|oct|nov|dez|dec)(?<yyyy>(?:19|20){0,1}[0-9]{2})))";
    //https://regex101.com/r/SaKlyS/4 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    private const string GrabFullMonthWithTwoOrFourDigitYearWithSomeCharSeparatingThemOrNot = @"(?<date>(?:(?<datewithsomecharseparating>(?<MMM>janeiro|january|fevereiro|february|março|march|abril|april|maio|may|junho|julho|agosto|august|setembro|september|outubro|october|novembro|november|dezembro|december)[-._ ]{1})|(?<datewithoutseparation>(?<MMM>janeiro|january|fevereiro|february|março|march|abril|april|maio|may|junho|julho|agosto|august|setembro|september|outubro|october|novembro|november|dezembro|december)))(?<yyyy>(?:19|20){0,1}[0-9]{2}))";
    //https://regex101.com/r/01Y8JS/3 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
​
    private const string GrabVersionFromFile = @"(?<version>\sv[ersionão]*[\d@]+[\w@]*|[\d@]+v[ersionão]*[\w@]*)";
    //https://regex101.com/r/BfGfIY/2 ^^^^^^^^^^^^^^^^^^^ 
​
    //Used at DocName:
    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 -.]*)";
​
    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})";
    #endregion private constants
    #region Common
    internal static bool DifficultyToTestPart(string partToTest)
    {
        return (partToTest.Length > 10 && partToTest.DoesNotContainAnySpace());
    }
    //
    /// <summary>
    /// TESTED and it is faster than the overload that accepts string pattern
    /// </summary>
    /// <param name="rgx"></param>
    /// <param name="part"></param>
    /// <param name="groupName"></param>
    /// <param name="errorMsg"></param>
    /// <returns></returns>
    internal static Result<string> ReturnResult(Regex rgx, string part, string groupName, string errorMsg)
    {
        _ = GetMatch(rgx, part, groupName, errorMsg, out var result);
        return result;
    }
    //GetMatch is a poor name...
    //Used in App
    internal static Match GetMatch(Regex rgx, string part, string groupName, string errorMsg, out Result<string> result)
    {
        //Edge case: Laudo Ortopédico afastamento laborativo por 100 dias 24082015.pdf
        //Match 1:
        //Group relationandinterval: por 100 dias
        //Group temporalrelation: por
        //Group intervalordate: 100
        //Group timeframe: dias
        //Match 2:
        //Group relationandinterval: 24082015
        //Group temporalrelation:
        //Group intervalordate: 24082015
        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)
    {
        //set Regex flag to global, do not return after first match
        var rgx = new Regex(pattern, RegexOptions.Multiline);
        //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;
    }
​
    public static readonly Lazy<Regex> ForGrabFakeDelimiterWithoutAnySpaceAround = new(() =>
        new Regex(GrabFakeDelimiterWithoutAnySpaceAround, RegexOptions.Compiled | RegexOptions.IgnoreCase));
    public static readonly Lazy<Regex> ForGrabNameAndExtension = new(() =>
        new Regex(GrabNameAndExtension, RegexOptions.Compiled | RegexOptions.IgnoreCase));
    public static readonly Lazy<Regex> ForGrabDelimiterWithSpaceAround = new(() =>
                   new Regex(GrabDelimiterWithSpaceAround, RegexOptions.Compiled | RegexOptions.IgnoreCase));
    public static readonly Lazy<Regex> ForGrabPartsOfName = new(() =>
                   new Regex(GrabPartsOfName, RegexOptions.Compiled | RegexOptions.IgnoreCase));
    public static readonly Lazy<Regex> ForGrab_GUID_Treated = new(() =>
                new Regex(Grab_GUID_Treated, RegexOptions.Compiled | RegexOptions.IgnoreCase));
    public static List<string> MonthsPortugueseFull =>
        new()
        {
                "janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro", "outubro",
                "novembro", "dezembro"
        };
    //https://stackoverflow.com/questions/2020407/initializing-list-inline
    public static Dictionary<string, string> MonthsPortugueseFullDictionary =>
        MonthsPortugueseFull.ToDictionary(month => month, month => month);
    public static List<string> MonthsPortugueseAbbreviated =>
        new()
        {
                "jan", "fev", "mar", "abr", "mai", "jun", "jul", "ago", "set", "out", "nov", "dez"
        };
    public static Dictionary<string, string> MonthsPortugueseAbbreviatedDictionary =>
        MonthsPortugueseAbbreviated.ToDictionary(month => month, month => month);
    public static List<string> MonthsPortugueseAbbreviatedWithDot =>
        MonthsPortugueseAbbreviated.Select(month => month + ".").ToList();
    public static List<string> MonthsEnglishFull =>
        new()
        {
                "january", "february", "march", "april", "may", "june", "july", "august",
                "september", "october", "november", "december"
        };
    public static Dictionary<string, string> MonthsEnglishFullDictionary =>
        MonthsEnglishFull.ToDictionary(month => month, month => month);
    public static List<string> MonthsEnglishAbbreviated => new()
        {
            "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug",
            "sep", "oct", "nov", "dec"
        };
    public static Dictionary<string, string> MonthsEnglishAbbreviatedDictionary =>
        MonthsEnglishAbbreviated.ToDictionary(month => month, month => month);
    public static bool IsMonthAbbreviationEqualsInPortugueseAndEnglish(string month) =>
        MonthsEnglishAbbreviated.FirstOrDefault(m => m == month) == MonthsPortugueseAbbreviated.FirstOrDefault(m => m == month);
    #endregion Common
​
    #region Interval and Date
    //public static bool DateMaskProvideYYYY (this DateInSentence thisDate) => thisDate.Mask.GetDescription().Contains("yyyy");
    //public static bool DateYearHasWildCard (this DateInSentence thisDate) => thisDate.DateAndTime == DateTime.MaxValue;
    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[] { "" };
    //                              ^^^^^^^^^^^^^^^^^^^^^^^^^^ ??
    public static readonly Lazy<Regex> ForGrabDatesWithMonthsInLettersOrPureNumbersFromFile = new(() =>
        new Regex(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, RegexOptions.Compiled | RegexOptions.IgnoreCase));
    public static readonly Lazy<Regex> ForGrabDatesUTC = new(() =>
        new Regex(GrabDatesUTC, RegexOptions.Compiled | RegexOptions.IgnoreCase));
    public static readonly Lazy<Regex> ForGrabDatePersonalizedForAnotaçãoOutlookBackup = new(() =>
        new Regex(GrabDatePersonalizedForAnotaçãoOutlookBackup, RegexOptions.Compiled | RegexOptions.IgnoreCase));
    public static readonly Lazy<Regex> ForGrabDatePersonalizedForAnotaçãoOutlookBackupWithDotAfterMMM = new(() =>
        new Regex(GrabDatePersonalizedForAnotaçãoOutlookBackupWithDotAfterMMM, RegexOptions.Compiled | RegexOptions.IgnoreCase));
    public static readonly Lazy<Regex> ForGrabDatesIncorrectFormattedWithInvalidChars = new(() =>
        new Regex(GrabDatesIncorrectFormattedWithInvalidChars, RegexOptions.Compiled | RegexOptions.IgnoreCase));
    public static readonly Lazy<Regex> ForGrabDatesOrPureNumbersOrDatesWithCardFromPartOfFile = new(() =>
        new Regex(GrabDatesOrPureNumbersOrDatesWithCardFromPartOfFile, RegexOptions.Compiled | RegexOptions.IgnoreCase));
    public static readonly Lazy<Regex> ForGrabDateIntervalFromPartOfFile = new(() =>
        new Regex(GrabDateIntervalFromPartOfFile, RegexOptions.Compiled));// | RegexOptions.IgnoreCase));
    public static readonly Lazy<Regex> ForGrabAbbreviatedMonthWithTwoOrFourDigitYearWithDotSeparatingThemOrNot = new(() =>
        new Regex(GrabAbbreviatedMonthWithTwoOrFourDigitYearWithDotSeparatingThemOrNot, RegexOptions.Compiled | RegexOptions.IgnoreCase));
    public static readonly Lazy<Regex> ForGrabFullMonthWithTwoOrFourDigitYearWithSomeCharSeparatingThemOrNot = new(() =>
        new Regex(GrabFullMonthWithTwoOrFourDigitYearWithSomeCharSeparatingThemOrNot, RegexOptions.Compiled | RegexOptions.IgnoreCase));
​
    #endregion Interval and Date                                                                        
​
    #region Version
    public static readonly Lazy<Regex> ForGrabVersionFromFile = new(() =>
        new Regex(GrabVersionFromFile, RegexOptions.Compiled | RegexOptions.IgnoreCase));
    #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));
        if (dateWithoutSpace.DoesNotContainAnyNumbers()) { testDate = DateTime.MinValue; return false; }
        var yyyy = forceDDMM ? "dummyformat" : DateFormat.yyyy.GetDescription();
        // BEWARE!!! if you try to capture yyyy with empty format, it will give error when inside string[] dateFormats
        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();
        //https://stackoverflow.com/questions/13796917/datetime-tryparseexact-and-different-separators
        string[] dateFormatsLength4AndOnlyDigits = { yyyy, ddMM };
        string[] dateFormatsLength5 = { ddMMM };
        string[] dateFormatsLength6AndOnlyDigits = { DateFormat.MMyyyy.GetDescription() };
        string[] dateFormatsLength7 = { DateFormat.MMMyyyy.GetDescription() };
        string[] dateFormatsLength8AndOnlyDigits = { ddMMyyyy };
        string[] dateFormatsLength9 = { ddMMMyyyy };
        string[] dateFormatsLength14AndOnlyDigits = { DateFormat.sortable.GetDescription() };
        //string[] dateFormatsLengthMoreThen10 =
        //{
        //    ddMMyyyyHHmmssWithSlash, DateFormat.universalSortable.GetDescription(),
        //    ddMMMM, ddMMMMyyyy, DateFormat.MMMMyyyy.GetDescription(),
        //    //DateFormat.personalizedForAnotaçãoOutlookBackup.GetDescription(),
        //    //DateFormat.personalizedForAnotaçãoOutlookBackupWithDot.GetDescription(),
        //};
        //string[] dateFormatsForAnotaçãoOutlookBackup =
        //{
        //    DateFormat.personalizedForAnotaçãoOutlookBackup.GetDescription(),
        //    DateFormat.personalizedForAnotaçãoOutlookBackupWithDot.GetDescription(),
        //};
        string[] dateFormatsLengthMoreThen10 =
        {
                ddMMyyyyHHmmssWithSlash, DateFormat.universalSortable.GetDescription(),
                ddMMMM, ddMMMMyyyy, DateFormat.MMMMyyyy.GetDescription(),
                DateFormat.personalizedForAnotaçãoOutlookBackup.GetDescription(),
                DateFormat.personalizedForAnotaçãoOutlookBackupWithDot.GetDescription(),
            };
        string[] dateFormatsAll;
        if (dateWithoutSpace.StringHasOnlyNumbers())
        {
            dateFormatsAll = dateWithoutSpace.Length switch
            {
                4 => dateFormatsLength4AndOnlyDigits,
                6 => dateFormatsLength6AndOnlyDigits,
                8 => dateFormatsLength8AndOnlyDigits,
                14 => dateFormatsLength14AndOnlyDigits,
                _ => new[] { "UnforeseenCase" }
            };
        }
        else
        {
​
            dateFormatsAll = dateWithoutSpace.Length switch
            {
                5 => dateFormatsLength5,
                7 => dateFormatsLength7,
                9 => dateFormatsLength9,
                _ => dateFormatsLengthMoreThen10
                //Below add 100 ms to the test GenerateListOfCurrent_New_ChangedFiles
                //  "                                   "       TryParseExact       TryParse    
                //  "                                   "   "       "   Max Avg     Max Avg
                //  All "                                           "   847 38      281 10
                //  All "                                           "   751 27      312 9
                //  All "                                           "   777 32      232 9
                //  "                                   "   "       "                   
                //  dateFormatsLength4AndOnlyDigits "               "   777 89      232 27
                //  dateFormatsLength6AndOnlyDigits "               "   777 307     232 102
                //  dateFormatsLength8AndOnlyDigits "               "   777 48      232 15
                //  dateFormatsLength14AndOnlyDigits    "           "   777 196     232 65
                //  UnforeseenCase  "                               "   777 310     232 129
                //  
                //  dateFormatsLength5  "                           "   15  3       15  3
                //  dateFormatsLength7  "                           "   421 196     139 69
                //  dateFormatsLength9  "                           "   155 155     139 139
                //  dateFormatsLengthMoreThen10 "                   "   777 37      32  11
                //  
                //  With:
                //  GetProperFormatFor10OrMore              "       "   1001 41     188 9
                //  All "                                           "   857 33      157 6
                //  All "                                           "   862 33      205 8
                //  All "                                           "   1001 34     108 7
                //_ => GetProperFormatFor10OrMore(dateWithoutSpace, dateFormatsLengthMoreThen10, dateFormatsForAnotaçãoOutlookBackup)
            };
        }
        //TODO need to change strategy if time is in UTC or not
        //DateTimeStyles.AdjustToUniversal
        //TODO: see if filter mask by length turn it faster, because less formats to try
        var tryDate = DateTime.TryParseExact(dateWithoutSpace, dateFormatsAll, cultureInfo, DateTimeStyles.AssumeLocal, out testDate);
        return tryDate || DateTime.TryParse(dateWithoutSpace, cultureInfo, DateTimeStyles.None, 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"
    }
​
    private static string[] GetProperFormatFor10OrMore(string dateWithoutSpace, string[] dateFormatsLengthMoreThen10, string[] dateFormatsForAnotaçãoOutlookBackup)
    {
        return dateWithoutSpace.CountOccurrences("_") == 6 ? dateFormatsForAnotaçãoOutlookBackup : dateFormatsLengthMoreThen10;
    }
​
    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 End ##########################################################################################                                                
public class TypeOfDoc
{
    //[JsonConstructor]
    public TypeOfDoc(
        string displayName,
        List<string> wordsThatPointsToType
    )
    {
        this.DisplayName = displayName;
        this.WordsThatPointsToType = wordsThatPointsToType;
    }
​
    public string DisplayName { get; set; }
    public IEnumerable<string> WordsThatPointsToType { get; set; }
}   
//################################################################################### MessageDialogService ##########################################################################################
public interface IMessageDialogService
{
    MessageDialogResult ShowOkCancelDialog(string text, string title,
      MessageDialogResult defaultResult = MessageDialogResult.Ok);
    MessageDialogResult ShowYesNoDialog(string text, string title,
        MessageDialogResult defaultResult = MessageDialogResult.Yes);
    void ShowInfoDialog(string text, string title = "Info");
}
​
public enum MessageDialogResult
{
    Ok, //Mapped to Yes
    Cancel, //Mapped to No
    Yes,
    No
}
                          
    /// <summary>
    /// For automated tasks like serialization
    /// </summary>
    public class MessageDialogServiceNone : IMessageDialogService
    {
        #region Implementation of IMessageDialogService
​
        public MessageDialogResult ShowOkCancelDialog(string text, string title,
            MessageDialogResult defaultResult = MessageDialogResult.Ok)
        {
            return defaultResult;
        }
​
        public MessageDialogResult ShowYesNoDialog(string text, string title,
            MessageDialogResult defaultResult = MessageDialogResult.Yes)
        {
            return defaultResult;
        }
​
        public void ShowInfoDialog(string text, string title = "Info")
        {
            //do nothing;
        }
​
        #endregion
    }           
//################################################################################### MessageDialogService End ##########################################################################################                         
//################################################################################### WrappedCollection ##########################################################################################
public class WrappedCollection<T> : IList<T>
{
    private readonly IList<T> _list = new List<T>();
​
    public WrappedCollection(IList<T> wrappedCollection)
    {
        if (wrappedCollection == null)
        {
            throw new ArgumentNullException("wrappedCollection");
        }
        this._list = 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
    {
        get { return _list.Count; }
    }
​
    public bool IsReadOnly
    {
        get { return _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 { return _list[index]; }
        set { _list[index] = value; }
    }
​
    #endregion
​
    #region Your Added Stuff
​
    // Add new features to your collection.
​
    #endregion
}                         
//################################################################################### WrappedCollection End ##################################################################################
​
//################################################################################### MyExtensions ##########################################################################################                         
​
//################################################################################### MyExtensions End ##########################################################################################
// ###################            ##################################      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;
    {
        if (CultureInfo.CurrentCulture.Name.ToString() == "pt-BR")
            return Convert.ToDateTime("01/04/1601 00:00:00"); // ApplicationServices.OutlookDefaultDateForInvalid;
        return Convert.ToDateTime("04/01/1601 00:00:00");
    }
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)
    {
        string txtBefore = null;
        try
        {
            txtBefore = text.GetUntilOrEmpty(beforeThis);
            return txtBefore.Length > 0 ? text.GetUntilOrEmpty(beforeThis).Substring(txtBefore.Length - numberOfChars) : string.Empty;
        }
        catch (Exception ex)
        {
            //Console.WriteLine(ex.Message);
            Console.WriteLine($"GetNumberOfCharsJustBeforeSubstring error {ex.Message}: tried to subtract {txtBefore.Length} – { numberOfChars }");
            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 SubstituteSubstringAtSpecificPositionForAnother(this string text,
        string substringToReplace, string replacement, int position)
    {
        //https://stackoverflow.com/questions/8809354/replace-a-character-at-a-specific-index-in-a-string
        var sb = new StringBuilder(text);
        sb.Remove(position, substringToReplace.Length).Insert(position, replacement);
        return sb.ToString();
    }
    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 bool NextCharAfterThisExcerpt(this string text, string uniqueExcerpt, char dot)
    {
        return text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length < text.Length &&
               text[text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length] == dot;
    }
    //TODO test it
    public static bool NextCharAfterThisExcerpt(this string text, string uniqueExcerpt, char[] chars)
    {
        return text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length < text.Length &&
               chars.Contains(text[text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length]);
    }
    public static string AddSubstringAfterThisFoundExcerpt(this string text, string uniqueExcerpt, string toAdd)
    {
        return text.ToLower().Replace(uniqueExcerpt, uniqueExcerpt + toAdd);
    }
​
    public static string RemoveSubstringAfterThisFoundExcerpt(this string text, string uniqueExcerpt,
        string toRemove)
    {
        return text.ToLower().Replace(uniqueExcerpt + toRemove, uniqueExcerpt);
    }
    public static string AddSubstringAfterThisFirstFoundExcerpt(this string text, string uniqueExcerpt, string toAdd)
    {
        var index = text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal);
        if (index < 0) return text;
        var firstPart = text.Substring(0, index);
        var secondPart = text.Substring(index + uniqueExcerpt.Length);
        return firstPart + uniqueExcerpt + toAdd + secondPart;
    }
    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;
    }
    public static int CountOccurrences(this string text, string pattern)
    {
        //https://stackoverflow.com/questions/541954/how-would-you-count-occurrences-of-a-string-within-a-string-c
        return (text.Length - text.Replace(pattern, "").Length) / pattern.Length;
    }
    /// <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);
    public static bool DoesNotContainAnyNumbers(this string @this) => @this.ReturnOnlyNumbers().Length == 0;
    public static bool StringHasOnlyNumbers(this string @this) => @this.ReturnOnlyNumbers().Length == @this.Length;
    //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);
    //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');
    public static bool ContainsOnlyDigitsAndThisSubstring(this string @this, string substring)
    {
        var resultOk = @this.Contains(substring);
        if (!resultOk) return false;
        @this = @this.Replace(substring, string.Empty);
        return @this.IsDigit();
    }   
    /// <summary>
    /// inHexadecimal = false : returns a decimal hash code
    /// </summary>
    /// <param name="input"></param>
    /// <param name="hashSize"></param>
    /// <param name="inHexadecimal"></param>
    /// <returns></returns>
​
    public static string ReturnParentFolder(this string pathSource)
    {
        //https://stackoverflow.com/a/30902714/2752308
        return Path.GetFullPath(Path.Combine(pathSource, @"..\"));
    }
    /// <summary>
    /// Extension to use with Root path, adding distal path as argument
    /// </summary>
    /// <param name="pathWithRoot"></param>
    /// <param name="pathDistal"></param>
    /// <returns></returns>
    public static string CombinePaths(this string pathWithRoot, string pathDistal)
    {
        var networkFolder = !pathWithRoot.Contains(":");
        var pathOne = pathWithRoot.Split(@"\".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
        var pathTwo = pathDistal.Split(@"\".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
        var pathFinal = pathOne.Concat(pathTwo);
        var preFinalPath = Path.Combine(pathFinal.ToArray());
        if (networkFolder)
            return "\\\\" + preFinalPath;
        return preFinalPath.Contains(":\\") ? preFinalPath : preFinalPath.Replace(":", ":\\");
    }
}
// ###################            ##################################      StringTextExtensions      ##################################            ###################
// ###################            ##################################      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 End     ##################################            ###################
// ###################            ##################################      Guard      ##################################            ###################
public class Guard //https://stackoverflow.com/a/64768572/2752308
    {
        /// <summary>
        /// It will scan all Properties of Class, and will Throw if any are not initialized
        /// </summary>
        /// <param name="param"></param>
        /// <exception cref="ArgumentNullException"></exception>
        public static void ThrowIfNull(object param)
        {
            var props = param.GetType().GetProperties();
            foreach (var prop in props)
            {
                var name = prop.Name;
                var val = prop.GetValue(param, null);
​
                _ = val ?? throw new ArgumentNullException(name);
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="argumentValue"></param>
        /// <param name="argumentName">Call it with nameof()</param>
        /// <exception cref="ArgumentNullException"></exception>
        public static void ThrowIfNull(object argumentValue, string argumentName)
        {
            if (argumentValue == null)
            {
                throw new ArgumentNullException(argumentName);
            }
        }
​
        /// <summary>
        /// As name is telling, throws:
        /// ArgumentNullException
        /// ArgumentOutOfRangeException for string.Empty
        /// ArgumentException if it is not string
        /// </summary>
        /// <param name="argumentValue"></param>
        /// <param name="argumentName"></param>
        public static void ThrowIfStringNullOrEmptyOrNotString(object argumentValue, string argumentName)
        {
            // Working:
            //if (argumentValue == null)
            //    throw new ArgumentNullException(argumentName);
            ////if (argumentValue is string && ((string)argumentValue).Length == 0)
            //if (argumentValue is string { Length: 0 })
            //    throw new ArgumentOutOfRangeException(argumentName);
            //if (argumentValue is not string) 
            //    throw new ArgumentException(argumentName);
​
            switch (argumentValue)
            {
                case null:
                    throw new ArgumentNullException(argumentName);
                //if (argumentValue is string && ((string)argumentValue).Length == 0)
                case string { Length: 0 }:
                    throw new ArgumentOutOfRangeException(argumentName);
            }
            if (argumentValue is not string)
                throw new ArgumentException(argumentName);
        }
    }
// ###################            ##################################      Guard End    ##################################            ###################
//https://jsontostring.com/convert-json-to-one-line/
public class SourceJSON
{
    private readonly bool _fromFixString;
    private readonly Lazy<List<TypeOfDoc>> _deserializeObject;
    private SourceJSON(bool fromFixString)
    {
        _fromFixString = fromFixString;
        _deserializeObject = GetAllTypeOfDocs();
    }
​
    public static SourceJSON CreateInstance(bool fromFixString)
    {
        return new SourceJSON(fromFixString);
    }
    public IEnumerable<string> GetWordsThatPointsToType(string[] criteria)
    {
        var wordsThatPointToTypes = new List<string>();
        if (!_deserializeObject.IsValueCreated) return wordsThatPointToTypes;
        //var jArray = JsonConvert.DeserializeObject<JArray>(json);
        //https://stackoverflow.com/a/41810862/2752308
        //foreach (JObject item in jArray) // <-- Note that here we used JObject instead of usual JProperty
        foreach (var typeOfDoc in _deserializeObject.Value!)
        {
            //see PatientManagerMDWinForms.Tests.WinServices
            //      .GetWordsThatPointToType_FromDifferentLINQ_Methods_SameResult()
​
            //var displayName = item.GetValue("DisplayName").ToString();
            if (criteria.Contains(typeOfDoc.DisplayName))
            //if (criteria.Contains(displayName))
            {
                //wordsThatPointToTypes.AddRange(
                //    item.GetValue("WordsThatPointsToType")
                //        .Select(word => word.ToString()));
                wordsThatPointToTypes.AddRange(
                    typeOfDoc.WordsThatPointsToType.ToList());
            }
        }
        return wordsThatPointToTypes;
    }
​
    private Lazy<List<TypeOfDoc>> GetAllTypeOfDocs()
    {
        var json = _fromFixString ? TypeOfPatientDocKeyWordsFixed : TypeOfPatientDocKeyWords().Value;
        var deserializeObject = JsonConvert.DeserializeObject<List<TypeOfDoc>>(json);
        //        return deserializeObject == null ? new Lazy<List<TypeOfDoc>>() : new Lazy<List<TypeOfDoc>>(() => deserializeObject);
        return new Lazy<List<TypeOfDoc>>(() => deserializeObject);
    }
​
​
    private const string TypeOfPatientDocKeyWordsFixed = "[{\"DisplayName\":\"Exames Laboratoriais\",\"WordsThatPointsToType\":[\"Revisão\",\"laboratorial\",\"laboratório\",\"fatores de risco\",\"hemograma\",\"sangue\",\"urina\",\"fezes\"]},{\"DisplayName\":\"Exames de Imagem\",\"WordsThatPointsToType\":[\"tomografia\",\"ressonância\",\"cintilografia\",\"RM\",\"TC\",\"Duplex\",\"Densitometria\",\"carótidas\",\"ecocardiograma\",\"ecocardiografia\",\"eco\",\"Tomossíntese\",\"US\",\"Ultrassonografia\",\"Ultra-sonografia\"]},{\"DisplayName\":\"Exames Especiais\",\"WordsThatPointsToType\":[\"polissonografia\",\"Mapeamento retina\",\"Campo visual\",\"fundoscopia\",\"EDA\",\"colonoscopia\",\"Holter\",\"MAPA\",\"ergometria\",\"prova de esforço\",\"prova de função respiratória\",\"ergoespirometria\",\"Escore de cálcio\",\"ergometria\",\"espirometria\",\"EMNG\"]},{\"DisplayName\":\"ECG\",\"WordsThatPointsToType\":[\"eletrocardiograma\",\"ECG\",\"Pulsebit\",\"HeartCheck Report\"]},{\"DisplayName\":\"Exames outros em geral\",\"WordsThatPointsToType\":[\"exame\",\"notas e exames\"]},{\"DisplayName\":\"Receituário\",\"WordsThatPointsToType\":[\"Receituário\",\"Receita\"]},{\"DisplayName\":\"Receita de Controlados\",\"WordsThatPointsToType\":[\"RECEITUÁRIO CONTROLE ESPECIAL\"]},{\"DisplayName\":\"Receita de Antibióticos\",\"WordsThatPointsToType\":[\"AMICACINA\",\"AMOXICILINA ;CLAVULANATO DE POTÁSSIO\",\"AMOXICILINA\",\"AMOXICILINA;SULBACTAM\",\"AMPICILINA\",\"ANFOTERICINA B\",\"ANIDULAFUNGINA\",\"AXETIL CEFUROXIMA\",\"AXETILCEFUROXIMA\",\"AZITROMICINA\",\"AZTREONAM\",\"CASPOFUNGINA\",\"CEFACLOR\",\"CEFADROXILA\",\"CEFALEXINA\",\"CEFUROXIMA\",\"CETOCONAZOL\",\"CILASTATINA;IMIPENÉM\",\"CLAVULANATO DE POTÁSSIO;AMOXICILINA\",\"CLAVULANATO DE POTÁSSIO;ÁCIDO CLAVULÂNICO;AMOXICILINA\",\"CLORANFENICOL\",\"COLISTINA\",\"Ciprofloxacina\",\"Ciprofloxacino\",\"Cipro\",\"DAPTOMICINA\",\"DI ETAMBUTOL\",\"DOXICICLINA\",\"DOXICICLINA\",\"ERTAPENÉM\",\"ESTREPTOMICINA\",\"ETIONAMIDA\",\"FLUCONAZOL\",\"FOSFOMICINA\",\"FOSFOMICINA TROMETAMOL\",\"GENTAMICINA\",\"IMIPENÉM\",\"IMIPENÉM;CILASTATINA\",\"ISAVUCONAZÔNIO\",\"ISONIAZIDA\",\"ITRACONAZOL\",\"Levofloxacina\",\"Levofloxacino\",\"LIMECICLINA\",\"LINEZOLIDA\",\"MEROPENÉM\",\"MICAFUNGINA\",\"MINOCICLINA\",\"Metronidazol\",\"Moxifloxacina\",\"Moxifloxacino\",\"NISTATINA\",\"PIPERACILINA\",\"PIPERACILINA;TAZOBACTAM\",\"PIRAZINAMIDA\",\"POLIMIXINA B\",\"POSACONAZOL\",\"RIFAMPICINA\",\"SULBACTAM\",\"SULBACTAM;AMPICILINA\",\"SULFADIAZINA\",\"TAZOBACTAM\",\"TAZOBACTAM;PIPERACILINA\",\"TEDIZOLIDA\",\"TEICOPLANINA\",\"TERBINAFINA\",\"TETRACICLINA\",\"TIANFENICOL\",\"TIGECICLINA\",\"TOBRAMICINA\",\"VANCOMICINA\",\"VORICONAZOL\"]},{\"DisplayName\":\"Receita de Psicotrópicos\",\"WordsThatPointsToType\":[\"AGOMELATINA\",\"AMITRIPTILINA\",\"BUPROPIONA\",\"CARBONATO DE LÍTIO\",\"CITALOPRAM\",\"CLOMIPRAMINA\",\"DESVENLAFAXINA\",\"DONEPEZILA\",\"DULOXETINA\",\"ESCITALOPRAM\",\"FLUOXETINA\",\"FLUVOXAMINA\",\"IMIPRAMINA\",\"LÍTIO\",\"MAPROTILINA\",\"MEMANTINA\",\"MIRTAZAPINA\",\"MIRTAZAPINA\",\"NORTRIPTILINA\",\"PAROXETINA\",\"REBOXETINA\",\"SERTRALINA\",\"TIANEPTINA\",\"TRAZODONA\",\"VENLAFAXINA\",\"VILAZODONA\",\"VORTIOXETINA\"]},{\"DisplayName\":\"Pedido de Parecer ou Segunda Opinião\",\"WordsThatPointsToType\":[\"Parecer\"]},{\"DisplayName\":\"Encaminhamento de Paciente para Emergência, Internação ou Método Complementar\",\"WordsThatPointsToType\":[\"Encaminhamento\"]},{\"DisplayName\":\"Risco Cirúrgico\",\"WordsThatPointsToType\":[\"Risco Cirúrgico\",\"Avaliação de risco\"]},{\"DisplayName\":\"Atestados ou Dispensas\",\"WordsThatPointsToType\":[\"Atestado\",\"Dispensa\",\"Afastamento de trabalho\"]},{\"DisplayName\":\"Relatório Somente\",\"WordsThatPointsToType\":[\"Relatório\",\"Sumário de Alta\"]},{\"DisplayName\":\"Emissão de Laudo\",\"WordsThatPointsToType\":[\"Laudo\",\"Pericia\",\"Pericial\"]},{\"DisplayName\":\"Recibo somente\",\"WordsThatPointsToType\":[\"Recibo\"]},{\"DisplayName\":\"Relatório com recibo\",\"WordsThatPointsToType\":[\"Relatório com recibo\",\"Relatório e recibo\",\"Relatório + recibo\"]},{\"DisplayName\":\"Sinais de Alerta\",\"WordsThatPointsToType\":[\"Sinais de Alerta\"]},{\"DisplayName\":\"Pedido Especial\",\"WordsThatPointsToType\":[\"Pedido\",\"Solicitação\"]},{\"DisplayName\":\"Pedido de Transporte\",\"WordsThatPointsToType\":[\"Transporte\",\"Ambulância\"]},{\"DisplayName\":\"Pedido de Assistência Domiciliar ou Home-Care\",\"WordsThatPointsToType\":[\"Assistência Domiciliar\",\"Home-Care\"]},{\"DisplayName\":\"Receita em Formato Grade com aprazamento e checagem\",\"WordsThatPointsToType\":[\"Receita em Formato Grade\",\"Prescrição\"]},{\"DisplayName\":\"Grade de sinais vitais\",\"WordsThatPointsToType\":[\"Grade de sinais vitais\",\"Grade sinais\"]},{\"DisplayName\":\"Pendências para próxima consulta\",\"WordsThatPointsToType\":[\"Pendências\",\"Trazer próxima consulta\"]},{\"DisplayName\":\"Minhas Anotações\",\"WordsThatPointsToType\":[\"Anotação Outlook\",\"Anotação\",\"Consulta n\",\"Consulta em\",\"Evolução\"]}]";
    //public static Lazy<string> TypeOfPatientDocKeyWords(bool fromFixString) => fromFixString ? new Lazy<string>(() => TypeOfPatientDocKeyWordsFixed) : new Lazy<string>(GetTypeOfPatientDocKeyWords);
    public Lazy<string> TypeOfPatientDocKeyWords() => new(GetTypeOfPatientDocKeyWords);
    private string GetTypeOfPatientDocKeyWords()
    {
        var json = string.Empty;
        try
        {
            var patientsSourceFolder = "";//AuxiliaryFolderStructure.Data.Path;
            var docKeyWords = "";//patientsSourceFolder.CombinePaths("TypeOfPatientDocKeyWords.json");
            using var sr = new StreamReader(docKeyWords);
            json = sr.ReadToEnd();
        }
        catch (Exception)
        {
            Console.WriteLine($"Error reading TypeOfPatientDocKeyWords.json at {nameof(GetTypeOfPatientDocKeyWords)}");
            return string.Empty;
        }
        return json;
    }
}
​

100
200

Cached Result
Last Run:	11:12:25 am
Compile:	0.125s
Execute:	0s
Memory:	224.16kb
CPU:	0s

View IL Code