DocName with NamePart v3 | C# Online Compiler

DocName with NamePart v3 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;

#region private::tests
public class Program
{
	public static void Main()
	{
		//Console.Writeline("Hello");
		TestNameParts();
	}
	public static void TestNameParts()
	{/**/
		string[] nameTests = {/**/ "Prontuário Itau com anotações entre 2007 e 2021.pdf"
						, "Recibos comparecimento a Fisioterapia entre 052016 e 122019.pdf"
						, "US abdominal˗cisto hepático_5f9a739a-0b2e-4fcc-9228-81035e6e50ea 23122022 v3.docx"
						, "Ruy Quiroga_20230605161406.pdf"
						, "Aderaldo Vieira Chaves - SOLICITAÇÃO DE EXAME_5f9a739a-0b2e-4fcc-9228-81035e6e50ea.pdf"
						, "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"
						, "Nome do paciente - exame laboratorial amplo 3 - 23122022.docx"
						, "Nome do paciente - exame laboratorial amplo - 10122022 2.docx", "Nome do paciente - exame laboratorial amplo - 122021 2.docx"
						, "Nome do paciente - relatório internação de 12 a 12122022 - 2 20__.docx"
						, "Nome do paciente - exame laboratorial amplo - 23122022 v2.docx", "Nome do paciente - exame laboratorial amplo v3 - 23122022.docx"
						, "Nome do paciente - exame laboratorial amplo - 122022 v2.docx", "Nome do paciente - relatório internação de 12 a 20122022 - v2 20__.docx"
						, "US abdominal-cisto hepático 23122022.docx", "US abdominal˗cisto hepático 23122022.docx", "US abdominal–cisto hepático 23122019.docx"
						, "US abdominal - cisto hepático 29122022.docx", "US abdominal - cisto hepático v3 23122022.doc", "US abdominal 21122022.docx"
						, "US abdominal - 23122022.docx", "Nome do paciente - exame laboratorial amplo v2 - 23122022.docx", "Nome do paciente - v2 20122012.docx"
						, "Outro paciente - exame laboratorial amplo para home-care - v2 23122022.docx", "Nome do paciente - relatório internação de 12 a 20122022 - v2 20122011.docx"
						, "Nome do paciente - exame laboratorial amplo - 202_ v3.docx"
						, "Nome do paciente D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Ciprofloxacino 500 mg 2017.pdf", "Fulano Sicrano Beltrano - relatório internação - de 1208 até 20062021 - erosão traqueal - v2 12072021.docx" 
						/**/};
		var docs = new List<DocName>();
		foreach (var fileName in nameTests)
		{
			var docName = DocName.CreateInstance(fileName, new MessageDialogServiceNone(), false);
			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.Part : n.FirstPartName.Error)}");// .ToString());//
			Console.WriteLine();
			//Console.WriteLine($"MiddlePart: {(n.MiddlePartName.IsSuccess ? n.MiddlePartName.Value.Part : n.MiddlePartName.Error)}");// .ToString());//
			Console.WriteLine();
			//Console.WriteLine($"LastPart: {(n.LastPartName.IsSuccess ? n.LastPartName.Value.Part : 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 ##########################################################################################						  
//################################################################################### 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 = "pt-BR", 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;
            Culture = new CultureInfo(culture);
            OriginalNameBeforeTreat = fullNameWithExtension;
            GetParts(FixWrongDelimiters(fullNameWithExtension));
        }

        /// <summary>
        /// The maximum possible year for a date or interval in a sentence
        /// </summary>
        /// <param name="fullNameWithExtension"></param>
        /// <param name="dialog"></param>
        /// <param name="raiseEvents"></param>
        /// <param name="maxPossibleYear"></param>
        /// <returns></returns>
        public static DocName CreateInstance(string fullNameWithExtension, IMessageDialogService dialog, bool raiseEvents, int maxPossibleYear = int.MinValue)
        {
            if (maxPossibleYear == int.MinValue)
                maxPossibleYear = DateInSentence.GetMaxPossibleYear();
            return new DocName(fullNameWithExtension, dialog, raiseEvents) { MaxPossibleYear = maxPossibleYear };
        }
        /// <summary>
        /// For Serialization ONLY; coding use the other without dialog Argument
        /// </summary>
        public static DocName None(IMessageDialogService dialog) => new(string.Empty, dialog, false);
        /// <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, Culture, 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, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
            return new DocName(FullName, _dialog, _raiseEvents) { MaxPossibleYear = this.MaxPossibleYear};
        }
        public DocName PromoteIntoPatientDoc(string fullName)
        {
            FirstPartName = Result.Success(NamePart.DefinePart(fullName, DocNamePart.First, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
            return new DocName(FullName, _dialog, _raiseEvents) { 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 CultureInfo Culture { 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)> WrongDelimiter { get; private set; } = new();
        public int MaxPossibleYear { get; private set; } = 2025;

        /// <summary>
        /// if WrongDelimiter.Any() || OriginalNumberOfParts > _maxNumOfParts
        /// </summary>
        public bool OriginalNameCannotBeRehydrated => WrongDelimiter.Any() || OriginalNumberOfParts > _maxNumOfParts || !OriginalNameBeforeTreat.Equals(FullNameWithExtension); 

        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 Result<NamePart> LastPartName { get; private set; }
        public Result<string> LastPartNameOriginal { 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;
        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));
                }
                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)
        {
            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, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
            FirstPartNameOriginal = matchesList[0].Trim();
            OriginalNumberOfParts = matchesList.Count;
            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, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
                    i = 2;
                    LastPartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(matchesList[i].Trim()));
                    LastPartName = Result.Success(NamePart.DefinePart(matchesList[i].Trim(), DocNamePart.Last, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
                    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, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
                    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);
                    }
                    MiddlePartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(joinMiddleParts.Trim()));
                    MiddlePartName = Result.Success(NamePart.DefinePart(joinMiddleParts.Trim(), DocNamePart.Middle, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
                    LastPartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(matchesList[matchesList.Count - 1].Trim()));
                    LastPartName = Result.Success(NamePart.DefinePart(matchesList[matchesList.Count - 1].Trim(), DocNamePart.Last, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
                    break;
            }
        }
        private static (string name, string extension) DivideDocNameFromExtension(string input)
        {
            var rgx = new Regex(GrabNameAndExtension);
            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; }
        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 = new Regex(GrabFakeDelimiterWithoutAnySpaceAround);
            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 = new Regex(GrabPartsOfName);
            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, Delimiter, DocNamePart.First)}"
                + $"{GeneratePartOfNameIncludingSimplePartConcatenated(MiddlePartName, Delimiter, DocNamePart.Middle)}"
                + $"{GeneratePartOfNameIncludingSimplePartConcatenated(LastPartName, Delimiter, DocNamePart.Last)}";
        }
        private string GeneratePartOfNameIncludingSimplePartConcatenated(Result<NamePart> part, string delimiter,
            DocNamePart whichPart)
        {
            string? name;
            if (whichPart == DocNamePart.First)
            {
                name = part.IsFailure
                    ? string.Empty
                    : @$"{part.Value.GetPartNameElements}";
                    //: @$"{part.Value.GetConcatenatedPartNameElements(FakeDelimiter, Delimiter)}";
            }
            else
            {
                name = part.IsFailure
                    ? string.Empty
                    : @$" {delimiter}{(string.IsNullOrEmpty(part.Value.GetPartNameElements) ? "" : " ")}{part.Value.GetPartNameElements.Trim()}";
            }
            return name;//.RemoveUnnecessarySpaces();
        }

        #endregion Private Methods

        #region Overrides of ValueObject

        protected override IEnumerable<object> 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 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 CultureInfo Culture { 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

        #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)
        {
            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,
                Culture = new CultureInfo(culture),
                Delimiter = delimiter,
                FakeDelimiter = fakeDelimiter
            };
            instance.MaxPossibleYear = maxPossibleYear;
            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, CultureInfo.CurrentCulture, MaxPossibleYear);
            var dateInSentence =
                DateInSentence.CreateInstanceFromSentence(_partText, Culture, (GUIDInPart.StartIndex, GUIDInPart.EndOriginal), MaxPossibleYear);
            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, Culture, (GUIDInPart.StartIndex, GUIDInPart.EndOriginal), MaxPossibleYear);
            }
            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);
                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;
        }
        #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))
            {
                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.Normal && 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.Normal && dateInSentence.DateText == intervalInSentence.ElementValue.Value;
        }

        /// <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

        #region Common

        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

        #endregion Private Methods

        #region Overrides of ValueObject
        protected override IEnumerable<object> 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 ##########################################################################################						  		  						  
//################################################################################### InNameGUID ##########################################################################################
public class InNameGUID : BaseElement//ValueObject
{
    private const string Grab_GUID_treated = @"(?<GUID>[0-9a-f]{8}<>[0-9a-f]{4}<>[0-9a-f]{4}<>[0-9a-f]{4}<>[0-9a-f]{12})";

    private InNameGUID(int 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 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<object> 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
		{
			//Try to look list of words only
			//until now is losing below
			//Gilda Elena Brandão Andrade D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Fosfomicina 20__.docx
			var criteria = new string[]{"Receita de Antibióticos", "Receita de Psicotrópicos"};
			var medicines = GetWordsThatPointsToType(criteria);
			foreach (var medicine in medicines)
			{
				if (!OriginalText.ToLowerInvariant().Contains(medicine.ToLowerInvariant()))
					continue;
				Name = medicine.CapitalizeFirstLetter();
				Dosage = "N/A";
				Unit = "N/A";
				Form = "N/A";
			}
		}
	}

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

        #endregion Private Methods
        #region Overrides of ValueObject

        protected override IEnumerable<object> 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);
        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 static Result<string> GetVersionFromPart(string partToTest)
    {
        var version = DocNameHelper.ReturnResult(GrabVersionFromFile, partToTest, "version", "No file version");
        if (version.IsFailure && !char.IsWhiteSpace(partToTest, 0))
            version = DocNameHelper.ReturnResult(GrabVersionFromFile, $" {partToTest}", "version", "No file version");
        return version;
    }

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

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

    #region Overrides of ValueObject

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

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

    #region Public Constants
    //public const string GrabDatesWithMonthsInLettersOrPureNumbersFromFile = @"(?<relationandinterval>(?<temporalrelation> em )?(?<=\W)(?<intervalordate>(?:\d{6,8}|\d{2,3}_{1,2})|(?:\b(0?[1-9]|[12][0-9]|3[01])*(?: de )?([JFMASONDjfmasond]([a-z0-9]+)([ç]{0,1})([a-z0-9]+)*)*(?: de )?(19|20)?[0-9]{2}\b)))";
    //https://regex101.com/r/ZuUZy3/9^^^^^^^^^^^^
    public const string GrabDatesWithMonthsInLettersOrPureNumbersFromFile = @"(?<relationandinterval>(?<temporalrelation> em | por )?(?<=\W)(?<intervalordate>(?:\d{6,8}|\d{2,3}_{1,2})|(?:\b(0?[1-9]|[12][0-9]|3[01])*(?: de )?([JFMASONDjfmasond]([a-z0-9]+)([ç]{0,1})([a-z0-9]+)*)*(?: de )?(19|20)?[0-9]{2}\b))(?<timeframe> ano | anos | mês | meses | dia | dias )?)";
    //https://regex101.com/r/ZuUZy3/11^^^^^^^^^^^^
    //https://stackoverflow.com/a/10033196/2752308 ^^^^^^ 
    public const string GrabDatesOrPureNumbersFromPartOfFile = @"(?<date>\d{6,8}|\d{2,3}_{1,2})";
    //https://regex101.com/r/DfGFk5/1   https://www.utctime.net/
    public const string GrabDatesUTC = @"(?<dateUTC>(?<year>-?(?:[1-9][0-9]*)?[0-9]{4})-(?<month>1[0-2]|0[1-9])-(?<day>3[01]|0[1-9]|[12][0-9])T(?<hour>2[0-3]|[01][0-9]):(?<minute>[0-5][0-9]):(?<second>[0-5][0-9])(\\.[0-9]+)?(?<zeroUTCoffse>Z)?|(?<year>(?:[1-9][0-9]*)?[0-9]{4})(?<month>1[0-2]|0[1-9])(?<day>3[01]|0[1-9]|[12][0-9])(?<hour>2[0-3]|[01][0-9])(?<minute>[0-5][0-9])(?<second>[0-5][0-9])(\\.[0-9]+)?(?<zeroUTCoffse>Z)?)";
    //Use it only to extract from PartOfName
    public const string GrabDateIntervalFromPartOfFile = @"(?<=\W)(?<interval>(?<starting>[ mçinícandouetr]+?)(?<datebegin>\d+)(?<link>[ eatéfimnldzou]+?)(?<=\W)(?<!\w-)(?<dateend>\d+))";
    //https://regex101.com/r/1UfbIM/1 ^^^^^^^^^^^^^^^^ 
    public const string GrabDateAndVersionDotAtEnd =
        @"(?<date>\d{6,8}|\d{2,3}_{1,2}) {1,2}(?<version>[vVersionão]+[\d@]+[\w@]*|[\d@]+[vVersionão]+[\w@]*).|(?<version>[vVersionão]+[\d@]+[\w@]*|[\d@]+[vVersionão]+[\w@]*) {1,2}(?<date>\d{6,8}|\d{2,3}_{1,2})\.|(?<date>\d{6,8}|\d{2,3}_{1,2})\.";
    //https://regex101.com/r/TpTA1n/2 ^^^^^^^^^^^^^^^^
    public const string WildCardForDate = "_";
    #endregion Public Constants

    #region Public Fields
    public string DateText { get; private set; } = string.Empty;
    public DateTime DateAndTime { get; private set; } = DateTime.MinValue;

    /// <summary>
    /// When TypeInterval == TimeFrame, DateTime == DateTime.MinValue and
    /// here will be stored Number of Days, Months or Years
    /// </summary>
    //[JsonIgnore]
    public int IntervalTimeFrame => int.Parse(DateText);

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

    #region Constructors
    //[JsonConstructor]
    private DateInSentence()
    {

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

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

    public static DateInSentence NullDate => 
        new(string.Empty, DateTime.MinValue, DateFormat.NoDate, CertaintyAboutElement.NonExisting);

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

    public static DateInSentence ChangeToMMDD(DateInSentence date, DateFormat newMask)
    {
        if (date.DateText.Length != 4) throw new ArgumentException("Can only change mask of DDMM or YYYY to MMDD");
        return CreateInstance(date.DateText, date.DateAndTime, DateFormat.MMdd);
    }
    public static DateInSentence ChangeToDDMM(DateInSentence date, DateFormat newMask)
    {
        if (date.DateText.Length != 4) throw new ArgumentException("Can only change mask of MMDD or YYYY to DDMM");
        return CreateInstance(date.DateText, date.DateAndTime, DateFormat.ddMM);
    }
    public static DateInSentence CreateInstanceTimeFrame(string dateText, DateFormat mask, CertaintyAboutElement certaintyAbout = CertaintyAboutElement.AbsolutelyCertain)
    {
        //if (!int.TryParse(dateText, out _)) throw new ArgumentException("dateText must be a number");
        return new DateInSentence(dateText, DateTime.MinValue, mask, certaintyAbout);
    }
    public static DateInSentence CreateInstance(string dateText, DateTime dateTime, DateFormat mask, CertaintyAboutElement certaintyAbout = CertaintyAboutElement.AbsolutelyCertain)
    {
        return new DateInSentence(dateText, dateTime, mask, certaintyAbout);
    }
	/// <summary>
	/// Create Instance inferring Mask and Format for Date Parsing
	/// </summary>
	public static DateInSentence CreateInstance(string dateToParse, CultureInfo cultureInfo, int? maxPossibleYear,
        bool forceDDMMorMMDD = false, int minPossibleYear = 1990, bool acceptWildCard = true)
	{
        var dateParsing = new DateInSentence(dateToParse, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
        var 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(), 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 (string.IsNullOrEmpty(dateParsing.DateText))
                throw new NotImplementedException("InferMaskAndFormatForDateParsing: dateParsing is not digit, ie, MMM or MMMM or ddd or dd or tt");                
            
        }
        //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(CultureInfo cultureInfo, string raw, DateInSentence dateParsing)
    {
        DateTime parsedDate;
        if (raw.Contains(WildCardForDate) && raw.Length == 4)
        {
            //202_
            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;
            //return dateParsing;
        }

        if (!raw.Contains(WildCardForDate) && raw.Length == 7)
        {
            //fev2021
            dateParsing.Mask = DateFormat.MMMyyyy;
            _ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), cultureInfo, DateTimeStyles.None,
                out parsedDate);
            dateParsing.DateText = raw;
            dateParsing.DateAndTime = parsedDate;
            dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
            //return dateParsing;
        }
        //GrabDatesWithMonthsInLettersOrPureNumbersFromFile
        //grab: 202_
        //[Description("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'")]
        //universalSortable		
    }

    private static void TryParseNumericOnlyDates(CultureInfo cultureInfo, int? maxPossibleYear, bool forceDDMMorMMDD,
        int minPossibleYear, string raw, DateInSentence dateParsing)
    {
        if (raw.Length == DateFormat.sortable.GetDescription().Length) //yyyyMMddHHmmss
        {
            //[Description("yyyyMMddHHmmss")]
            //sortable,
            dateParsing.Mask = DateFormat.sortable;
        }
        //[Description("dd/MM/yyyy HH:mm:ss")]
        //completeUpToSeconds,
        //[Description("MM/dd/yyyy HH:mm:ss")]
        //completeUpToSecondsUS,
        else if (raw.Length == 8) //ddmmyyyy or mmddyyyy
        {
            dateParsing.Mask = dateParsing.IsDDMM ? DateFormat.ddMMyyyy : DateFormat.MMddyyyy;
        }
        else if (raw.Length == 6) //MMyyyy 
        {
            dateParsing.Mask = DateFormat.MMyyyy;
        }
        else if (raw.Length == 4) //ddMM OR MMdd OR yyyy
        {
            var yyyyToTestIfWithinAllowedRange = DateTime.MinValue;
            var maybeDDMMorMMDD = IsItPossibleToBeDDMMOrMMDD(raw, cultureInfo);
            //DateTime.TryParseExact(dateParsing, DateFormat.ddMM.GetDescription(), cultureInfo, DateTimeStyles.None, out _) ||
            // DateTime.TryParseExact(dateParsing, DateFormat.MMdd.GetDescription(), cultureInfo, DateTimeStyles.None, out _);
            var maybeYYYY = DateTime.TryParseExact(raw, DateFormat.yyyy.GetDescription(), cultureInfo, DateTimeStyles.None,
                out yyyyToTestIfWithinAllowedRange);
            if ((maybeDDMMorMMDD && !maybeYYYY) || forceDDMMorMMDD)
                dateParsing.Mask = dateParsing.IsDDMM ? DateFormat.ddMM : DateFormat.MMdd;
            else if (!maybeDDMMorMMDD && maybeYYYY)
                dateParsing.Mask = DateFormat.yyyy;
            else if (maybeDDMMorMMDD && maybeYYYY)
            {
                //assume yyyy if possible ????
                dateParsing.CertaintyAbout = CertaintyAboutElement.InformedGuess;
                if (yyyyToTestIfWithinAllowedRange >= new DateTime(minPossibleYear, 1, 1) &&
                    yyyyToTestIfWithinAllowedRange <= new DateTime(maxPossibleYear.Value, 1, 1))
                    //https://stackoverflow.com/questions/3871299/asp-net-c-sharp-parse-int-as-datetime
                    dateParsing.Mask = DateFormat.yyyy;
                else
                    dateParsing.Mask = dateParsing.IsDDMM ? DateFormat.ddMM : DateFormat.MMdd;
            }
            else if (maybeDDMMorMMDD && maybeYYYY)
            {
                //?????
                dateParsing.Mask = DateFormat.NoDate;
                dateParsing.CertaintyAbout = CertaintyAboutElement.NonExisting;
            }
        }
        else if (raw.Length == 2) //dd OR MM OR yy
        {
            throw new NotImplementedException("InferMaskAndFormatForDateParsing: dateParsing.Length == 2");
        }
    }

    public static DateInSentence CreateInstanceFromSentence(string dateToParse, CultureInfo cultureInfo 
        ,(int start, int end) forbiddenZoneCoordinates, int? maxPossibleYear
        , bool forceDDMMorMMDD = false, int minPossibleYear = 1990, bool acceptWildCard = true)
    {
        //var dateInSentence = new DateInSentence(dateToParse, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
        var hasDate = GetDateStatic(dateToParse, cultureInfo, forbiddenZoneCoordinates, acceptWildCard);
        if (hasDate.IsFailure)
            return DateInSentence.NullDate;
        return CreateInstance(hasDate.Value, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
    }
    public static Result<DateInSentence> Update(string date, DateInSentence valueDateInSentence)
    {
        var 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;
    }
    public Result<string> GetDate(string partToTest, (int start, int end) forbiddenZoneCoordinates)
        //public static Result<string> GetDateStatic(string partToTest, DocNamePart partName, InNameGUID partHasGUID)	
    {
        if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest))
            return Result.Failure<string>("No date stamp in this file name");
        var hasDate = ReturnDateResult(GrabDatesUTC, partToTest, "dateUTC",
            "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates);
        //"No date stamp in this file name", partName, partHasGUID);
        if (hasDate.IsFailure)
        {
            hasDate = ReturnDateResult(GrabDatesOrPureNumbersFromPartOfFile, partToTest, "date",
                "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates);
            //"No date stamp in this file name", partName, partHasGUID);				
        }
        if (hasDate.IsFailure)
        {
            hasDate = ReturnDateResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "intervalordate",
                "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates);
            //"No date stamp in this file name", partName, partHasGUID);				
        }
        if (hasDate.IsSuccess)
        {
            hasDate = FilterAbsurdDates(hasDate, _cultureInfo, _acceptWildCard, "No date stamp in this file name");
        }
        return hasDate;
    }
    #endregion Constructors

    #region Private Methods
    public static Result<string> GetDateStatic(string partToTest, CultureInfo cultureInfo, (int start, int end) forbiddenZoneCoordinates, bool acceptWildCard = true)
        //public static Result<string> GetDateStatic(string partToTest, DocNamePart partName, InNameGUID partHasGUID)	
    {
        if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest))
            return Result.Failure<string>("No date stamp in this file name");
        var hasDate = ReturnDateResult(GrabDatesUTC, partToTest, "dateUTC",
            "No date stamp in this file name", cultureInfo, forbiddenZoneCoordinates);
        //"No date stamp in this file name", partName, partHasGUID);
        if (hasDate.IsFailure)
        {
            hasDate = ReturnDateResult(GrabDatesOrPureNumbersFromPartOfFile, partToTest, "date",
                "No date stamp in this file name", cultureInfo, forbiddenZoneCoordinates);
            //"No date stamp in this file name", partName, partHasGUID);				
        }
        if (hasDate.IsFailure)
        {
            hasDate = ReturnDateResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "intervalordate",
                "No date stamp in this file name", cultureInfo, forbiddenZoneCoordinates);
            //"No date stamp in this file name", partName, partHasGUID);				
        }
        if (hasDate.IsSuccess)
        {
            hasDate = FilterAbsurdDates(hasDate, cultureInfo, acceptWildCard, "No date stamp in this file name");
        }
        return hasDate;
    }
    internal static int GetCurrentYearPlus(int toAddCurrent) => DateTime.Now.Year + toAddCurrent;
    internal static int GetMaxPossibleYear(int yearsAhead = 2) => DateTime.Now.Year + yearsAhead;
    internal static bool IsItPossibleToBeDDMMOrMMDD(string dateToTest, CultureInfo cultureInfo)
    {
        if (dateToTest.Length != 4) return false;
        return DateTime.TryParseExact(dateToTest, DateFormat.ddMM.GetDescription(), cultureInfo, DateTimeStyles.None, out _) ||
               DateTime.TryParseExact(dateToTest, DateFormat.MMdd.GetDescription(), cultureInfo, DateTimeStyles.None, out _);
    }

    private static Result<string> FilterAbsurdDates(
        Result<string> hasDate, CultureInfo cultureInfo, bool acceptWildCard = true
        , string errorMsg = "No date found", int numberOfYearsToConsiderAbsurd = 99)
    {
        if (hasDate.IsFailure)
            return hasDate;
        DateTime testDate = DateTime.MinValue;
        string dateWithoutSpace = string.Empty;
        if (hasDate.Value.DoesNotContainAnySpace())
        {
            dateWithoutSpace = hasDate.Value;
        }
        else
        {
            var dateCandidates = hasDate.Value.Split(' ');
            foreach (var element in dateCandidates)
            {
                if (element.Length > 3 && element.Length < 8)
                {
                    dateWithoutSpace = element;
                }
            }
        }
        if (string.IsNullOrEmpty(dateWithoutSpace)) return Result.Failure<string>(errorMsg);
        if (DocNameHelper.DateTryParseExact(dateWithoutSpace, out testDate, new CultureInfo("pt-BR")))
        //if (DateTime.TryParseExact(dateWithoutSpace, "yyyy", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out testDate) 	   )
        {
            if (testDate.IsThisDateNullOrDefault())
                return Result.Failure<string>(errorMsg);
            if (Math.Abs(testDate.YearsBetweenNowAndDate()) >= numberOfYearsToConsiderAbsurd)
                return Result.Failure<string>($"Cannot allow set date so many years ({testDate.YearsBetweenNowAndDate()}) far from today");
            return Result.Success(dateWithoutSpace);
            //Console.WriteLine("DateTryParseExact SUCCESS: " + testDate);
        }
        if (acceptWildCard && dateWithoutSpace.Contains(WildCardForDate))
        {
            return Result.Success(dateWithoutSpace);
        }
        //Console.WriteLine("DateTryParseExact FAILURE: " + testDate);
        return Result.Failure<string>($"Invalid date resulting in {testDate.ToString()}");
    }

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

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

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

    #endregion
}
//################################################################################### DateInSentence   End ##########################################################################################
//################################################################################### IntervalInSentence ##########################################################################################
public enum IntervalType
{
    Normal = 0, //"de 1203 até 20041999"
    TemporalClue //"em 082021"
}
public class IntervalInSentence : BaseElement// ValueObject
{

    #region Private Constants
    private readonly CultureInfo _cultureInfo;
    private readonly bool _sameFrameIntervalIsAllowed;
    private readonly bool _forceBeginDatePreviousYearIfReasonable;
    private readonly string _errorMsg;
    private Result<string> _candidateBegin;
    private Result<string> _candidateEnd;
    #endregion Private Constants

    #region Public Constants
    /// <summary>
    /// Should check for equality between relationandinterval and intervalordate; if so, the interval is invalid and should be ignored
    /// </summary>
    public const string GrabDatesWithMonthsInLettersOrPureNumbersFromFile = @"(?<relationandinterval>(?<temporalrelation> em | por )?(?<=\W)(?<intervalordate>(?:\d{6,8}|\d{2,3}_{1,2})|(?:\b(0?[1-9]|[12][0-9]|3[01])*(?: de )?([JFMASONDjfmasond]([a-z0-9]+)([ç]{0,1})([a-z0-9]+)*)*(?: de )?(19|20)?[0-9]{2}\b))(?<timeframe> anos[ .]{0,1}| ano[ .]{0,1}| mês[ .]{0,1}| meses[ .]{0,1}| dias[ .]{0,1}| dia[ .]{0,1})?)";
    //https://regex101.com/r/ZuUZy3/12^^^^^^^^^^^^
    //https://stackoverflow.com/a/10033196/2752308 ^^^^^^ 
    //Use it only to extract from PartOfName
    public const string GrabDateIntervalFromPartOfFile = @"(?<=\W)(?<interval>(?<starting>[ mçinícandouetr]+?)(?<datebegin>\d+)(?<link>[ eatéfimnldzou]+?)(?<=\W)(?<!\w-)(?<dateend>\d+))";
    //https://regex101.com/r/1UfbIM/2 ^^^^^^^^^^^^^^^^ 
    #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; }

    #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);
            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)
    {
        MaxPossibleYear = maxPossibleYear;
        _cultureInfo = cultureInfo;
        _sameFrameIntervalIsAllowed = sameFrameIntervalIsAllowed;
        _forceBeginDatePreviousYearIfReasonable = forceBeginDatePreviousYearIfReasonable;
        _errorMsg = errorMsg;
        OriginalText = originalText;
    }

    internal static IntervalInSentence CreateInstance(string interval, CultureInfo cultureInfo, int maxPossibleYear, 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);
        return !intervalInSentence.GetIntervalDates(interval) ? IntervalInSentence.Null : intervalInSentence;
    }
    #endregion Constructors

    #region Private Methods
    private bool IsDDMM => _cultureInfo.Name == "pt-BR";
    /// <summary>
    ///TODO very tough to predict all dd-mm possibilities and tell them from only yyyy
    /// example de 1208 a 2009 is one in which EndDate maybe dd-mm or yyyy, but not the first
    /// but how can I tell de 2107 a 2009 ??? comparing as dd-mm, interval is valid, but as yyyy, it is not valid
    /// maybe assuming certain yyyy are valid, but I do not know for sure
    /// </summary>
    /// <param name="partToTest"></param>
    /// <param name="errorMsg"></param>
    /// <returns></returns>
    private bool GetIntervalDates(string partToTest)
    {
        if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest)) return false;
        var hasInterval = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "interval",
            _errorMsg);
        if (hasInterval.IsSuccess)
        {
            ElementValue = hasInterval;
            _candidateBegin = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "datebegin", _errorMsg);
            _candidateEnd = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, 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(GrabDateIntervalFromPartOfFile, partToTest, "starting", _errorMsg).Value;
            TextBetween = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "link", _errorMsg).Value;
            IntervalType = IntervalType.Normal;
            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);
            hasInterval = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest,
                "intervalordate", _errorMsg);
            if (result.Equals(hasInterval))
            {
                ElementValue = Result.Failure<string>(_errorMsg);
                return false;// Result.Failure<string>(errorMsg);
            }
            ElementValue = result;
            IntervalType = IntervalType.TemporalClue;
            _candidateBegin = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "intervalordate", _errorMsg);
            _candidateEnd = _candidateBegin;
            if (_candidateBegin.IsFailure) return false;
            TextTemporalRelation = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "temporalrelation", _errorMsg).Value;
            TextBetween = string.Empty;
            TimeFrame = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "timeframe", _errorMsg).Value;
            DateBegin = DateInSentence.CreateInstanceTimeFrame(_candidateBegin.Value, DetermineTimeFrameType(result.Value));
        }
        //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.CreateInstance(dateBegin, validDates.dateStarted, format))
                                    , Result.Success(DateInSentence.CreateInstance(dateEnd, validDates.dateEnded, format)));
                        }
                    }
                    break;
                case 8: //ddMMyyyy
                    var formatEnd = IsDDMM
                        ? DateFormat.ddMMyyyy
                        : DateFormat.MMddyyyy;
                    var dateEndIsDDMM = DateTime.TryParseExact(dateEnd, formatEnd.GetDescription(),
                                                               _cultureInfo, DateTimeStyles.None, out var dateEnded);
                    if (dateBegin.Length == 8) //ddMMyyyy
                    {
                        var beginDDMMDateIsInPreviousYear = CompareDatesWithSameFormat(dateBegin, dateEnd, out var format, out var validDates);
                        if (beginDDMMDateIsInPreviousYear)
                        {
                            return (Result.Success(DateInSentence.CreateInstance(dateBegin, validDates.dateStarted, format))
                                , Result.Success(DateInSentence.CreateInstance(dateEnd, validDates.dateEnded, format)));
                        }
                    }
                    else if (dateBegin.Length == 6) //almost impossible MMyyyy
                    {
                        throw new NotImplementedException("I did not implemented 'de MMyyyy até ddMMyyyy'");
                    }
                    else if (dateBegin.Length == 4) //ddMM
                    {
                        var dateBeginIsDDMM = DateTime.TryParseExact(dateBegin + dateEnded.Year, formatEnd.GetDescription(),
                                                                     _cultureInfo, DateTimeStyles.None, out var ddMMBegin);
                        if (!dateBeginIsDDMM)
                        {
                            errorMsg = "because BeginDate is After EndDate";
                        } 
                        else if (IsBeginDateReallyBeforeEndDate(ddMMBegin, dateEnded))
                        {
                            //return (Result.Success(InNameDate.CreateInstance(dateBegin + dateEnded.Year, ddMMBegin, formatEnd)), 
                            //		Result.Success(InNameDate.CreateInstance(dateEnd, dateEnded, formatEnd))
                            //	   );
                            //Above return real tested date; below the original one
                            var formatBegin = IsDDMM
                                ? DateFormat.ddMM
                                : DateFormat.MMdd;
                            if (DateBeginHadToGoBackOneYear)
                                ddMMBegin = ddMMBegin.AddYears(-1);
                            return (Result.Success(DateInSentence.CreateInstance(dateBegin, ddMMBegin, formatBegin)),
                                    Result.Success(DateInSentence.CreateInstance(dateEnd, dateEnded, formatEnd))
                                   );
                        }
                    }
                    else if (dateBegin.Length == 2) //dd
                    {
                        var dayBegin = int.Parse(dateBegin); //dateBegin.Substring(0, 2);
                        if ((dayBegin > 0 && dayBegin < dateEnded.Day) || ((dayBegin == dateEnded.Day) && _sameFrameIntervalIsAllowed))
                        {
                            var dayInterval = Result.Success(DateInSentence.CreateInstance(dateBegin,
                                                                                       new DateTime(dateEnded.Year, dateEnded.Month, dayBegin), DateFormat.dd));
                            return (dayInterval,
                                    Result.Success(DateInSentence.CreateInstance(dateEnd, dateEnded, formatEnd))
                                   );
                        }
                        errorMsg = "because BeginDate is After EndDate";
                    }
                    break;
                case 6: //MMyyyy
                    formatEnd = DateFormat.MMyyyy;
                    dateEndIsDDMM = DateTime.TryParseExact(dateEnd, formatEnd.GetDescription(),
                                                               _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(),
                                                                     _cultureInfo, DateTimeStyles.None, out var ddMMBegin);
                        if (IsBeginDateReallyBeforeEndDate(ddMMBegin, dateEnded))
                        {
                            return (Result.Success(DateInSentence.CreateInstance(dateBegin, ddMMBegin, formatEnd)),
                                    Result.Success(DateInSentence.CreateInstance(dateEnd, dateEnded, formatEnd))
                                   );
                        }
                        errorMsg = "because BeginDate is After EndDate";
                    }
                    else if (dateBegin.Length == 4) //almost impossible ddMM; I do not think about MMyy
                    {
                        throw new NotImplementedException("I did not implemented 'de ddMM até MMyyyy'");
                    }
                    else if (dateBegin.Length == 2) //MM
                    {

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

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

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

                    }
                    break;

            }

        }
        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,
       int? maxPossibleYear, int minPossibleYear = 1990, bool sameFrameIntervalIsAllowed = false)
    {
        maxPossibleYear ??= DateInSentence.GetCurrentYearPlus(3);
        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.Value, sameFrameIntervalIsAllowed);

        //If both possibilities are valid, I'm betting that if you are not informing YYYY in two MMDD or DDMM interval,
        //it should be YYYY instead
        (dateBeginIsYYYY, dateEndIsYYYY) = DetermineIfIntervalDatesShouldBeYYYY(
            isDateEndDubious, isDateBeginDubious, endDateMaybeYYYY, beginDateMaybeYYYY, dateEndIsYYYY,
            dateBeginIsYYYY);
        var beginCannotBeDDMMOrMMDD = !DateInSentence.IsItPossibleToBeDDMMOrMMDD(dateBeginToTest, _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(), _cultureInfo,
                DateTimeStyles.None, out dateEnded);
            if (!dateEndIsYYYY) return (dateBegin, dateEnd);
            dateBegin = DateInSentence.CreateInstance(dateBeginToTest, dateStarted, DateFormat.yyyy, certaintyAboutYYYY);
            dateEnd = DateInSentence.CreateInstance(dateEndToTest, dateEnded, DateFormat.yyyy, certaintyAboutYYYY);
        }
        else if (dateBeginIsDDMM)
        {
            if (!dateEndIsDDMM || !IsDDMMBeginDateReallyBeforeEndDate(dateBeginToTest, dateEndToTest, formatForDateBeginTry, sameFrameIntervalIsAllowed)) return (dateBegin, dateEnd);
            dateBegin = DateInSentence.CreateInstance(dateBeginToTest, dateStarted, formatForDateBeginTry, certaintyAboutYYYY);
            dateEnd = DateInSentence.CreateInstance(dateEndToTest, dateEnded, formatForDateBeginTry, certaintyAboutYYYY);
        }
        return (dateBegin, dateEnd);
    }

    private (bool isDateEndDubious, bool isDateBeginDubious, CertaintyAboutElement certaintyAboutYYYY)
        DecideDegreeOfCertaintyAboutDates(string dateBeginToTest, string dateEndToTest)
    {
        var dubiousDate = _cultureInfo.Name == "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(), _cultureInfo, DateTimeStyles.None, out var beginDate);
        //var beginDate = DateTime.ParseExact(dateBegin, dateFormat.GetDescription(), cultureInfo);
        var endDateValid = DateTime.TryParseExact(dateEnd, dateFormat.GetDescription(), _cultureInfo, DateTimeStyles.None, out var endDate);
        if (!beginDateValid || !endDateValid) return false;
        //var endDate = DateTime.ParseExact(dateEnd, dateFormat.GetDescription(), cultureInfo);
        return IsBeginDateReallyBeforeEndDate(beginDate, endDate);
        //sameFrameIntervalIsAllowed ? 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(), _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, _cultureInfo,
            DateTimeStyles.None, out var dateStarted);
        var dateEndIsDDMM = DateTime.TryParseExact(dateEndToTest, maskForDDMM, _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, CultureInfo.CurrentCulture);
        var validEndInterval =
            DocNameHelper.DateTryParseExact(_candidateEnd.Value, out var endInterval, CultureInfo.CurrentCulture);
        var isValid = beginInterval < endInterval;
        return isValid;
    } 
    #endregion Draft

    #region Overrides of ValueObject

    protected override IEnumerable<object> 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
}
//################################################################################### IntervalInSentence End ##########################################################################################
//################################################################################### BaseElement  ##########################################################################################
    public class BaseElement : ValueObject
    {
        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<object> GetEqualityComponents()
        {
            yield return StartIndex;
            yield return ConnectorBefore;
            yield return OriginalText;
            yield return 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,
        NoDate = -1,
        yyyy = 0,
        MMyyyy,
        MMMyyyy,
        MMMMyyyy,

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

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

        dd,
        MM,
        MMM,
        MMMM,

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

    }
    public enum CertaintyAboutElement
    {
        NonExisting = -1,
        AbsolutelyCertain = 0,
        InformedGuess,
        InformedByUser,
        NotSure
    }
    public enum DocNamePart
    {
        NoPart = 0,
        First,
        Middle,
        Last,
        Extension
    }

    public enum ElementRelativePosition
    {
        DoesNotExist = 0,
        First,
        Middle,
        Last,
        //Second,
        //Third,
        //Fourth,
        //Fifty
    }
    public enum WhichElementItIs
    {
        DoesNotExist = 0,
        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 Common
        internal static bool DifficultyToTestPart(string partToTest)
        {
            return (partToTest.Length > 10 && partToTest.DoesNotContainAnySpace());
        }
        internal static Result<string> ReturnResult(string pattern, string part, string groupName, string errorMsg)
        {
            _ = GetMatch(pattern, part, groupName, errorMsg, out var result);
            //if ((!result.IsFailure && OutOfForbiddenZoneIfSamePart(groupName, partName, match, partHasGUID)) || !isDate) return result;
            //if (!result.IsFailure && OutOfForbiddenZoneIfSamePart(groupName, match, partHasGUID) || !isDate) return result;
            return result;
        }
        //GetMatch is a poor name...
        //Used in App
        internal static Match GetMatch(string pattern, string part, string groupName, string errorMsg, out Result<string> result)
        {
            var rgx = new Regex(pattern);
            var match = rgx.Match(" " + part.TrimStart());
            //BUG                     ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
            //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
            result = match.Success ? Result.Success(match.Groups[groupName].Value.Trim()) : Result.Failure<string>(errorMsg);
            return match;
        }
        //Used in NetFiddle
        internal static Match GetMatch(string pattern, string part) //, string groupName)
        {
            var rgx = new Regex(pattern);
            var match = rgx.Match(" " + part);
            //BUG                ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
            //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
            return match;
        }
        //Used in NetFiddle
        internal static Group GetMatchMainGroup(string pattern, string part) //, string groupName)
        {
            var rgx = new Regex(pattern);
            var match = rgx.Match(part.EnsureOneSingleSpaceAtBegin());
            //BUG                ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
            //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
            return match.Groups[0];
        }
        //Used in NetFiddle
        internal static Group GetMatch(string pattern, string part, string groupName)
        {
            var rgx = new Regex(pattern);
            var match = rgx.Match(part.EnsureOneSingleSpaceAtBegin());
            //BUG                ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
            //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
            return match.Groups[groupName];
        }
        //Not used anywhere
        internal static MatchCollection GetMatches(string pattern, string part)
        {
            var rgx = new Regex(pattern);
            var matches = rgx.Matches(part.EnsureOneSingleSpaceAtBegin());
            //BUG                    ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 		
            return matches;
        }

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

        #endregion Common

        #region Interval and Date
        internal static string[] dubiousDDMMOrYYYY() => new[] { "2001", "2002", "2003", "2004", "2005", "2006", "2007", "2008", "2009", "2010", "2011", "2012" };
        //https://stackoverflow.com/questions/62703152/convert-two-fields-month-and-year-into-a-yyyy-mm-dd-field
        internal static string[] dubiousMMDDOrYYYY() => new[] { "" };
        //								^^^^^^^^^^^^^^^^^^^^^^^^^^ ??

        #endregion Interval and Date																		

        #region Dates

        /// <summary>
        /// If yearToAssume == string.Empty, it will try to parse with no year 
        /// </summary>
        /// <param name="yearToAssume"></param>
        /// <param name="testDate"></param>
        /// <param name="cultureInfo"></param>
        /// <param name="dateWithNoYearAndWithoutSpace"></param>
        /// <returns></returns>
        internal static bool DateWithNoYearTryParseExact(string dateWithNoYearAndWithoutSpace, out DateTime testDate, CultureInfo cultureInfo, string yearToAssume)
        {
            Guard.ThrowIfStringNullOrEmptyOrNotString(dateWithNoYearAndWithoutSpace, nameof(dateWithNoYearAndWithoutSpace));
            return DateTryParseExact(dateWithNoYearAndWithoutSpace + yearToAssume, out testDate, cultureInfo, string.IsNullOrEmpty(yearToAssume));
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="dateWithoutSpace"></param>
        /// <param name="testDate"></param>
        /// <param name="cultureInfo"></param>
        /// <param name="forceDDMM"></param>
        /// <returns></returns>
        internal static bool DateTryParseExact(string dateWithoutSpace, out DateTime testDate, CultureInfo cultureInfo
            , bool forceDDMM = false)
        {
            //https://dotnetfiddle.net/F6fGPt
            //https://learn.microsoft.com/en-us/dotnet/standard/base-types/parsing-datetime
            //https://stackoverflow.com/questions/10029099/datetime-parse2012-09-30t230000-0000000z-always-converts-to-datetimekind-l
            Guard.ThrowIfStringNullOrEmptyOrNotString(dateWithoutSpace, nameof(dateWithoutSpace));
            var yyyy = forceDDMM ? string.Empty : DateFormat.yyyy.GetDescription();
            var isDDMM = cultureInfo.Name == "pt-BR";
            var ddMMyyyy = isDDMM ? DateFormat.ddMMyyyy.GetDescription() : DateFormat.MMddyyyy.GetDescription();
            var ddMMMyyyy = isDDMM ? DateFormat.ddMMMyyyy.GetDescription() : DateFormat.MMMddyyyy.GetDescription();
            var ddMMMMyyyy = isDDMM ? DateFormat.ddMMMMyyyy.GetDescription() : DateFormat.MMMMddyyyy.GetDescription();
            var ddMM = isDDMM ? DateFormat.ddMM.GetDescription() : DateFormat.MMdd.GetDescription();
            var ddMMM = isDDMM ? DateFormat.ddMMM.GetDescription() : DateFormat.MMMdd.GetDescription();
            var ddMMMM = isDDMM ? DateFormat.ddMMMM.GetDescription() : DateFormat.MMMMdd.GetDescription();
            var ddMMyyyyHHmmssWithSlash = isDDMM ? DateFormat.completeUpToSeconds.GetDescription() : DateFormat.completeUpToSecondsUS.GetDescription();
            return DateTime.TryParse(dateWithoutSpace, cultureInfo, DateTimeStyles.None, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, yyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, DateFormat.MMMMyyyy.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, DateFormat.MMMyyyy.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, DateFormat.MMyyyy.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, ddMMyyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, ddMMMyyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, ddMMMMyyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, ddMM, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, ddMMM, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, ddMMMM, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, ddMMyyyyHHmmssWithSlash, cultureInfo, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, DateFormat.universalSortable.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, DateFormat.sortable.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out testDate);
            //https://stackoverflow.com/questions/13457458/difference-between-universalsortabledatetimepattern-and-sortabledatetimepattern
            //https://stackoverflow.com/questions/3025361/c-sharp-datetime-to-yyyymmddhhmmss-format
            //// create date time 2008-03-09 16:05:07.123
            //            DateTime dt = new DateTime(2008, 3, 9, 16, 5, 7, 123);

            //            String.Format("{0:y yy yyy yyyy}",      dt);  // "8 08 008 2008"   year
            //            String.Format("{0:M MM MMM MMMM}",      dt);  // "3 03 Mar March"  month
            //            String.Format("{0:d dd ddd dddd}",      dt);  // "9 09 Sun Sunday" day
            //            String.Format("{0:h hh H HH}",          dt);  // "4 04 16 16"      hour 12/24
            //            String.Format("{0:m mm}",               dt);  // "5 05"            minute
            //            String.Format("{0:s ss}",               dt);  // "7 07"            second
            //            String.Format("{0:f ff fff ffff}",      dt);  // "1 12 123 1230"   sec.fraction
            //            String.Format("{0:F FF FFF FFFF}",      dt);  // "1 12 123 123"    without zeroes
            //            String.Format("{0:t tt}",               dt);  // "P PM"            A.M. or P.M.
            //            String.Format("{0:z zz zzz}",           dt);  // "-6 -06 -06:00"   time zone

            //// month/day numbers without/with leading zeroes
            //            String.Format("{0:M/d/yyyy}",           dt);  // "3/9/2008"
            //            String.Format("{0:MM/dd/yyyy}",         dt);  // "03/09/2008"

            //// day/month names
            //            String.Format("{0:ddd, MMM d, yyyy}",   dt);  // "Sun, Mar 9, 2008"
            //            String.Format("{0:dddd, MMMM d, yyyy}", dt);  // "Sunday, March 9, 2008"

            //// two/four digit year
            //            String.Format("{0:MM/dd/yy}",           dt);  // "03/09/08"
            //            String.Format("{0:MM/dd/yyyy}",         dt);  // "03/09/2008"
        }

        internal static IEnumerable<DocName> OrderDocsByDate(IEnumerable<DocName> docs)
        {
            //DONE put a field that merge Date and, if date is null, the Last part of interval
            //return docs.OrderBy(x => x.HasDate ? x.GetDateTime() : x.GetLastPartOfIntervalTime() );
            return docs.OrderBy(x => x.GetDateTimeOrLastPartOfIntervalForOrderDoc());
        }

        #endregion Dates
    }

//################################################################################### DocNameHelper 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;
	public static DateTime ThisDateOrAppropriateMinimalDateTime(this DateTime @this) => (DateTime)(@this < @this.MinimumWinFormDateTime() || @this == NullOutlookDateTime(@this) ? @this.MinimumWinFormDateTime() : @this);
	public static bool IsThisDateNullOrDefault(this DateTime @this) => @this == @this.MinimumWinFormDateTime() || @this == NullOutlookDateTime(@this) || @this == DateTime.MaxValue || @this == DateTime.MinValue || @this == @this.OutlookDefaultDateForInvalidEntry() || @this < @this.OutlookEarliestDateThatDoesNotProvokeError();
	public static DateTime ThisDateCandidateOrDateTimeMinimal(this string stringToBeParsed)
	{
		DateTime @this = default;
		if (stringToBeParsed == null || !DateTime.TryParse(stringToBeParsed, out @this))
			return DateTime.MinValue;
		return @this;
	}

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

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

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

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

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

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

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

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

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

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

		return string.Empty;
	}

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

		return string.Empty;
	}

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

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

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

		return stringBuilder.ToString();
	}

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

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

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

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

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

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

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

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

		return new string (array);
	}

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

		return newText.ToString();
	}
    public static string TrimLastCharacter(this String str) => String.IsNullOrEmpty(str) ? str : str.TrimEnd(str[str.Length - 1]);

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

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

		return false;
	}

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

		return false;
	}

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

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

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

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

	public static bool IsDate(this string @this, out DateTime date) => DateTime.TryParse(@this, out date);
	public static bool IsDate(this string @this) => DateTime.TryParse(@this, out var date);
	/// <summary>
	/// https://stackoverflow.com/questions/7461080/fastest-way-to-check-if-string-contains-only-digits-in-c-sharp
	/// TryParse won't work in some situations, like what happens if the string is a credit card number with 16 digits
	/// or if DateTime is in sortable format, like "20210620150000"
	/// </summary>
	/// <param name = "this"></param>
	/// <returns></returns>
	public static bool IsNumber(this string @this) => int.TryParse(@this, out var number);
	public static bool IsDigit(this string @this) => @this.All(c => c >= '0' && c <= '9');
}

// ###################            ##################################      StringTextExtensions      ##################################            ###################
// ###################            ##################################      EasyOfficeFolderExtensions      ##################################            ###################
public static class EasyOfficeFolderExtensions
{
	public static string GetParentFolder(this string pathSource)
	{
		//https://stackoverflow.com/a/30902714/2752308
		return Path.GetFullPath(Path.Combine(pathSource, @"..\"));
	}

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

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

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

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

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

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

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

		return default(T);
	}

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

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

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

		return enumDL;
	}

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

		return enumDL;
	}

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

		return enumDL;
	}

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

​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;
​
#region private::tests
public class Program
{
    public static void Main()
    {
        //Console.Writeline("Hello");
        TestNameParts();
    }
    public static void TestNameParts()
    {/**/
        string[] nameTests = {/**/ "Prontuário Itau com anotações entre 2007 e 2021.pdf"
                        , "Recibos comparecimento a Fisioterapia entre 052016 e 122019.pdf"
                        , "US abdominal˗cisto hepático_5f9a739a-0b2e-4fcc-9228-81035e6e50ea 23122022 v3.docx"
                        , "Ruy Quiroga_20230605161406.pdf"
                        , "Aderaldo Vieira Chaves - SOLICITAÇÃO DE EXAME_5f9a739a-0b2e-4fcc-9228-81035e6e50ea.pdf"
                        , "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"
                        , "Nome do paciente - exame laboratorial amplo 3 - 23122022.docx"
                        , "Nome do paciente - exame laboratorial amplo - 10122022 2.docx", "Nome do paciente - exame laboratorial amplo - 122021 2.docx"
                        , "Nome do paciente - relatório internação de 12 a 12122022 - 2 20__.docx"
                        , "Nome do paciente - exame laboratorial amplo - 23122022 v2.docx", "Nome do paciente - exame laboratorial amplo v3 - 23122022.docx"
                        , "Nome do paciente - exame laboratorial amplo - 122022 v2.docx", "Nome do paciente - relatório internação de 12 a 20122022 - v2 20__.docx"
                        , "US abdominal-cisto hepático 23122022.docx", "US abdominal˗cisto hepático 23122022.docx", "US abdominal–cisto hepático 23122019.docx"
                        , "US abdominal - cisto hepático 29122022.docx", "US abdominal - cisto hepático v3 23122022.doc", "US abdominal 21122022.docx"
                        , "US abdominal - 23122022.docx", "Nome do paciente - exame laboratorial amplo v2 - 23122022.docx", "Nome do paciente - v2 20122012.docx"
                        , "Outro paciente - exame laboratorial amplo para home-care - v2 23122022.docx", "Nome do paciente - relatório internação de 12 a 20122022 - v2 20122011.docx"
                        , "Nome do paciente - exame laboratorial amplo - 202_ v3.docx"
                        , "Nome do paciente D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Ciprofloxacino 500 mg 2017.pdf", "Fulano Sicrano Beltrano - relatório internação - de 1208 até 20062021 - erosão traqueal - v2 12072021.docx" 
                        /**/};
        var docs = new List<DocName>();
        foreach (var fileName in nameTests)
        {
            var docName = DocName.CreateInstance(fileName, new MessageDialogServiceNone(), false);
            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.Part : n.FirstPartName.Error)}");// .ToString());//
            Console.WriteLine();
            //Console.WriteLine($"MiddlePart: {(n.MiddlePartName.IsSuccess ? n.MiddlePartName.Value.Part : n.MiddlePartName.Error)}");// .ToString());//
            Console.WriteLine();
            //Console.WriteLine($"LastPart: {(n.LastPartName.IsSuccess ? n.LastPartName.Value.Part : 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 ##########################################################################################                          
//################################################################################### 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 = "pt-BR", 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;
            Culture = new CultureInfo(culture);
            OriginalNameBeforeTreat = fullNameWithExtension;
            GetParts(FixWrongDelimiters(fullNameWithExtension));
        }
​
        /// <summary>
        /// The maximum possible year for a date or interval in a sentence
        /// </summary>
        /// <param name="fullNameWithExtension"></param>
        /// <param name="dialog"></param>
        /// <param name="raiseEvents"></param>
        /// <param name="maxPossibleYear"></param>
        /// <returns></returns>
        public static DocName CreateInstance(string fullNameWithExtension, IMessageDialogService dialog, bool raiseEvents, int maxPossibleYear = int.MinValue)
        {
            if (maxPossibleYear == int.MinValue)
                maxPossibleYear = DateInSentence.GetMaxPossibleYear();
            return new DocName(fullNameWithExtension, dialog, raiseEvents) { MaxPossibleYear = maxPossibleYear };
        }
        /// <summary>
        /// For Serialization ONLY; coding use the other without dialog Argument
        /// </summary>
        public static DocName None(IMessageDialogService dialog) => new(string.Empty, dialog, false);
        /// <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, Culture, 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, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
            return new DocName(FullName, _dialog, _raiseEvents) { MaxPossibleYear = this.MaxPossibleYear};
        }
        public DocName PromoteIntoPatientDoc(string fullName)
        {
            FirstPartName = Result.Success(NamePart.DefinePart(fullName, DocNamePart.First, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
            return new DocName(FullName, _dialog, _raiseEvents) { 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 CultureInfo Culture { 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)> WrongDelimiter { get; private set; } = new();
        public int MaxPossibleYear { get; private set; } = 2025;
​
        /// <summary>
        /// if WrongDelimiter.Any() || OriginalNumberOfParts > _maxNumOfParts
        /// </summary>
        public bool OriginalNameCannotBeRehydrated => WrongDelimiter.Any() || OriginalNumberOfParts > _maxNumOfParts || !OriginalNameBeforeTreat.Equals(FullNameWithExtension); 
​
        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 Result<NamePart> LastPartName { get; private set; }
        public Result<string> LastPartNameOriginal { 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;
        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));
                }
                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)
        {
            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, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
            FirstPartNameOriginal = matchesList[0].Trim();
            OriginalNumberOfParts = matchesList.Count;
            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, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
                    i = 2;
                    LastPartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(matchesList[i].Trim()));
                    LastPartName = Result.Success(NamePart.DefinePart(matchesList[i].Trim(), DocNamePart.Last, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
                    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, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
                    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);
                    }
                    MiddlePartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(joinMiddleParts.Trim()));
                    MiddlePartName = Result.Success(NamePart.DefinePart(joinMiddleParts.Trim(), DocNamePart.Middle, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
                    LastPartNameOriginal = Result.Success(IfNeededReplaceFakeDelimiter(matchesList[matchesList.Count - 1].Trim()));
                    LastPartName = Result.Success(NamePart.DefinePart(matchesList[matchesList.Count - 1].Trim(), DocNamePart.Last, Culture.Name, Delimiter, FakeDelimiter, MaxPossibleYear));
                    break;
            }
        }
        private static (string name, string extension) DivideDocNameFromExtension(string input)
        {
            var rgx = new Regex(GrabNameAndExtension);
            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; }
        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 = new Regex(GrabFakeDelimiterWithoutAnySpaceAround);
            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 = new Regex(GrabPartsOfName);
            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, Delimiter, DocNamePart.First)}"
                + $"{GeneratePartOfNameIncludingSimplePartConcatenated(MiddlePartName, Delimiter, DocNamePart.Middle)}"
                + $"{GeneratePartOfNameIncludingSimplePartConcatenated(LastPartName, Delimiter, DocNamePart.Last)}";
        }
        private string GeneratePartOfNameIncludingSimplePartConcatenated(Result<NamePart> part, string delimiter,
            DocNamePart whichPart)
        {
            string? name;
            if (whichPart == DocNamePart.First)
            {
                name = part.IsFailure
                    ? string.Empty
                    : @$"{part.Value.GetPartNameElements}";
                    //: @$"{part.Value.GetConcatenatedPartNameElements(FakeDelimiter, Delimiter)}";
            }
            else
            {
                name = part.IsFailure
                    ? string.Empty
                    : @$" {delimiter}{(string.IsNullOrEmpty(part.Value.GetPartNameElements) ? "" : " ")}{part.Value.GetPartNameElements.Trim()}";
            }
            return name;//.RemoveUnnecessarySpaces();
        }
​
        #endregion Private Methods
​
        #region Overrides of ValueObject
​
        protected override IEnumerable<object> 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 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 CultureInfo Culture { 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
​
        #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)
        {
            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,
                Culture = new CultureInfo(culture),
                Delimiter = delimiter,
                FakeDelimiter = fakeDelimiter
            };
            instance.MaxPossibleYear = maxPossibleYear;
            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, CultureInfo.CurrentCulture, MaxPossibleYear);
            var dateInSentence =
                DateInSentence.CreateInstanceFromSentence(_partText, Culture, (GUIDInPart.StartIndex, GUIDInPart.EndOriginal), MaxPossibleYear);
            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, Culture, (GUIDInPart.StartIndex, GUIDInPart.EndOriginal), MaxPossibleYear);
            }
            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);
                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;
        }
        #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))
            {
                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.Normal && 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.Normal && dateInSentence.DateText == intervalInSentence.ElementValue.Value;
        }
​
        /// <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
​
        #region Common
​
        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
​
        #endregion Private Methods
​
        #region Overrides of ValueObject
        protected override IEnumerable<object> 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 ##########################################################################################                                                         
//################################################################################### InNameGUID ##########################################################################################
public class InNameGUID : BaseElement//ValueObject
{
    private const string Grab_GUID_treated = @"(?<GUID>[0-9a-f]{8}<>[0-9a-f]{4}<>[0-9a-f]{4}<>[0-9a-f]{4}<>[0-9a-f]{12})";
​
    private InNameGUID(int 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 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<object> 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
        {
            //Try to look list of words only
            //until now is losing below
            //Gilda Elena Brandão Andrade D'Oliveira - RECEITUÁRIO CONTROLE ESPECIAL - Fosfomicina 20__.docx
            var criteria = new string[]{"Receita de Antibióticos", "Receita de Psicotrópicos"};
            var medicines = GetWordsThatPointsToType(criteria);
            foreach (var medicine in medicines)
            {
                if (!OriginalText.ToLowerInvariant().Contains(medicine.ToLowerInvariant()))
                    continue;
                Name = medicine.CapitalizeFirstLetter();
                Dosage = "N/A";
                Unit = "N/A";
                Form = "N/A";
            }
        }
    }
​
    private static IEnumerable<string> GetWordsThatPointsToType(string[] criteria)
    //private static List<string> GetWordsThatPointsToType(string[] criteria)
    {
        return new string[] { "Receita de Antibióticos", "Receita de Psicotrópicos" };
    }
​
        #endregion Private Methods
        #region Overrides of ValueObject
​
        protected override IEnumerable<object> 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);
        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 static Result<string> GetVersionFromPart(string partToTest)
    {
        var version = DocNameHelper.ReturnResult(GrabVersionFromFile, partToTest, "version", "No file version");
        if (version.IsFailure && !char.IsWhiteSpace(partToTest, 0))
            version = DocNameHelper.ReturnResult(GrabVersionFromFile, $" {partToTest}", "version", "No file version");
        return version;
    }
​
    public static Result<string> TryRecoverFileVersionOnlyNumber(Result<string> fileDateOrInterval, Result<string> partNameToTest)
    {
        // special case:
        //  Nome do paciente - exame laboratorial amplo - 122022 2.docx######
        //   FirstPartName: Nome do paciente
        //   MiddlePartName: exame laboratorial amplo
        //   MiddlePartNameOriginal: exame laboratorial amplo
        //   LastPartName: 2
        //   LastPartNameOriginal: 122022 2
        //   FileVersion: No file version
        //   FileDate: 122022
        var rest = string.Empty;
        int tryVersion;
        if (fileDateOrInterval.IsSuccess)
        {
            rest = partNameToTest.Value.Replace(fileDateOrInterval.Value, string.Empty).Trim();
            // if (!int.TryParse(rest, out tryVersion)) return Result.Failure<string>("No file version");
            int.TryParse(rest, out tryVersion);
            if (tryVersion is > 0 and < 20)
                return Result.Success(tryVersion.ToString());
        }
​
        // special case:
        //Nome do paciente - exame laboratorial amplo 3 - 23122022.docx######
        //FirstPartName: Nome do paciente
        //MiddlePartName: exame laboratorial amplo 3
        //MiddlePartNameOriginal: exame laboratorial amplo 3
        //LastPartName:
        //LastPartNameOriginal: 23122022
        //FileVersion: No file version
        //FileDate: 23122022
        var restNum = rest.ReturnOnlyNumbersToArray();
        if (restNum.Length != 1 || !int.TryParse(restNum[0].ToString(), out tryVersion)) return Result.Failure<string>("No file version");
        return tryVersion is > 0 and < 20 ? Result.Success(tryVersion.ToString()) : Result.Failure<string>("No file version");
    }
    #endregion Private Methods
​
    #region Overrides of ValueObject
​
    protected override IEnumerable<object> GetEqualityComponents()
    {
        yield return _originalSentenceToParseDate;
        yield return Version;
    }
​
    #endregion
}
//################################################################################### VersionInSentence   End ##########################################################################################
//################################################################################### DateInSentence  ##########################################################################################
public class DateInSentence : BaseElement// ValueObject
{
    private readonly CultureInfo _cultureInfo;
    private readonly int? _maxPossibleYear;
    private readonly bool _forceDdmMorMmdd;
    private readonly int _minPossibleYear;
    private readonly bool _acceptWildCard;
​
    #region Public Constants
    //public const string GrabDatesWithMonthsInLettersOrPureNumbersFromFile = @"(?<relationandinterval>(?<temporalrelation> em )?(?<=\W)(?<intervalordate>(?:\d{6,8}|\d{2,3}_{1,2})|(?:\b(0?[1-9]|[12][0-9]|3[01])*(?: de )?([JFMASONDjfmasond]([a-z0-9]+)([ç]{0,1})([a-z0-9]+)*)*(?: de )?(19|20)?[0-9]{2}\b)))";
    //https://regex101.com/r/ZuUZy3/9^^^^^^^^^^^^
    public const string GrabDatesWithMonthsInLettersOrPureNumbersFromFile = @"(?<relationandinterval>(?<temporalrelation> em | por )?(?<=\W)(?<intervalordate>(?:\d{6,8}|\d{2,3}_{1,2})|(?:\b(0?[1-9]|[12][0-9]|3[01])*(?: de )?([JFMASONDjfmasond]([a-z0-9]+)([ç]{0,1})([a-z0-9]+)*)*(?: de )?(19|20)?[0-9]{2}\b))(?<timeframe> ano | anos | mês | meses | dia | dias )?)";
    //https://regex101.com/r/ZuUZy3/11^^^^^^^^^^^^
    //https://stackoverflow.com/a/10033196/2752308 ^^^^^^ 
    public const string GrabDatesOrPureNumbersFromPartOfFile = @"(?<date>\d{6,8}|\d{2,3}_{1,2})";
    //https://regex101.com/r/DfGFk5/1   https://www.utctime.net/
    public const string GrabDatesUTC = @"(?<dateUTC>(?<year>-?(?:[1-9][0-9]*)?[0-9]{4})-(?<month>1[0-2]|0[1-9])-(?<day>3[01]|0[1-9]|[12][0-9])T(?<hour>2[0-3]|[01][0-9]):(?<minute>[0-5][0-9]):(?<second>[0-5][0-9])(\\.[0-9]+)?(?<zeroUTCoffse>Z)?|(?<year>(?:[1-9][0-9]*)?[0-9]{4})(?<month>1[0-2]|0[1-9])(?<day>3[01]|0[1-9]|[12][0-9])(?<hour>2[0-3]|[01][0-9])(?<minute>[0-5][0-9])(?<second>[0-5][0-9])(\\.[0-9]+)?(?<zeroUTCoffse>Z)?)";
    //Use it only to extract from PartOfName
    public const string GrabDateIntervalFromPartOfFile = @"(?<=\W)(?<interval>(?<starting>[ mçinícandouetr]+?)(?<datebegin>\d+)(?<link>[ eatéfimnldzou]+?)(?<=\W)(?<!\w-)(?<dateend>\d+))";
    //https://regex101.com/r/1UfbIM/1 ^^^^^^^^^^^^^^^^ 
    public const string GrabDateAndVersionDotAtEnd =
        @"(?<date>\d{6,8}|\d{2,3}_{1,2}) {1,2}(?<version>[vVersionão]+[\d@]+[\w@]*|[\d@]+[vVersionão]+[\w@]*).|(?<version>[vVersionão]+[\d@]+[\w@]*|[\d@]+[vVersionão]+[\w@]*) {1,2}(?<date>\d{6,8}|\d{2,3}_{1,2})\.|(?<date>\d{6,8}|\d{2,3}_{1,2})\.";
    //https://regex101.com/r/TpTA1n/2 ^^^^^^^^^^^^^^^^
    public const string WildCardForDate = "_";
    #endregion Public Constants
​
    #region Public Fields
    public string DateText { get; private set; } = string.Empty;
    public DateTime DateAndTime { get; private set; } = DateTime.MinValue;
​
    /// <summary>
    /// When TypeInterval == TimeFrame, DateTime == DateTime.MinValue and
    /// here will be stored Number of Days, Months or Years
    /// </summary>
    //[JsonIgnore]
    public int IntervalTimeFrame => int.Parse(DateText);
​
    public DateFormat Mask { get; private set; } = DateFormat.NoDate;
    public CertaintyAboutElement CertaintyAbout { get; private set; } = CertaintyAboutElement.NonExisting;
    public bool IsDDMM => _cultureInfo?.Name == "pt-BR";
    public bool HasDate => DateAndTime != DateTime.MinValue;
    #endregion Public Fields
​
    #region Constructors
    //[JsonConstructor]
    private DateInSentence()
    {
​
    }
    private DateInSentence(string dateText, DateTime dateTime, DateFormat mask, CertaintyAboutElement certaintyAbout)
    {
        DateText = dateText;
        DateAndTime = dateTime;
        Mask = mask;
        CertaintyAbout = certaintyAbout;
    }
​
    private DateInSentence(string originalSentenceToParseDate, CultureInfo cultureInfo, int? maxPossibleYear,
        bool forceDDMMorMMDD, int minPossibleYear, bool acceptWildCard)
    {
        OriginalText = originalSentenceToParseDate;
        _cultureInfo = cultureInfo;
        _maxPossibleYear = maxPossibleYear ??= GetMaxPossibleYear();
        _forceDdmMorMmdd = forceDDMMorMMDD;
        _minPossibleYear = minPossibleYear;
        _acceptWildCard = acceptWildCard;
    }
​
    public static DateInSentence NullDate => 
        new(string.Empty, DateTime.MinValue, DateFormat.NoDate, CertaintyAboutElement.NonExisting);
​
    public static DateInSentence ChangeMask(DateInSentence date, DateFormat newMask)
    {
        return CreateInstance(date.DateText, date.DateAndTime, newMask);
    }
    public static DateInSentence ChangeToYYYY(DateInSentence date, DateFormat newMask)
    {
        if (date.DateText.Length != 4) throw new ArgumentException("Can only change mask of DDMM or MMDD to YYYY");
        return CreateInstance(date.DateText, date.DateAndTime, DateFormat.yyyy);
    }
​
    public static DateInSentence ChangeToMMDD(DateInSentence date, DateFormat newMask)
    {
        if (date.DateText.Length != 4) throw new ArgumentException("Can only change mask of DDMM or YYYY to MMDD");
        return CreateInstance(date.DateText, date.DateAndTime, DateFormat.MMdd);
    }
    public static DateInSentence ChangeToDDMM(DateInSentence date, DateFormat newMask)
    {
        if (date.DateText.Length != 4) throw new ArgumentException("Can only change mask of MMDD or YYYY to DDMM");
        return CreateInstance(date.DateText, date.DateAndTime, DateFormat.ddMM);
    }
    public static DateInSentence CreateInstanceTimeFrame(string dateText, DateFormat mask, CertaintyAboutElement certaintyAbout = CertaintyAboutElement.AbsolutelyCertain)
    {
        //if (!int.TryParse(dateText, out _)) throw new ArgumentException("dateText must be a number");
        return new DateInSentence(dateText, DateTime.MinValue, mask, certaintyAbout);
    }
    public static DateInSentence CreateInstance(string dateText, DateTime dateTime, DateFormat mask, CertaintyAboutElement certaintyAbout = CertaintyAboutElement.AbsolutelyCertain)
    {
        return new DateInSentence(dateText, dateTime, mask, certaintyAbout);
    }
    /// <summary>
    /// Create Instance inferring Mask and Format for Date Parsing
    /// </summary>
    public static DateInSentence CreateInstance(string dateToParse, CultureInfo cultureInfo, int? maxPossibleYear,
        bool forceDDMMorMMDD = false, int minPossibleYear = 1990, bool acceptWildCard = true)
    {
        var dateParsing = new DateInSentence(dateToParse, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
        var 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(), 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 (string.IsNullOrEmpty(dateParsing.DateText))
                throw new NotImplementedException("InferMaskAndFormatForDateParsing: dateParsing is not digit, ie, MMM or MMMM or ddd or dd or tt");                
            
        }
        //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(CultureInfo cultureInfo, string raw, DateInSentence dateParsing)
    {
        DateTime parsedDate;
        if (raw.Contains(WildCardForDate) && raw.Length == 4)
        {
            //202_
            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;
            //return dateParsing;
        }
​
        if (!raw.Contains(WildCardForDate) && raw.Length == 7)
        {
            //fev2021
            dateParsing.Mask = DateFormat.MMMyyyy;
            _ = DateTime.TryParseExact(raw, dateParsing.Mask.GetDescription(), cultureInfo, DateTimeStyles.None,
                out parsedDate);
            dateParsing.DateText = raw;
            dateParsing.DateAndTime = parsedDate;
            dateParsing.CertaintyAbout = CertaintyAboutElement.AbsolutelyCertain;
            //return dateParsing;
        }
        //GrabDatesWithMonthsInLettersOrPureNumbersFromFile
        //grab: 202_
        //[Description("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'")]
        //universalSortable     
    }
​
    private static void TryParseNumericOnlyDates(CultureInfo cultureInfo, int? maxPossibleYear, bool forceDDMMorMMDD,
        int minPossibleYear, string raw, DateInSentence dateParsing)
    {
        if (raw.Length == DateFormat.sortable.GetDescription().Length) //yyyyMMddHHmmss
        {
            //[Description("yyyyMMddHHmmss")]
            //sortable,
            dateParsing.Mask = DateFormat.sortable;
        }
        //[Description("dd/MM/yyyy HH:mm:ss")]
        //completeUpToSeconds,
        //[Description("MM/dd/yyyy HH:mm:ss")]
        //completeUpToSecondsUS,
        else if (raw.Length == 8) //ddmmyyyy or mmddyyyy
        {
            dateParsing.Mask = dateParsing.IsDDMM ? DateFormat.ddMMyyyy : DateFormat.MMddyyyy;
        }
        else if (raw.Length == 6) //MMyyyy 
        {
            dateParsing.Mask = DateFormat.MMyyyy;
        }
        else if (raw.Length == 4) //ddMM OR MMdd OR yyyy
        {
            var yyyyToTestIfWithinAllowedRange = DateTime.MinValue;
            var maybeDDMMorMMDD = IsItPossibleToBeDDMMOrMMDD(raw, cultureInfo);
            //DateTime.TryParseExact(dateParsing, DateFormat.ddMM.GetDescription(), cultureInfo, DateTimeStyles.None, out _) ||
            // DateTime.TryParseExact(dateParsing, DateFormat.MMdd.GetDescription(), cultureInfo, DateTimeStyles.None, out _);
            var maybeYYYY = DateTime.TryParseExact(raw, DateFormat.yyyy.GetDescription(), cultureInfo, DateTimeStyles.None,
                out yyyyToTestIfWithinAllowedRange);
            if ((maybeDDMMorMMDD && !maybeYYYY) || forceDDMMorMMDD)
                dateParsing.Mask = dateParsing.IsDDMM ? DateFormat.ddMM : DateFormat.MMdd;
            else if (!maybeDDMMorMMDD && maybeYYYY)
                dateParsing.Mask = DateFormat.yyyy;
            else if (maybeDDMMorMMDD && maybeYYYY)
            {
                //assume yyyy if possible ????
                dateParsing.CertaintyAbout = CertaintyAboutElement.InformedGuess;
                if (yyyyToTestIfWithinAllowedRange >= new DateTime(minPossibleYear, 1, 1) &&
                    yyyyToTestIfWithinAllowedRange <= new DateTime(maxPossibleYear.Value, 1, 1))
                    //https://stackoverflow.com/questions/3871299/asp-net-c-sharp-parse-int-as-datetime
                    dateParsing.Mask = DateFormat.yyyy;
                else
                    dateParsing.Mask = dateParsing.IsDDMM ? DateFormat.ddMM : DateFormat.MMdd;
            }
            else if (maybeDDMMorMMDD && maybeYYYY)
            {
                //?????
                dateParsing.Mask = DateFormat.NoDate;
                dateParsing.CertaintyAbout = CertaintyAboutElement.NonExisting;
            }
        }
        else if (raw.Length == 2) //dd OR MM OR yy
        {
            throw new NotImplementedException("InferMaskAndFormatForDateParsing: dateParsing.Length == 2");
        }
    }
​
    public static DateInSentence CreateInstanceFromSentence(string dateToParse, CultureInfo cultureInfo 
        ,(int start, int end) forbiddenZoneCoordinates, int? maxPossibleYear
        , bool forceDDMMorMMDD = false, int minPossibleYear = 1990, bool acceptWildCard = true)
    {
        //var dateInSentence = new DateInSentence(dateToParse, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
        var hasDate = GetDateStatic(dateToParse, cultureInfo, forbiddenZoneCoordinates, acceptWildCard);
        if (hasDate.IsFailure)
            return DateInSentence.NullDate;
        return CreateInstance(hasDate.Value, cultureInfo, maxPossibleYear, forceDDMMorMMDD, minPossibleYear, acceptWildCard);
    }
    public static Result<DateInSentence> Update(string date, DateInSentence valueDateInSentence)
    {
        var 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;
    }
    public Result<string> GetDate(string partToTest, (int start, int end) forbiddenZoneCoordinates)
        //public static Result<string> GetDateStatic(string partToTest, DocNamePart partName, InNameGUID partHasGUID)   
    {
        if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest))
            return Result.Failure<string>("No date stamp in this file name");
        var hasDate = ReturnDateResult(GrabDatesUTC, partToTest, "dateUTC",
            "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates);
        //"No date stamp in this file name", partName, partHasGUID);
        if (hasDate.IsFailure)
        {
            hasDate = ReturnDateResult(GrabDatesOrPureNumbersFromPartOfFile, partToTest, "date",
                "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates);
            //"No date stamp in this file name", partName, partHasGUID);                
        }
        if (hasDate.IsFailure)
        {
            hasDate = ReturnDateResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "intervalordate",
                "No date stamp in this file name", _cultureInfo, forbiddenZoneCoordinates);
            //"No date stamp in this file name", partName, partHasGUID);                
        }
        if (hasDate.IsSuccess)
        {
            hasDate = FilterAbsurdDates(hasDate, _cultureInfo, _acceptWildCard, "No date stamp in this file name");
        }
        return hasDate;
    }
    #endregion Constructors
​
    #region Private Methods
    public static Result<string> GetDateStatic(string partToTest, CultureInfo cultureInfo, (int start, int end) forbiddenZoneCoordinates, bool acceptWildCard = true)
        //public static Result<string> GetDateStatic(string partToTest, DocNamePart partName, InNameGUID partHasGUID)   
    {
        if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest))
            return Result.Failure<string>("No date stamp in this file name");
        var hasDate = ReturnDateResult(GrabDatesUTC, partToTest, "dateUTC",
            "No date stamp in this file name", cultureInfo, forbiddenZoneCoordinates);
        //"No date stamp in this file name", partName, partHasGUID);
        if (hasDate.IsFailure)
        {
            hasDate = ReturnDateResult(GrabDatesOrPureNumbersFromPartOfFile, partToTest, "date",
                "No date stamp in this file name", cultureInfo, forbiddenZoneCoordinates);
            //"No date stamp in this file name", partName, partHasGUID);                
        }
        if (hasDate.IsFailure)
        {
            hasDate = ReturnDateResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "intervalordate",
                "No date stamp in this file name", cultureInfo, forbiddenZoneCoordinates);
            //"No date stamp in this file name", partName, partHasGUID);                
        }
        if (hasDate.IsSuccess)
        {
            hasDate = FilterAbsurdDates(hasDate, cultureInfo, acceptWildCard, "No date stamp in this file name");
        }
        return hasDate;
    }
    internal static int GetCurrentYearPlus(int toAddCurrent) => DateTime.Now.Year + toAddCurrent;
    internal static int GetMaxPossibleYear(int yearsAhead = 2) => DateTime.Now.Year + yearsAhead;
    internal static bool IsItPossibleToBeDDMMOrMMDD(string dateToTest, CultureInfo cultureInfo)
    {
        if (dateToTest.Length != 4) return false;
        return DateTime.TryParseExact(dateToTest, DateFormat.ddMM.GetDescription(), cultureInfo, DateTimeStyles.None, out _) ||
               DateTime.TryParseExact(dateToTest, DateFormat.MMdd.GetDescription(), cultureInfo, DateTimeStyles.None, out _);
    }
​
    private static Result<string> FilterAbsurdDates(
        Result<string> hasDate, CultureInfo cultureInfo, bool acceptWildCard = true
        , string errorMsg = "No date found", int numberOfYearsToConsiderAbsurd = 99)
    {
        if (hasDate.IsFailure)
            return hasDate;
        DateTime testDate = DateTime.MinValue;
        string dateWithoutSpace = string.Empty;
        if (hasDate.Value.DoesNotContainAnySpace())
        {
            dateWithoutSpace = hasDate.Value;
        }
        else
        {
            var dateCandidates = hasDate.Value.Split(' ');
            foreach (var element in dateCandidates)
            {
                if (element.Length > 3 && element.Length < 8)
                {
                    dateWithoutSpace = element;
                }
            }
        }
        if (string.IsNullOrEmpty(dateWithoutSpace)) return Result.Failure<string>(errorMsg);
        if (DocNameHelper.DateTryParseExact(dateWithoutSpace, out testDate, new CultureInfo("pt-BR")))
        //if (DateTime.TryParseExact(dateWithoutSpace, "yyyy", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out testDate)     )
        {
            if (testDate.IsThisDateNullOrDefault())
                return Result.Failure<string>(errorMsg);
            if (Math.Abs(testDate.YearsBetweenNowAndDate()) >= numberOfYearsToConsiderAbsurd)
                return Result.Failure<string>($"Cannot allow set date so many years ({testDate.YearsBetweenNowAndDate()}) far from today");
            return Result.Success(dateWithoutSpace);
            //Console.WriteLine("DateTryParseExact SUCCESS: " + testDate);
        }
        if (acceptWildCard && dateWithoutSpace.Contains(WildCardForDate))
        {
            return Result.Success(dateWithoutSpace);
        }
        //Console.WriteLine("DateTryParseExact FAILURE: " + testDate);
        return Result.Failure<string>($"Invalid date resulting in {testDate.ToString()}");
    }
​
    private static bool InTimeRangeAllowed(int numberOfYearsToConsiderAbsurd, DateTime testDate)
    {
        try
        {
            var tested = Math.Abs(testDate.YearsBetweenNowAndDate());
            return tested < numberOfYearsToConsiderAbsurd;
        }
        catch (Exception)
        {
            return false;
        }
    }
​
    public static Result<string> ReturnDateResult(string pattern, string part, string groupName, string errorMsg
            , CultureInfo cultureInfo, (int start, int end) forbiddenZoneCoordinates)
    {
        Result<string> result;
        var match = DocNameHelper.GetMatch(pattern, part, groupName, errorMsg, out result);
        if (!result.IsFailure && DocNameHelper.OutOfForbiddenZoneIfSamePart(groupName, match, forbiddenZoneCoordinates.start, forbiddenZoneCoordinates.end)) return result;
        //https://stackoverflow.com/questions/38948394/datetime-tryparse-fails-at-yyyy-only
        if (DocNameHelper.DateTryParseExact(part, out var testDate, cultureInfo))
            result = !testDate.IsThisDateNullOrDefault()
                ? Result.Success(part)
                : Result.Failure<string>(errorMsg);
        return result;
    }
    #endregion Private Methods
​
    #region Overrides of ValueObject
    protected override IEnumerable<object> GetEqualityComponents()
    {
        yield return DateText;
        yield return DateAndTime;
        yield return Mask;
        yield return CertaintyAbout;
    }
​
    #endregion
}
//################################################################################### DateInSentence   End ##########################################################################################
//################################################################################### IntervalInSentence ##########################################################################################
public enum IntervalType
{
    Normal = 0, //"de 1203 até 20041999"
    TemporalClue //"em 082021"
}
public class IntervalInSentence : BaseElement// ValueObject
{
​
    #region Private Constants
    private readonly CultureInfo _cultureInfo;
    private readonly bool _sameFrameIntervalIsAllowed;
    private readonly bool _forceBeginDatePreviousYearIfReasonable;
    private readonly string _errorMsg;
    private Result<string> _candidateBegin;
    private Result<string> _candidateEnd;
    #endregion Private Constants
​
    #region Public Constants
    /// <summary>
    /// Should check for equality between relationandinterval and intervalordate; if so, the interval is invalid and should be ignored
    /// </summary>
    public const string GrabDatesWithMonthsInLettersOrPureNumbersFromFile = @"(?<relationandinterval>(?<temporalrelation> em | por )?(?<=\W)(?<intervalordate>(?:\d{6,8}|\d{2,3}_{1,2})|(?:\b(0?[1-9]|[12][0-9]|3[01])*(?: de )?([JFMASONDjfmasond]([a-z0-9]+)([ç]{0,1})([a-z0-9]+)*)*(?: de )?(19|20)?[0-9]{2}\b))(?<timeframe> anos[ .]{0,1}| ano[ .]{0,1}| mês[ .]{0,1}| meses[ .]{0,1}| dias[ .]{0,1}| dia[ .]{0,1})?)";
    //https://regex101.com/r/ZuUZy3/12^^^^^^^^^^^^
    //https://stackoverflow.com/a/10033196/2752308 ^^^^^^ 
    //Use it only to extract from PartOfName
    public const string GrabDateIntervalFromPartOfFile = @"(?<=\W)(?<interval>(?<starting>[ mçinícandouetr]+?)(?<datebegin>\d+)(?<link>[ eatéfimnldzou]+?)(?<=\W)(?<!\w-)(?<dateend>\d+))";
    //https://regex101.com/r/1UfbIM/2 ^^^^^^^^^^^^^^^^ 
    #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; }
​
    #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);
            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)
    {
        MaxPossibleYear = maxPossibleYear;
        _cultureInfo = cultureInfo;
        _sameFrameIntervalIsAllowed = sameFrameIntervalIsAllowed;
        _forceBeginDatePreviousYearIfReasonable = forceBeginDatePreviousYearIfReasonable;
        _errorMsg = errorMsg;
        OriginalText = originalText;
    }
​
    internal static IntervalInSentence CreateInstance(string interval, CultureInfo cultureInfo, int maxPossibleYear, 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);
        return !intervalInSentence.GetIntervalDates(interval) ? IntervalInSentence.Null : intervalInSentence;
    }
    #endregion Constructors
​
    #region Private Methods
    private bool IsDDMM => _cultureInfo.Name == "pt-BR";
    /// <summary>
    ///TODO very tough to predict all dd-mm possibilities and tell them from only yyyy
    /// example de 1208 a 2009 is one in which EndDate maybe dd-mm or yyyy, but not the first
    /// but how can I tell de 2107 a 2009 ??? comparing as dd-mm, interval is valid, but as yyyy, it is not valid
    /// maybe assuming certain yyyy are valid, but I do not know for sure
    /// </summary>
    /// <param name="partToTest"></param>
    /// <param name="errorMsg"></param>
    /// <returns></returns>
    private bool GetIntervalDates(string partToTest)
    {
        if (string.IsNullOrEmpty(partToTest) || DocNameHelper.DifficultyToTestPart(partToTest)) return false;
        var hasInterval = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "interval",
            _errorMsg);
        if (hasInterval.IsSuccess)
        {
            ElementValue = hasInterval;
            _candidateBegin = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "datebegin", _errorMsg);
            _candidateEnd = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, 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(GrabDateIntervalFromPartOfFile, partToTest, "starting", _errorMsg).Value;
            TextBetween = DocNameHelper.ReturnResult(GrabDateIntervalFromPartOfFile, partToTest, "link", _errorMsg).Value;
            IntervalType = IntervalType.Normal;
            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);
            hasInterval = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest,
                "intervalordate", _errorMsg);
            if (result.Equals(hasInterval))
            {
                ElementValue = Result.Failure<string>(_errorMsg);
                return false;// Result.Failure<string>(errorMsg);
            }
            ElementValue = result;
            IntervalType = IntervalType.TemporalClue;
            _candidateBegin = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "intervalordate", _errorMsg);
            _candidateEnd = _candidateBegin;
            if (_candidateBegin.IsFailure) return false;
            TextTemporalRelation = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "temporalrelation", _errorMsg).Value;
            TextBetween = string.Empty;
            TimeFrame = DocNameHelper.ReturnResult(GrabDatesWithMonthsInLettersOrPureNumbersFromFile, partToTest, "timeframe", _errorMsg).Value;
            DateBegin = DateInSentence.CreateInstanceTimeFrame(_candidateBegin.Value, DetermineTimeFrameType(result.Value));
        }
        //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.CreateInstance(dateBegin, validDates.dateStarted, format))
                                    , Result.Success(DateInSentence.CreateInstance(dateEnd, validDates.dateEnded, format)));
                        }
                    }
                    break;
                case 8: //ddMMyyyy
                    var formatEnd = IsDDMM
                        ? DateFormat.ddMMyyyy
                        : DateFormat.MMddyyyy;
                    var dateEndIsDDMM = DateTime.TryParseExact(dateEnd, formatEnd.GetDescription(),
                                                               _cultureInfo, DateTimeStyles.None, out var dateEnded);
                    if (dateBegin.Length == 8) //ddMMyyyy
                    {
                        var beginDDMMDateIsInPreviousYear = CompareDatesWithSameFormat(dateBegin, dateEnd, out var format, out var validDates);
                        if (beginDDMMDateIsInPreviousYear)
                        {
                            return (Result.Success(DateInSentence.CreateInstance(dateBegin, validDates.dateStarted, format))
                                , Result.Success(DateInSentence.CreateInstance(dateEnd, validDates.dateEnded, format)));
                        }
                    }
                    else if (dateBegin.Length == 6) //almost impossible MMyyyy
                    {
                        throw new NotImplementedException("I did not implemented 'de MMyyyy até ddMMyyyy'");
                    }
                    else if (dateBegin.Length == 4) //ddMM
                    {
                        var dateBeginIsDDMM = DateTime.TryParseExact(dateBegin + dateEnded.Year, formatEnd.GetDescription(),
                                                                     _cultureInfo, DateTimeStyles.None, out var ddMMBegin);
                        if (!dateBeginIsDDMM)
                        {
                            errorMsg = "because BeginDate is After EndDate";
                        } 
                        else if (IsBeginDateReallyBeforeEndDate(ddMMBegin, dateEnded))
                        {
                            //return (Result.Success(InNameDate.CreateInstance(dateBegin + dateEnded.Year, ddMMBegin, formatEnd)), 
                            //      Result.Success(InNameDate.CreateInstance(dateEnd, dateEnded, formatEnd))
                            //     );
                            //Above return real tested date; below the original one
                            var formatBegin = IsDDMM
                                ? DateFormat.ddMM
                                : DateFormat.MMdd;
                            if (DateBeginHadToGoBackOneYear)
                                ddMMBegin = ddMMBegin.AddYears(-1);
                            return (Result.Success(DateInSentence.CreateInstance(dateBegin, ddMMBegin, formatBegin)),
                                    Result.Success(DateInSentence.CreateInstance(dateEnd, dateEnded, formatEnd))
                                   );
                        }
                    }
                    else if (dateBegin.Length == 2) //dd
                    {
                        var dayBegin = int.Parse(dateBegin); //dateBegin.Substring(0, 2);
                        if ((dayBegin > 0 && dayBegin < dateEnded.Day) || ((dayBegin == dateEnded.Day) && _sameFrameIntervalIsAllowed))
                        {
                            var dayInterval = Result.Success(DateInSentence.CreateInstance(dateBegin,
                                                                                       new DateTime(dateEnded.Year, dateEnded.Month, dayBegin), DateFormat.dd));
                            return (dayInterval,
                                    Result.Success(DateInSentence.CreateInstance(dateEnd, dateEnded, formatEnd))
                                   );
                        }
                        errorMsg = "because BeginDate is After EndDate";
                    }
                    break;
                case 6: //MMyyyy
                    formatEnd = DateFormat.MMyyyy;
                    dateEndIsDDMM = DateTime.TryParseExact(dateEnd, formatEnd.GetDescription(),
                                                               _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(),
                                                                     _cultureInfo, DateTimeStyles.None, out var ddMMBegin);
                        if (IsBeginDateReallyBeforeEndDate(ddMMBegin, dateEnded))
                        {
                            return (Result.Success(DateInSentence.CreateInstance(dateBegin, ddMMBegin, formatEnd)),
                                    Result.Success(DateInSentence.CreateInstance(dateEnd, dateEnded, formatEnd))
                                   );
                        }
                        errorMsg = "because BeginDate is After EndDate";
                    }
                    else if (dateBegin.Length == 4) //almost impossible ddMM; I do not think about MMyy
                    {
                        throw new NotImplementedException("I did not implemented 'de ddMM até MMyyyy'");
                    }
                    else if (dateBegin.Length == 2) //MM
                    {
​
                    }
                    break;
                case 4: //ddmm OR yyyy ???
                    if (dateBegin.Length == 8) //almost impossible ddMMyyyy
                    {
​
                    }
                    else if (dateBegin.Length == 6) //almost impossible MMyyyy
                    {
​
                    }
                    else if (dateBegin.Length == 4)
                    {
                        //yyyy => dateEnd = yyyy
                        //ddmm => dateEnd = ddmm;
                        var result = DecideIfDateEndIsYYYYOrDDMM(dateBegin, dateEnd, null, sameFrameIntervalIsAllowed: _sameFrameIntervalIsAllowed);
                        if (result.dateBegin.CertaintyAbout != CertaintyAboutElement.NonExisting)
                        {
                            return (Result.Success(result.dateBegin), Result.Success(result.dateEnd));
                        }
                        errorMsg = "not existing BeginDate or EndDate";
                    }
                    else if (dateBegin.Length == 2) //dd OR MM
                    { // dateEnd = ddmm OR MMYY
​
                    }
                    break;
​
            }
​
        }
        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,
       int? maxPossibleYear, int minPossibleYear = 1990, bool sameFrameIntervalIsAllowed = false)
    {
        maxPossibleYear ??= DateInSentence.GetCurrentYearPlus(3);
        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.Value, sameFrameIntervalIsAllowed);
​
        //If both possibilities are valid, I'm betting that if you are not informing YYYY in two MMDD or DDMM interval,
        //it should be YYYY instead
        (dateBeginIsYYYY, dateEndIsYYYY) = DetermineIfIntervalDatesShouldBeYYYY(
            isDateEndDubious, isDateBeginDubious, endDateMaybeYYYY, beginDateMaybeYYYY, dateEndIsYYYY,
            dateBeginIsYYYY);
        var beginCannotBeDDMMOrMMDD = !DateInSentence.IsItPossibleToBeDDMMOrMMDD(dateBeginToTest, _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(), _cultureInfo,
                DateTimeStyles.None, out dateEnded);
            if (!dateEndIsYYYY) return (dateBegin, dateEnd);
            dateBegin = DateInSentence.CreateInstance(dateBeginToTest, dateStarted, DateFormat.yyyy, certaintyAboutYYYY);
            dateEnd = DateInSentence.CreateInstance(dateEndToTest, dateEnded, DateFormat.yyyy, certaintyAboutYYYY);
        }
        else if (dateBeginIsDDMM)
        {
            if (!dateEndIsDDMM || !IsDDMMBeginDateReallyBeforeEndDate(dateBeginToTest, dateEndToTest, formatForDateBeginTry, sameFrameIntervalIsAllowed)) return (dateBegin, dateEnd);
            dateBegin = DateInSentence.CreateInstance(dateBeginToTest, dateStarted, formatForDateBeginTry, certaintyAboutYYYY);
            dateEnd = DateInSentence.CreateInstance(dateEndToTest, dateEnded, formatForDateBeginTry, certaintyAboutYYYY);
        }
        return (dateBegin, dateEnd);
    }
​
    private (bool isDateEndDubious, bool isDateBeginDubious, CertaintyAboutElement certaintyAboutYYYY)
        DecideDegreeOfCertaintyAboutDates(string dateBeginToTest, string dateEndToTest)
    {
        var dubiousDate = _cultureInfo.Name == "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(), _cultureInfo, DateTimeStyles.None, out var beginDate);
        //var beginDate = DateTime.ParseExact(dateBegin, dateFormat.GetDescription(), cultureInfo);
        var endDateValid = DateTime.TryParseExact(dateEnd, dateFormat.GetDescription(), _cultureInfo, DateTimeStyles.None, out var endDate);
        if (!beginDateValid || !endDateValid) return false;
        //var endDate = DateTime.ParseExact(dateEnd, dateFormat.GetDescription(), cultureInfo);
        return IsBeginDateReallyBeforeEndDate(beginDate, endDate);
        //sameFrameIntervalIsAllowed ? 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(), _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, _cultureInfo,
            DateTimeStyles.None, out var dateStarted);
        var dateEndIsDDMM = DateTime.TryParseExact(dateEndToTest, maskForDDMM, _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, CultureInfo.CurrentCulture);
        var validEndInterval =
            DocNameHelper.DateTryParseExact(_candidateEnd.Value, out var endInterval, CultureInfo.CurrentCulture);
        var isValid = beginInterval < endInterval;
        return isValid;
    } 
    #endregion Draft
​
    #region Overrides of ValueObject
​
    protected override IEnumerable<object> 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
}
//################################################################################### IntervalInSentence End ##########################################################################################
//################################################################################### BaseElement  ##########################################################################################
    public class BaseElement : ValueObject
    {
        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<object> GetEqualityComponents()
        {
            yield return StartIndex;
            yield return ConnectorBefore;
            yield return OriginalText;
            yield return 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,
        NoDate = -1,
        yyyy = 0,
        MMyyyy,
        MMMyyyy,
        MMMMyyyy,
​
        MMdd,
        MMMdd,
        MMMMdd,
        MMddyyyy,
        MMMddyyyy,
        MMMMddyyyy,
​
        ddMM,
        ddMMM,
        ddMMMM,
        ddMMyyyy,
        ddMMMyyyy,
        ddMMMMyyyy,
​
        dd,
        MM,
        MMM,
        MMMM,
​
        yyyyMM,
        yyyyMMM,
        yyyyMMMM,
        yyyyMMdd,
        [Description("dd/MM/yyyy HH:mm:ss")]
        completeUpToSeconds,
        [Description("MM/dd/yyyy HH:mm:ss")]
        completeUpToSecondsUS,
        [Description("yyyyMMddHHmmss")]
        sortable,
        [Description("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'")]
        universalSortable
​
    }
    public enum CertaintyAboutElement
    {
        NonExisting = -1,
        AbsolutelyCertain = 0,
        InformedGuess,
        InformedByUser,
        NotSure
    }
    public enum DocNamePart
    {
        NoPart = 0,
        First,
        Middle,
        Last,
        Extension
    }
​
    public enum ElementRelativePosition
    {
        DoesNotExist = 0,
        First,
        Middle,
        Last,
        //Second,
        //Third,
        //Fourth,
        //Fifty
    }
    public enum WhichElementItIs
    {
        DoesNotExist = 0,
        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 Common
        internal static bool DifficultyToTestPart(string partToTest)
        {
            return (partToTest.Length > 10 && partToTest.DoesNotContainAnySpace());
        }
        internal static Result<string> ReturnResult(string pattern, string part, string groupName, string errorMsg)
        {
            _ = GetMatch(pattern, part, groupName, errorMsg, out var result);
            //if ((!result.IsFailure && OutOfForbiddenZoneIfSamePart(groupName, partName, match, partHasGUID)) || !isDate) return result;
            //if (!result.IsFailure && OutOfForbiddenZoneIfSamePart(groupName, match, partHasGUID) || !isDate) return result;
            return result;
        }
        //GetMatch is a poor name...
        //Used in App
        internal static Match GetMatch(string pattern, string part, string groupName, string errorMsg, out Result<string> result)
        {
            var rgx = new Regex(pattern);
            var match = rgx.Match(" " + part.TrimStart());
            //BUG                     ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
            //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
            result = match.Success ? Result.Success(match.Groups[groupName].Value.Trim()) : Result.Failure<string>(errorMsg);
            return match;
        }
        //Used in NetFiddle
        internal static Match GetMatch(string pattern, string part) //, string groupName)
        {
            var rgx = new Regex(pattern);
            var match = rgx.Match(" " + part);
            //BUG                ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
            //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
            return match;
        }
        //Used in NetFiddle
        internal static Group GetMatchMainGroup(string pattern, string part) //, string groupName)
        {
            var rgx = new Regex(pattern);
            var match = rgx.Match(part.EnsureOneSingleSpaceAtBegin());
            //BUG                ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
            //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
            return match.Groups[0];
        }
        //Used in NetFiddle
        internal static Group GetMatch(string pattern, string part, string groupName)
        {
            var rgx = new Regex(pattern);
            var match = rgx.Match(part.EnsureOneSingleSpaceAtBegin());
            //BUG                ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015" 
            //Match m = Regex.Match(input, GrabNameAndExtension, RegexOptions.IgnoreCase);
            return match.Groups[groupName];
        }
        //Not used anywhere
        internal static MatchCollection GetMatches(string pattern, string part)
        {
            var rgx = new Regex(pattern);
            var matches = rgx.Matches(part.EnsureOneSingleSpaceAtBegin());
            //BUG                    ^^^^^ bacalhau because of GetInterval cannot get "em 2012 e 2015", only " em 2012 e 2015"      
            return matches;
        }
​
        internal static bool OutOfForbiddenZoneIfSamePart(string groupName, Match match, int startOfForbiddenZone, int endOfForbiddenZone)
        {
            return BeforeStartOfForbiddenZone(groupName, match, startOfForbiddenZone) && AfterEndOfForbiddenZone(groupName, match, endOfForbiddenZone);
        }
        private static bool BeforeStartOfForbiddenZone(string groupName, Match match, int startOfForbiddenZone)
        {
            return match.Groups[groupName].Index + match.Groups[groupName].Length - 1 < startOfForbiddenZone;
        }
        private static bool AfterEndOfForbiddenZone(string groupName, Match match, int endOfForbiddenZone)
        {
            return match.Groups[groupName].Index > endOfForbiddenZone;
        }
​
        #endregion Common
​
        #region Interval and Date
        internal static string[] dubiousDDMMOrYYYY() => new[] { "2001", "2002", "2003", "2004", "2005", "2006", "2007", "2008", "2009", "2010", "2011", "2012" };
        //https://stackoverflow.com/questions/62703152/convert-two-fields-month-and-year-into-a-yyyy-mm-dd-field
        internal static string[] dubiousMMDDOrYYYY() => new[] { "" };
        //                              ^^^^^^^^^^^^^^^^^^^^^^^^^^ ??
​
        #endregion Interval and Date                                                                        
​
        #region Dates
​
        /// <summary>
        /// If yearToAssume == string.Empty, it will try to parse with no year 
        /// </summary>
        /// <param name="yearToAssume"></param>
        /// <param name="testDate"></param>
        /// <param name="cultureInfo"></param>
        /// <param name="dateWithNoYearAndWithoutSpace"></param>
        /// <returns></returns>
        internal static bool DateWithNoYearTryParseExact(string dateWithNoYearAndWithoutSpace, out DateTime testDate, CultureInfo cultureInfo, string yearToAssume)
        {
            Guard.ThrowIfStringNullOrEmptyOrNotString(dateWithNoYearAndWithoutSpace, nameof(dateWithNoYearAndWithoutSpace));
            return DateTryParseExact(dateWithNoYearAndWithoutSpace + yearToAssume, out testDate, cultureInfo, string.IsNullOrEmpty(yearToAssume));
        }
​
        /// <summary>
        /// 
        /// </summary>
        /// <param name="dateWithoutSpace"></param>
        /// <param name="testDate"></param>
        /// <param name="cultureInfo"></param>
        /// <param name="forceDDMM"></param>
        /// <returns></returns>
        internal static bool DateTryParseExact(string dateWithoutSpace, out DateTime testDate, CultureInfo cultureInfo
            , bool forceDDMM = false)
        {
            //https://dotnetfiddle.net/F6fGPt
            //https://learn.microsoft.com/en-us/dotnet/standard/base-types/parsing-datetime
            //https://stackoverflow.com/questions/10029099/datetime-parse2012-09-30t230000-0000000z-always-converts-to-datetimekind-l
            Guard.ThrowIfStringNullOrEmptyOrNotString(dateWithoutSpace, nameof(dateWithoutSpace));
            var yyyy = forceDDMM ? string.Empty : DateFormat.yyyy.GetDescription();
            var isDDMM = cultureInfo.Name == "pt-BR";
            var ddMMyyyy = isDDMM ? DateFormat.ddMMyyyy.GetDescription() : DateFormat.MMddyyyy.GetDescription();
            var ddMMMyyyy = isDDMM ? DateFormat.ddMMMyyyy.GetDescription() : DateFormat.MMMddyyyy.GetDescription();
            var ddMMMMyyyy = isDDMM ? DateFormat.ddMMMMyyyy.GetDescription() : DateFormat.MMMMddyyyy.GetDescription();
            var ddMM = isDDMM ? DateFormat.ddMM.GetDescription() : DateFormat.MMdd.GetDescription();
            var ddMMM = isDDMM ? DateFormat.ddMMM.GetDescription() : DateFormat.MMMdd.GetDescription();
            var ddMMMM = isDDMM ? DateFormat.ddMMMM.GetDescription() : DateFormat.MMMMdd.GetDescription();
            var ddMMyyyyHHmmssWithSlash = isDDMM ? DateFormat.completeUpToSeconds.GetDescription() : DateFormat.completeUpToSecondsUS.GetDescription();
            return DateTime.TryParse(dateWithoutSpace, cultureInfo, DateTimeStyles.None, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, yyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, DateFormat.MMMMyyyy.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, DateFormat.MMMyyyy.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, DateFormat.MMyyyy.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, ddMMyyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, ddMMMyyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, ddMMMMyyyy, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, ddMM, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, ddMMM, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, ddMMMM, cultureInfo, DateTimeStyles.AssumeLocal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, ddMMyyyyHHmmssWithSlash, cultureInfo, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, DateFormat.universalSortable.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out testDate) ||
                   DateTime.TryParseExact(dateWithoutSpace, DateFormat.sortable.GetDescription(), cultureInfo, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out testDate);
            //https://stackoverflow.com/questions/13457458/difference-between-universalsortabledatetimepattern-and-sortabledatetimepattern
            //https://stackoverflow.com/questions/3025361/c-sharp-datetime-to-yyyymmddhhmmss-format
            //// create date time 2008-03-09 16:05:07.123
            //            DateTime dt = new DateTime(2008, 3, 9, 16, 5, 7, 123);
​
            //            String.Format("{0:y yy yyy yyyy}",      dt);  // "8 08 008 2008"   year
            //            String.Format("{0:M MM MMM MMMM}",      dt);  // "3 03 Mar March"  month
            //            String.Format("{0:d dd ddd dddd}",      dt);  // "9 09 Sun Sunday" day
            //            String.Format("{0:h hh H HH}",          dt);  // "4 04 16 16"      hour 12/24
            //            String.Format("{0:m mm}",               dt);  // "5 05"            minute
            //            String.Format("{0:s ss}",               dt);  // "7 07"            second
            //            String.Format("{0:f ff fff ffff}",      dt);  // "1 12 123 1230"   sec.fraction
            //            String.Format("{0:F FF FFF FFFF}",      dt);  // "1 12 123 123"    without zeroes
            //            String.Format("{0:t tt}",               dt);  // "P PM"            A.M. or P.M.
            //            String.Format("{0:z zz zzz}",           dt);  // "-6 -06 -06:00"   time zone
​
            //// month/day numbers without/with leading zeroes
            //            String.Format("{0:M/d/yyyy}",           dt);  // "3/9/2008"
            //            String.Format("{0:MM/dd/yyyy}",         dt);  // "03/09/2008"
​
            //// day/month names
            //            String.Format("{0:ddd, MMM d, yyyy}",   dt);  // "Sun, Mar 9, 2008"
            //            String.Format("{0:dddd, MMMM d, yyyy}", dt);  // "Sunday, March 9, 2008"
​
            //// two/four digit year
            //            String.Format("{0:MM/dd/yy}",           dt);  // "03/09/08"
            //            String.Format("{0:MM/dd/yyyy}",         dt);  // "03/09/2008"
        }
​
        internal static IEnumerable<DocName> OrderDocsByDate(IEnumerable<DocName> docs)
        {
            //DONE put a field that merge Date and, if date is null, the Last part of interval
            //return docs.OrderBy(x => x.HasDate ? x.GetDateTime() : x.GetLastPartOfIntervalTime() );
            return docs.OrderBy(x => x.GetDateTimeOrLastPartOfIntervalForOrderDoc());
        }
​
        #endregion Dates
    }
​
//################################################################################### DocNameHelper 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;
    public static DateTime ThisDateOrAppropriateMinimalDateTime(this DateTime @this) => (DateTime)(@this < @this.MinimumWinFormDateTime() || @this == NullOutlookDateTime(@this) ? @this.MinimumWinFormDateTime() : @this);
    public static bool IsThisDateNullOrDefault(this DateTime @this) => @this == @this.MinimumWinFormDateTime() || @this == NullOutlookDateTime(@this) || @this == DateTime.MaxValue || @this == DateTime.MinValue || @this == @this.OutlookDefaultDateForInvalidEntry() || @this < @this.OutlookEarliestDateThatDoesNotProvokeError();
    public static DateTime ThisDateCandidateOrDateTimeMinimal(this string stringToBeParsed)
    {
        DateTime @this = default;
        if (stringToBeParsed == null || !DateTime.TryParse(stringToBeParsed, out @this))
            return DateTime.MinValue;
        return @this;
    }
​
    public static DateTime ThisDateCandidateOrAppropriateMinimalDateTime(this string stringToBeParsed)
    {
        DateTime @this = default;
        if (stringToBeParsed == null || !DateTime.TryParse(stringToBeParsed, out @this))
            return @this.MinimumWinFormDateTime();
        return (DateTime)(@this < @this.MinimumWinFormDateTime() || @this == NullOutlookDateTime(@this) ? @this.MinimumWinFormDateTime() : @this);
    }
​
    /// <summary>
    /// Return the older or the ancient of two dates
    /// </summary>
    /// <param name = "d1"></param>
    /// <param name = "d2"></param>
    /// <returns></returns>
    public static DateTime ReturnAnteriorBetweenDates(this DateTime d1, DateTime d2) => d1 < d2 ? d1 : d2;
    /// <summary>
    /// Return the most near Now() date
    /// </summary>
    /// <param name = "d1"></param>
    /// <param name = "d2"></param>
    /// <returns></returns>
    public static DateTime ReturnPosteriorBetweenDates(this DateTime d1, DateTime d2) => d1 < d2 ? d1 : d2;
    public static DateTime AllowPastOrNowTimeButNotFuture(this DateTime? ToTest, DateTime? ToCompare = null)
    {
        if (ToCompare == null)
        {
            ToCompare = DateTime.Now;
        }
​
        return ToTest switch
        {
            var value when value == null => DateTime.Now,
            var value when value < ToCompare => (DateTime)ToTest,
            var value when value > ToCompare => throw new ArgumentOutOfRangeException("Date cannot be in the future..."),
            _ => default,
        };
    }
​
    public static DateTime AllowOnlyFuture(this DateTime? ToTest, double numberOfHoursToAdd = 1, DateTime? ToCompare = null)
    {
        if (ToCompare == null)
        {
            ToCompare = DateTime.Now;
        }
​
        return ToTest switch
        {
            var value when value == null => DateTime.Now.AddHours(numberOfHoursToAdd),
            var value when value > ToCompare => (DateTime)ToTest,
            var value when value < ToCompare => throw new ArgumentOutOfRangeException("Date cannot be in the past or even now..."),
            _ => default,
        };
    //var timeOnlyInFuture = DateTime.MaxValue;
    //switch (ToTest)
    //{
    //    case var value when value == null:
    //        timeOnlyInFuture = DateTime.Now.AddHours(numberOfHoursToAdd);
    //        break;
    //    case var value when value > ToCompare:
    //        timeOnlyInFuture = (DateTime)ToTest;
    //        break;
    //    case var value when value < ToCompare:
    //        throw new ArgumentOutOfRangeException("Date cannot be in the past or even now...");
    //    default:
    //        break;                    
    //}
    //return timeOnlyInFuture;
    }
}
​
// ###################            ##################################      DateTimeExtensions      ##################################            ###################
// ###################            ##################################      StringTextExtensions      ##################################            ###################
public static class StringTextExtensions
{
    private const char OneBlankSpace = ' ';
    public static string RemoveUnnecessarySpaces(this string textToTrim)
    {
        return Regex.Replace(textToTrim, @"\s+", " ").Trim();
    }
​
    public static string RemoveAllSpaces(this string textToTrim)
    {
        return textToTrim.Replace(" ", string.Empty);
    }
​
    public static string RemoveAllPunctuation(this string textToTrim)
    {
        //https://stackoverflow.com/questions/421616/how-can-i-strip-punctuation-from-a-string
        return new string (textToTrim.Where(c => !char.IsPunctuation(c)).Where(c => !char.IsSymbol(c)).ToArray());
    //return Regex.Replace(textToTrim, @"[a-zA-ZçÇ à-úÀ-Ú]+", string.Empty).Trim();
    //return Regex.Replace(textToTrim, @"\p{P}+", string.Empty).Trim();
    //^^^^^cuidado! @"\p{P}+" ou "\\p{P}+": nunca @"\\p{P}+"
    }
​
    public static string GetRidOfNonLetterCharsInKeyOrPairElements(this string rawString) => rawString.RemoveAllPunctuation().RemoveAllSpaces().RemoveBrackets();
    public static string GetNumberOfCharsJustBeforeSubstring(this string text, string beforeThis, int numberOfChars = 1)
    {
        try
        {
            var txtBefore = text.GetUntilOrEmpty(beforeThis);
            return text.GetUntilOrEmpty(beforeThis).Substring(txtBefore.Length - numberOfChars);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
            return string.Empty;
        }
    }
​
    public static string GetUntilOrEmpty(this string text, string stopAt = "-")
    {
        if (!string.IsNullOrWhiteSpace(text))
        {
            int charLocation = text.IndexOf(stopAt, StringComparison.Ordinal);
            if (charLocation > 0)
            {
                return text.Substring(0, charLocation);
            }
        }
​
        return string.Empty;
    }
​
    public static string GetAfterOrEmpty(this string text, string stopAt = "-")
    {
        if (!string.IsNullOrWhiteSpace(text))
        {
            int charLocation = text.IndexOf(stopAt, StringComparison.Ordinal);
            if (charLocation > 0)
            {
                return text.Substring(charLocation + stopAt.Length, text.Length - charLocation - stopAt.Length);
            }
        }
​
        return string.Empty;
    }
​
    public static string GetMiddleString(this string inputString, char separator = OneBlankSpace)
    {
        //this is assuming that your tokens only happens one time in the string
        //https://stackoverflow.com/questions/2449561/retrieve-string-from-the-middle-of-a-string
        var input = inputString.Split(separator);
        var firstToken = input[0];
        var lastToken = input[input.Length - 1];
        var pos1 = inputString.IndexOf(firstToken) + firstToken.Length;
        var pos2 = inputString.IndexOf(lastToken);
        var result = inputString.Substring(pos1, pos2 - pos1).Trim() ?? string.Empty;
        return result;
    }
​
    public static (string textBefore, string textAfter) GetTextBeforeAndAfterSubstring(this string textToExtract, string stringToSearchFor, int desiredLengthToCut, int indexToSearchedString)
    {
        //var indexToSearchedString = textToExtract.IndexOf(stringToSearchFor, StringComparison.Ordinal);
        var textBefore = textToExtract.Substring(indexToSearchedString - desiredLengthToCut < 0 ? 0 : indexToSearchedString - desiredLengthToCut, indexToSearchedString - desiredLengthToCut > 0 ? desiredLengthToCut : indexToSearchedString);
        var textAfter = textToExtract.Substring(indexToSearchedString + stringToSearchFor.Length, DecideHowMuchItCanCutAfter(textToExtract.Length, indexToSearchedString + stringToSearchFor.Length, desiredLengthToCut));
        return (textBefore, textAfter);
        static int DecideHowMuchItCanCutAfter(int totalLength, int beginCut, int lengthToCut)
        {
            if (beginCut + lengthToCut < totalLength)
                return lengthToCut;
            if (beginCut + lengthToCut >= totalLength)
                return totalLength - beginCut;
            return 0;
        }
    }
​
    public static string RemoveDiacritics(this string s)
    {
        string normalizedString = s.Normalize(NormalizationForm.FormD);
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < normalizedString.Length; i++)
        {
            char c = normalizedString[i];
            if (CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
                stringBuilder.Append(c);
        }
​
        return stringBuilder.ToString();
    }
​
    public static string RemoveBrackets(this string s)
    {
        return s.Replace("[", string.Empty).Replace("]", string.Empty);
    }
​
    public static string SurroundWithDoubleQuotes(this string text)
    {
        return SurroundWith(text, "\"");
    }
​
    public static string SurroundWith(this string text, string ends)
    {
        return ends + text + ends;
    }
​
    public static string EscapeSingleQuote(this string text)
    {
        return text.Replace("'", @"\'");
    }
​
    public static string AddSingleQuoteAsEscapeCharacter(this string text)
    {
        //https://docs.microsoft.com/pt-br/dotnet/api/microsoft.office.interop.outlook._items.find?view=outlook-pia
        return text.Replace("'", @"''");
    }
​
    public static string EnsureOneSingleSpaceAtBegin(this string text)
    {
        return OneBlankSpace + text.TrimStart();
    }
​
    public static string CapitalizeFirstLetter(this string value)
    {
        //In Case if the entire string is in UpperCase then convert it into lower
        value = value.ToLower();
        char[] array = value.ToCharArray();
        // Handle the first letter in the string.
        if (array.Length >= 1)
        {
            if (char.IsLower(array[0]))
            {
                array[0] = char.ToUpper(array[0]);
            }
        }
​
        // Scan through the letters, checking for spaces.
        // ... Uppercase the lowercase letters following spaces.
        for (int i = 1; i < array.Length; i++)
        {
            if (array[i - 1] == ' ')
            {
                if (char.IsLower(array[i]))
                {
                    array[i] = char.ToUpper(array[i]);
                }
            }
        }
​
        return new string (array);
    }
​
    /// <summary>
    /// Split a string on each occurrence of a capital (assumed to be a word)
    /// e.g. MyBigToe returns "My Big Toe"
    /// </summary>
    public static string SplitCapitalizedWords(this string source)
    {
        if (String.IsNullOrEmpty(source))
            return String.Empty;
        var newText = new StringBuilder(source.Length * 2);
        newText.Append(source[0]);
        for (int i = 1; i < source.Length; i++)
        {
            if (char.IsUpper(source[i]))
                newText.Append(' ');
            newText.Append(source[i]);
        }
​
        return newText.ToString();
    }
    public static string TrimLastCharacter(this String str) => String.IsNullOrEmpty(str) ? str : str.TrimEnd(str[str.Length - 1]);
​
    /// <summary>
    /// https://stackoverflow.com/questions/6865419/indexof-for-multiple-results
    /// https://stackoverflow.com/questions/15993357/how-to-get-all-indexof-instances-of-string-in-another-string-c-sharp
    /// </summary>
    /// <param name = "str"></param>
    /// <param name = "searchString"></param>
    /// <returns></returns>
    public static IEnumerable<int> AllIndexesOf(this string str, string searchString)
    {
        int minIndex = str.IndexOf(searchString, StringComparison.Ordinal);
        while (minIndex != -1)
        {
            yield return minIndex;
            minIndex = str.IndexOf(searchString, minIndex + searchString.Length, StringComparison.Ordinal);
        }
    }
​
    /// <summary>
    ///     A string extension method that query if '@this' contains any values.
    /// </summary>
    /// <param name = "this">The @this to act on.</param>
    /// <param name = "values">A variable-length parameters list containing values.</param>
    /// <returns>true if it contains any values, otherwise false.</returns>
    public static bool ContainsAny(this string @this, params string[] values)
    {
        foreach (string value in values)
        {
            if (@this.IndexOf(value) != -1)
            {
                return true;
            }
        }
​
        return false;
    }
​
    /// <summary>
    ///     A string extension method that query if '@this' contains any values.
    /// </summary>
    /// <param name = "this">The @this to act on.</param>
    /// <param name = "comparisonType">Type of the comparison.</param>
    /// <param name = "values">A variable-length parameters list containing values.</param>
    /// <returns>true if it contains any values, otherwise false.</returns>
    public static bool ContainsAny(this string @this, StringComparison comparisonType, params string[] values)
    {
        foreach (string value in values)
        {
            if (@this.IndexOf(value, comparisonType) != -1)
            {
                return true;
            }
        }
​
        return false;
    }
​
    public static bool DoesNotContainAnySpace(this string @this) => !@this.Any(char.IsWhiteSpace);
    //https://stackoverflow.com/questions/3293295/string-contains-only-a-given-set-of-characters
    public static bool ContainsOnly(this string @this, string allowedChars) => @this.All(allowedChars.Contains);
    public static bool StringHasOnlyNumbers(this string @this) => @this.ReturnOnlyNumbers().Length == @this.Length;
    //https://stackoverflow.com/questions/4734116/find-and-extract-a-number-from-a-string   
    public static List<string> ReturnOnlyInvalidChars(this string @this, string allowedChars) => (
        from c in @this
        where !allowedChars.Contains(c.ToString())select c.ToString()).ToList();
    //https://stackoverflow.com/questions/4734116/find-and-extract-a-number-from-a-string
    public static string ReturnOnlyNumbers(this string @this) => new(@this.Where(char.IsDigit).ToArray());
    public static int? ReturnOnlyNumbersAsInt(this string @this)
    {
        int.TryParse(@this.ReturnOnlyNumbers(), out var result);
        return result;
    }
​
    public static string ReturnOnlyNonNumericCharacters(this string @this) => Regex.Replace(@this, @"[\d-]", string.Empty);
    /// <summary>
    /// https://stackoverflow.com/a/10042595/2752308
    /// </summary>
    /// <param name = "this"></param>
    /// <returns></returns>
    public static int[] ReturnOnlyNumbersToArray(this string @this) => Regex.Matches(@this, "(-?[0-9]+)").OfType<Match>().Select(m => int.Parse(m.Value)).ToArray();
    public static int GetSingleDigitAtPositionInFilteredStrOnlyNumbers(this string @this, int position1Based)
    {
        if (position1Based < 1 || position1Based > @this.Length - 1)
        {
            throw new ArgumentOutOfRangeException(nameof(position1Based), $"{nameof(position1Based)} cannot be outer of string limits");
        }
​
        return int.Parse(@this.ReturnOnlyNumbers()[position1Based - 1].ToString());
    }
​
    public static string FormatPhoneNumber(this long number, string mask) => number.ToString(mask);
    //https://pt.stackoverflow.com/questions/283609/formatar-uma-string-para-formato-de-telefone
    public static string FormatPhoneNumber(this string number)
    {
        var mask = number.ReturnOnlyNumbers().Length switch
        {
            15 => @"0 000 (00) 00000-0000",
            13 => @"+00 (00) 00000-0000",
            11 => @"(00) 00000-0000",
            10 => @"(00) 0000-0000",
            _ => throw new ArgumentOutOfRangeException(nameof(FormatPhoneNumber), "FormatPhoneNumber only accepts certain ranges of phone numbers"),
        };
        //var mask = string.Empty;
        //switch (number.ReturnOnlyNumbers().Length)
        //{
        //    case 15:
        //        mask = @"0 000 (00) 00000-0000";
        //        break;
        //    case 13:
        //        mask = @"+00 (00) 00000-0000";
        //        break;
        //    case 11:
        //        mask = @"(00) 00000-0000";
        //        break;
        //    case 10:
        //        mask = @"(00) 0000-0000";
        //        break;
        //    default:
        //        throw new ArgumentOutOfRangeException(nameof(FormatPhoneNumber), "FormatPhoneNumber only accepts certain ranges of phone numbers");        
        //}
        return long.Parse(number.ReturnOnlyNumbers()).FormatPhoneNumber(mask);
    }
​
    public static bool IsDate(this string @this, out DateTime date) => DateTime.TryParse(@this, out date);
    public static bool IsDate(this string @this) => DateTime.TryParse(@this, out var date);
    /// <summary>
    /// https://stackoverflow.com/questions/7461080/fastest-way-to-check-if-string-contains-only-digits-in-c-sharp
    /// TryParse won't work in some situations, like what happens if the string is a credit card number with 16 digits
    /// or if DateTime is in sortable format, like "20210620150000"
    /// </summary>
    /// <param name = "this"></param>
    /// <returns></returns>
    public static bool IsNumber(this string @this) => int.TryParse(@this, out var number);
    public static bool IsDigit(this string @this) => @this.All(c => c >= '0' && c <= '9');
}
​
// ###################            ##################################      StringTextExtensions      ##################################            ###################
// ###################            ##################################      EasyOfficeFolderExtensions      ##################################            ###################
public static class EasyOfficeFolderExtensions
{
    public static string GetParentFolder(this string pathSource)
    {
        //https://stackoverflow.com/a/30902714/2752308
        return Path.GetFullPath(Path.Combine(pathSource, @"..\"));
    }
​
    /// <summary>
    /// Extension to use with Root path, adding distal path as argument
    /// </summary>
    /// <param name = "pathWithRoot"></param>
    /// <param name = "pathDistal"></param>
    /// <returns></returns>
    public static string CombinePaths(this string pathWithRoot, string pathDistal)
    {
        var networkFolder = !pathWithRoot.Contains(":");
        var pathOne = pathWithRoot.Split(@"\".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
        var pathTwo = pathDistal.Split(@"\".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
        var pathFinal = pathOne.Concat(pathTwo);
        var preFinalPath = Path.Combine(pathFinal.ToArray());
        if (networkFolder)
            return "\\\\" + preFinalPath;
        return preFinalPath.Contains(":\\") ? preFinalPath : preFinalPath.Replace(":", ":\\");
    }
}
​
// ###################            ##################################      EasyOfficeFolderExtensions      ##################################            ###################
// ###################            ##################################      ObjectTextExtensions      ##################################            ###################
public static class ObjectTextExtensions
{
    public static T ObjToEnum<T>(this object o, int unknown = 0)
    {
        try
        {
            if (o != null)
            {
                T enumVal = (T)Enum.Parse(typeof(T), o.ToString());
                return enumVal;
            }
        }
        catch (Exception)
        {
            return (T)Enum.ToObject(typeof(T), unknown);
        }
​
        return (T)Enum.ToObject(typeof(T), unknown); //0 é o valor que estou dando para todos os enum Desconhecidos
    }
​
    //        public static T LookupItemExToEnum<T>(this object o, int unknown = 0)
    //        {
    //        }
    /// <summary>
    /// Returns true if Enum value exists
    /// </summary>
    /// <param name = "value"></param>
    /// <returns></returns>
    public static bool IsDefined(this System.Enum value)
    {
        return Enum.IsDefined(value.GetType(), value);
    }
​
    //       public static LookupItemEx EnumTo<TValue>(this TValue value) where TValue : System.Enum =>
    //            LookupItemEx.Create(value.EnumToInt(), value.ToString(), value.GetDescription());
    public static int EnumToInt<TValue>(this TValue value)
        where TValue : System.Enum => (int)(object)value;
    public static TValue IntToEnum<TValue>(this int value)
        where TValue : System.Enum => (TValue)(object)value;
    //=> (TValue)Convert.ChangeType(value, typeof(TValue));
    //(T)Convert.ChangeType(Email.FromString("m", WhichContactType.PERSONAL), typeof(T)), 
    public static T GetEnumValue<T>(this string value)
        where T : struct
    {
        Type t = typeof(T);
        if (!t.IsEnum)
            throw new Exception("T must be an enum");
        else
        {
            if (Enum.IsDefined(t, value))
                return (T)Enum.Parse(t, value);
            else
                return default(T);
        }
    }
​
    //https://stackoverflow.com/questions/483794/convert-enum-to-string/17034624#17034624
    public static T GetValueFromDescription<T>(this string description, bool throwException = true)
        where T : Enum
    {
        //https://stackoverflow.com/questions/4367723/get-enum-from-description-attribute
        foreach (var field in typeof(T).GetFields())
        {
            if (Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute))is DescriptionAttribute attribute)
            {
                if (attribute.Description == description)
                    return (T)field.GetValue(null);
            }
            else
            {
                if (field.Name == description)
                    return (T)field.GetValue(null);
            }
        }
​
        if (throwException)
        {
            throw new ArgumentException("Not found.", nameof(description));
        }
​
        return default(T);
    }
​
    public static string GetDescription(this Enum value)
    {
        //https://stackoverflow.com/questions/4367723/get-enum-from-description-attribute
        //https://stackoverflow.com/a/479417/2752308
        FieldInfo field = value.GetType().GetField(value.ToString());
        DescriptionAttribute attribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;
        return attribute == null ? value.ToString() : attribute.Description;
    }
​
    public static string GetDescription(this object e, Type enumType)
    {
        //var fields = Enum.GetValues(enumType).Cast<object>();
        //var fieldsName =
        //from o in fields
        //    where o.ToString() == e.ToString()
        //        select o.ToString();
        //var fieldValue = enumType.GetField(fieldsName.FirstOrDefault()).ToString();
        var fieldValue = enumType.GetField(Enum.GetValues(enumType).Cast<object>().Where(o => o.ToString() == e.ToString()).Select(o => o.ToString()).FirstOrDefault()).ToString();
        FieldInfo field = enumType.GetField(fieldValue.Contains(" ") ? fieldValue.Split().Last() : fieldValue);
        DescriptionAttribute attribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;
        return attribute == null ? e.ToString() : attribute.Description;
    }
​
    /// <summary>
    /// De um valor apenas, pega o Dictionary; meio estranho
    /// </summary>
    /// <typeparam name = "TValue"></typeparam>
    /// <param name = "value"></param>
    /// <returns></returns>
    public static Dictionary<int, TValue> EnumToDictionary<TValue>(this TValue value)
        where TValue : System.Enum
    {
        Type enumType = typeof(TValue);
        var allEnumValues = enumType.GetEnumValues().Cast<TValue>();
        var enumDL = new Dictionary<int, TValue>();
        foreach (TValue val in allEnumValues.ToList())
        {
            enumDL.Add(val.EnumToInt(), val);
        }
​
        return enumDL;
    }
​
    public static Dictionary<int, Enum> EnumToDictionaryNotGeneric(this Enum @enum)
    //where T : struct, Enum
    {
        Type enumType = @enum.GetType(); //typeof(@enum);
        var allEnumValues = Enum.GetValues(@enum.GetType()).Cast<Enum>();
        var enumDL = new Dictionary<int, Enum>();
        foreach (var val in allEnumValues.ToList())
        {
            enumDL.Add(val.EnumToInt(), val);
        }
​
        return enumDL;
    }
​
    /// <summary>
    /// Pega o Dictionary; a assinatura é muito estranha
    /// </summary>
    /// <typeparam name = "T"></typeparam>
    /// <returns></returns>
    public static Dictionary<int, T> EnumToDictionary<T>(this Type enumType)
        where T : Enum
    {
        //Type enumType = typeof(T);
        //var allEnumDescriptions = enumType.GetEnumNames();
        //non-generic equivalent:          ^^^^^^^^^^ Enum.GetValues<WhichGender>()
        var allEnumValues = enumType.GetEnumValues().Cast<T>();
        var converter = new EnumConverter(enumType);
        // Can't use generic type constraints on value types,
        // so have to do check like this
        //if (enumType.BaseType != typeof(Enum))
        //    throw new ArgumentException("T must be of type System.Enum");
        var enumDL = new Dictionary<int, T>();
        foreach (T val in allEnumValues.ToList())
        {
            enumDL.Add(val.EnumToInt(), val);
        }
​
        return enumDL;
    }
​
    //https://stackoverflow.com/a/972323/2752308
    public static IReadOnlyList<T> GetValues<T>()
    {
        return (T[])Enum.GetValues(typeof(T));
    }
/// <summary>
/// https://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum
/// Only after 7.3
/// see too: https://stackoverflow.com/questions/5005931/listing-values-within-enums-using-reflection-in-c-sharp
/// Use this instead of EnumPatient.GetAllValues()
/// </summary>
/// <returns></returns>
 //        public static Dictionary<int, string> GetAllValuesByEnumType(this EnumPatient.Enums whichType)
//        {
//        }
} 
// ###################            ##################################      ObjectTextExtensions 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    ##################################            ###################
​

View IL Code