ApplicationServices draft | C# Online Compiler

ApplicationServices draft by Marcelo Scofano

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Reflection;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using System.Text.RegularExpressions;
using static System.IO.Path;
using CSharpFunctionalExtensions;
using static PatientManagerMD.ResourceCentral.EnumHelper.CommonEnums;
//using static PatientManagerMD.ResourceCentral.Properties.Resources;
using PatientManagerMD.ResourceCentral.DataHelper;
using PatientManagerMD.ResourceCentral.ExtensionMethods;
using PatientManagerMD.ResourceCentral.AppResource;

public class Program
{
	public static void Main()
	{
		Console.WriteLine("Hello World");
	}
}

namespace PatientManagerMD.ResourceCentral.Services
{
	public class ApplicationServices
	{
		//private readonly XDocument _xDoc;
		//TODO: is it necessary to be static!?!?!?
		public static XDocument XDoc { get; set; }
		private string Path { get; set; }
		private XMLDataServices XMLDataServices { get; set; }
		/// <summary>
		/// In Linux machines or in the DotFiddleNet Core, it will be false
		/// </summary>
		public bool IsInMachineWithMappedDriveLetters { get; }

		public ApplicationServices(XDocument sourceGenderFromFirstName, string pathXDoc)
		{
			XDoc = sourceGenderFromFirstName;
			Path = pathXDoc;
			XMLDataServices = new XMLDataServices(pathXDoc);
			IsInMachineWithMappedDriveLetters = System.IO.Directory.GetLogicalDrives().Any(name => name.Contains(":"));
		}

#region Static XDoc dependency
		public void SaveXDoc()
		{
			XDoc.Save(Path); //, ResourceCentral.Properties.Resources.GenderFromName
		}

		/// <summary>
		/// If it not find Gender from Name, it will return default that is 0
		/// </summary>
		/// <param name = "nameToTest"></param>
		/// <returns></returns>
		public WhichGender LoadGenderInferredFromFirstName(string firstNameToTest)
		{
			var genderValue = PatientServices.ParseGenderFromStr(GetGenderFromFirstNameOrDefault(firstNameToTest));
			return genderValue;
		}

		public static WhichGender GetGenderFromName(string firstName)
		{
			if (string.IsNullOrEmpty(firstName) || !GenderCanBeInferred(firstName))
				return WhichGender.Indeterminado;
			return PatientServices.ParseGenderFromStr(GetGenderFromFirstNameOrDefault(firstName));
		}

		public int HowManyNameVsGenderCatalogued()
		{
			return XDoc.Descendants("NomevsSexo").Elements("PrimeiroNome").Count();
		}

#endregion
		/// <summary>
		/// Não é estática!!!
		/// TODO avaliar esta confusão; claro que é para ser estática...
		/// </summary>
		/// <param name = "strToParseGender"></param>
		/// <param name = "genderOfName"></param>
		/// <returns></returns>
		public bool GenderCannotBeInferred(string strToParseGender, WhichGender genderOfName)
		{
			//Only for test purpose
			return WhichGender.Indeterminado == (genderOfName != WhichGender.Indeterminado ? genderOfName : PatientServices.ParseGenderFromStr(strToParseGender));
		}

		public static bool GenderCanBeInferred(string strToParseGender)
		{
			return WhichGender.Indeterminado != PatientServices.ParseGenderFromStr(GenderStringFromFirstName(strToParseGender));
		}

		/// <summary>
		/// nameToTest is the full name; it parses it and test first name only
		/// </summary>
		/// <param name = "nameToTest"></param>
		/// <returns></returns>
		public static string GenderStringFromFirstName(string fullNameToTest)
		{
			var firstName = fullNameToTest.Split(' ')[0];
			if (XDoc == null)
				return "Indeterminado";
			try
			{
				return GetGenderFromFirstNameOrDefault(firstName);
			}
			catch (Exception)
			{
				return "Indeterminado";
			}
		}

		private static string GetGenderFromFirstNameOrDefault(string firstName)
		{
			return XDoc.Descendants("NomevsSexo").Where(x => x.Element("PrimeiroNome").Value == firstName).Select(y => y.Element("sexo").Value).FirstOrDefault();
		}

		public static WhichGender GenderFromFullName(string fullNameToTest)
		{
			//ParseGenderFromStr(nameToTest).EnumToInt().ToString()
			return PatientServices.ParseGenderFromStr(GenderStringFromFirstName(fullNameToTest));
		}

		public static Maybe<WhichGender> GenderFromPatientJson(string patientFullName)
		{
			//TODO: implement it
			return Maybe<WhichGender>.None;
		}

		public static WhichGender ParseGenderFromStr(string genderToParse)
		{
			return PatientServices.ParseGenderFromStr(genderToParse);
		}

		public void DeleteFirstNameAndGenderFromXML(string nameToTest)
		{
			XMLDataServices.DeleteFirstNameAndGenderFromXML(nameToTest, XDoc);
			SaveXDoc();
		}

		public void AddFirstNameAndGenderToXML(string nameToTest, WhichGender genderOfName, LanguageName whichLanguage)
		{
			//https://stackoverflow.com/questions/8642980/inserting-particular-xelement-at-specific-position-in-a-xml-using-linq
			XMLDataServices.AddFirstNameAndGenderToXML(nameToTest, genderOfName, XDoc, whichLanguage);
			SaveXDoc();
		}

		public static List<string> PreposicoesNomeProprio()
		{
			var fileToRead = ""; // Combine(AuxiliaryFolderStructure.Data.Path, PreposicoesTextoNormal);
			var lines = File.ReadLines(fileToRead, Encoding.UTF8).ToList();
			return lines;
		}

		//TODO: get above and below fileToRead from SourceJson as a Singleton, loading it once in ApplicationServices instantiation
		//tradeoff to avoid global variables for state that is the result of one-time, heavy operations         		
		public static string FullNameInProperCase(string name)
		{
			var space = " ";
			var parts = name.Split(' ');
			var fileToRead = ""; //Combine(AuxiliaryFolderStructure.Data.Path, Resources.PreposicoesNomeProprio);
			//https://stackoverflow.com/questions/2182342/parse-lines-using-linq-to-txt
			var allLines =
				from line in File.ReadLines(fileToRead, Encoding.UTF8)let cleanedLines = line.RemoveBrackets()select cleanedLines;
			var preposicoesNomeProprio = allLines.ToList();
			var fullName = string.Empty;
			foreach (var part in parts)
			{
				if (preposicoesNomeProprio.Contains(part))
				{
					fullName += part + space;
				}
				else
				{
					if (NameHasApostrophe(part))
					{
						fullName += char.ToUpper(part[0]) + "'" + part.Substring(2, part.Length - 2).CapitalizeFirstLetter() + space;
					}
					else if (part == "TESTE")
					{
						fullName += part + space;
					}
					else
					{
						fullName += part.CapitalizeFirstLetter() + space;
					}
				}
			}

			return fullName.Trim();
		}

		public static string ReturnCorrectFirstLetterOfNameThatHasApostrophe(string part) => //part.Substring(2,part.Length-2);
		char.ToUpper(part[2]).ToString();
		public static bool NameHasApostrophe(string part) //, int positionOfApostrophe = 1)
 => part.Contains("'");

		 //public static DateTime OutlookEarliestDateThatDoesntProvokeError => Convert.ToDateTime(OutlookEarliestDateThatDoesntProvokeErrorEntry);
		public static DateTime MinBirthYearToStillBeAlive => DateTime.Now.AddYears(-119);
		//public static DateTime GetDateOrAppropriateMinimalDate(DateTime dateToTest)
		//public static string DefaultCountry() => Resources.DefaultCountry;
		//public static string DefaultCountryLocalName() => Resources.DefaultCountryLocalName;
		//public static string DefaultState() => Resources.DefaultState;
		//public static string DefaultCity() => Resources.DefaultCity;
		public static string HeaderRTFLatin => @"{\rtf1\ansi\ansicpg1252\deff0\deflang2070" + @"{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;}" + @"{\fonttbl{\f0\fnil\fcharset0 Microsoft Sans Serif;}}\viewkind4\uc1\pard\fs20 ";

		//To get below or similar Enum based on HeaderRTFLatin:
		// => Documents\Consultório Impressos\DB Pacientes\LINQPad Queries\Generating Enum Colors for RTF.linq
		//https://stackoverflow.com/questions/11728209/how-to-get-the-name-of-color-while-having-its-rgb-value-in-c
		//public enum ColorString		

		public static string ConvertString2RTF(string input)
		{
			//first take care of special RTF chars
			StringBuilder backslashed = new StringBuilder(input);
			backslashed.Replace(@"\", @"\\");
			backslashed.Replace(@"{", @"\{");
			backslashed.Replace(@"}", @"\}");
			//then convert the string char by char
			StringBuilder sb = new StringBuilder();
			foreach (char character in backslashed.ToString())
			{
				if (character <= 0x7f)
					sb.Append(character);
				else
					sb.Append("\\u" + Convert.ToUInt32(character) + "?");
			}

			return sb.ToString();
		}

		//public static List<int, string> ReturnKeyValuePairList<TValue>(Enum TValue) where TValue : Enum
		//{
		//    return  Enum.GetValues(typeof(enumType))
		//                    .Cast<T>()
		//    //                ^^^^^^ https://stackoverflow.com/a/15457453/2752308
		//                    .Select(e => new { Key = e, Value = e }).ToList();
		//    //                  ^^^^  https://stackoverflow.com/a/42345540/2752308
		//}
		public class KeyValuePair
		{
			//https://stackoverflow.com/a/6294585/2752308
			//var EtniaSource = ApplicationServices.KeyValuePair.ListFrom<WhichEtnia>();
			public string Key { get; set; }
			public string Name { get; set; }
			public int Value { get; set; }

			public static List<KeyValuePair> ListFrom<T>(bool splitCapitalizedWords = false)
			{
				var array = (T[])(Enum.GetValues(typeof(T)));
				return array.Select(a => new KeyValuePair { Key = a.ToString(), Name = (splitCapitalizedWords ? a.ToString().SplitCapitalizedWords() : a.ToString()), Value = Convert.ToInt32(a) }).OrderBy(kvp => kvp.Value).ToList();
			}
		}
	}
//namespace PatientManagerMD.ResourceCentral.Services
//{
    public static class XMLServices
    {
        public static int Position(this XNode node)
        {
            return node.NodesBeforeSelf().Count();
        }

        public static void SortElemByName(this XContainer container)
        {
            container.ReplaceNodes(
                from childEl in container.Elements()
                orderby childEl.Name.LocalName
                select childEl
            );
            foreach (XElement childEl in container.Elements().Where(e => e.HasElements))
            {
                SortElemByName(childEl);
            }
        }

        public static void SortElementsByNameInPlace(this XContainer xContainer)
        {
            //foreach (XElement element in xContainer.Descendants("NomevsSexo").Elements("PrimeiroNome"))//Descendants())
            foreach (XElement element in xContainer.Descendants("NomevsSexo")) //Descendants())
            {
                var orderedElements =
                (
                    from child in element.Elements()
                    orderby child.Value
                    select child
                ).ToList(); // ToList matters, since we remove all of the child elements next

                element.Elements().Remove();
                element.Add(orderedElements);
            }
        }

        public static void
            SortAllElements(this XContainer container) //this XElement source, bool bSortAttributes = true)
        {
            container.ReplaceNodes(
                from childEl in container.Elements()
                orderby childEl.Value
                select childEl
            );
            foreach (XElement childEl in container.Elements().Where(e => e.HasElements))
            {
                SortAllElements(childEl);
            }
        }
    }
	//namespace PatientManagerMD.ResourceCentral.Services
	//{
	public class XMLDataServices
	{
		public string Path { get; private set; }

		public XMLDataServices(string path)
		{
			Path = path;
		}

		private void GuardClauseAgainstInjectorNotInitialized()
		{
			if (string.IsNullOrEmpty(Path))
			{
				throw new ArgumentNullException("Path não pode ser vazia!!!");
			}
		}

		public void DeleteFirstNameAndGenderFromXML(string nameToTest, XDocument doc)
		{
			try
			{
				GuardClauseAgainstInjectorNotInitialized();
				doc.Descendants("NomevsSexo").Where(x => x.Element("PrimeiroNome").Value == nameToTest).Remove();
			//doc.Save(Path);//Path.Combine(AuxiliaryFolderStructure.SupportPathTest, ResourceCentral.Properties.Resources.GenderFromName));
			}
			catch (ArgumentNullException)
			{
				throw;
			}
		}

		public void AddFirstNameAndGenderToXML(string nameToTest, WhichGender genderOfName, XDocument doc, LanguageName languageName)
		{
			GuardClauseAgainstInjectorNotInitialized();
			//https://stackoverflow.com/questions/8642980/inserting-particular-xelement-at-specific-position-in-a-xml-using-linq
			var indexFirstNode = doc.Descendants("NomevsSexo").FirstOrDefault(x => string.Compare(x.Element("PrimeiroNome")?.Value, nameToTest) == -1)?.Position();
			//var nodeLower =
			//    doc.Descendants("NomevsSexo")
			//        .LastOrDefault(x => string.Compare(x.Element("PrimeiroNome")?.Value, nameToTest) == -1);
			//var indexNodeLower = nodeLower?.Position();
			var indexNodeHigher = doc.Descendants("NomevsSexo").FirstOrDefault(x => string.Compare(x.Element("PrimeiroNome")?.Value, nameToTest) == 1)?.Position();
			// Se fosse usar indexNodeLower seria AddAfterSelf()
			var nodeToAdd = new XElement("NomevsSexo", new XElement("PrimeiroNome", nameToTest, new XAttribute("Language", languageName.GetDescription())), new XElement("sexo", (int)genderOfName));
			if (indexNodeHigher.HasValue && indexFirstNode.HasValue)
			{
				//https://stackoverflow.com/questions/24623391/add-xelement-to-another-xelement-in-specific-location
				doc.Element("InfereSexoPorNome")?.Elements("NomevsSexo").ElementAt((int)(indexNodeHigher - indexFirstNode)).AddBeforeSelf(nodeToAdd);
			}
			else
			{
				doc.Element("InfereSexoPorNome")?.LastNode.AddAfterSelf(nodeToAdd);
			}
		//doc.Save(Path);//Path.Combine(AuxiliaryFolderStructure.SupportPathTest, ResourceCentral.Properties.Resources.GenderFromName));
		}
	}

	//namespace PatientManagerMD.ResourceCentral.Services
	//{
	/// <summary>
	/// Paradoxically, despite it's name, it is for Application wide services that does not depends on Model;
	/// if I allow that, it would create a Circular Reference error.
	/// That is why I had to move a lot of helpers and enums to this assembly
	/// </summary>
	public static class PatientServices
	{
#region Deals with ID
		/// <summary>
		/// It coordinates logic to extract ID from Olk, if there is a valid ID;
		/// if ID is valid, but repeated, it generates a random one, very out of range to be a marker that
		/// it has to be modified
		/// If ID is not valid number, or null, it uses incremental counter, but assures that it
		/// is not repeated too
		/// </summary>
		/// <param name = "candidateID"></param>
		/// <param name = "onlyDifferentRandomIDs"></param>
		/// <param name = "onlyDifferentIncrementIDs"></param>
		/// <param name = "count"></param>
		/// <returns></returns>
		 //..public static long IDToUse(string candidateID, ref List<long> onlyDifferentRandomIDs, ref List<long> onlyDifferentIncrementIDs,
		/// <summary>
		/// Random long
		/// </summary>
		/// <param name = "seed">Seed cannot be less than 1 or greater than 100.000</param>
		/// <param name = "range">Range cannot be zero or negative or greater than 1000</param>
		/// <returns></returns>
		/// ", nameof(range));
		 //...public static long GetNewRandomID(long seed, long range)
		//..public static long GetProperIDToUse(string customerId)
		public static bool AddedIfNotAlreadyExists(ref List<long> nonRepeat, long numToTry)
		{
			var exists = nonRepeat.Any(l => l == numToTry);
			if (!exists)
				nonRepeat.Add(numToTry);
			return !exists;
		}

		//.. public static long UseThisID_orGenerateProperID(ref List<long> nonRepeat, long numToTry)
		/// <summary>
		/// It will increment before trying: ++counter
		/// </summary>
		/// <param name = "nonRepeat"></param>
		/// <param name = "numToTry"></param>
		/// <returns></returns>
		public static long GetNonRepeatedIncrementalID(ref List<long> nonRepeat, long numToTry)
		{
			if (AddedIfNotAlreadyExists(ref nonRepeat, numToTry))
				return numToTry;
			bool added;
			do
			{
				++numToTry;
				added = AddedIfNotAlreadyExists(ref nonRepeat, numToTry);
			}
			while (!added);
			return numToTry;
		}

#endregion
		//From VBA:
		//?Outlook.OlGender.olUnspecified
		//0 
		//?Outlook.OlGender.olMale
		//2 
		//?Outlook.OlGender.olFemale   
		//1
		public enum OlGender
		{
			OlUnspecified = 0,
			OlFemale = 1,
			OlMale = 2
		}

		public static string WhichStringGender(OlGender genderToConvertToString)
		{
			return genderToConvertToString switch
			{
				OlGender.OlFemale => Enum.GetName(typeof(WhichGender), WhichGender.Feminino),
				OlGender.OlMale => Enum.GetName(typeof(WhichGender), WhichGender.Masculino),
				_ => Enum.GetName(typeof(WhichGender), WhichGender.Indeterminado),
			};
		}

		public static WhichGender WhichGenderFromOutlook(OlGender genderToConvertToPatient)
		{
			return genderToConvertToPatient switch
			{
				OlGender.OlFemale => WhichGender.Feminino,
				OlGender.OlMale => WhichGender.Masculino,
				_ => WhichGender.Indeterminado,
			};
		}

		public static WhichGender WhichGenderFromOutlook(int genderToConvertToPatient)
		{
			return genderToConvertToPatient switch
			{
				1 => WhichGender.Feminino,
				2 => WhichGender.Masculino,
				_ => WhichGender.Indeterminado,
			};
		}

		public static WhichGender GetGenderFromOutlook(WhichGender appropriateGenderToUse)
		{
			//TODO: rever esta lógica e ver se dá para usar as anteriores...
			//Era o que estava no GenderToFromOutlook Setr da Patient.cls
			if (appropriateGenderToUse == WhichGender.Feminino)
				return (WhichGender)WhichGenderToFromOlk.Feminino;
			if (appropriateGenderToUse == WhichGender.Masculino)
				return (WhichGender)WhichGenderToFromOlk.Masculino;
			if (appropriateGenderToUse == WhichGender.Indeterminado)
				return appropriateGenderToUse;
			return WhichGender.Indeterminado;
		}

		public static OlGender WhichGenderToOutlookEnum(WhichGender genderToConvertToOlk)
		{
			return genderToConvertToOlk switch
			{
				WhichGender.Feminino => OlGender.OlFemale,
				WhichGender.Masculino => OlGender.OlMale,
				_ => OlGender.OlUnspecified,
			//_ => throw new ArgumentOutOfRangeException(nameof(genderToConvertToOlk), genderToConvertToOlk, null)
			};
		}

		public static int WhichGenderToOutlookInt(WhichGender genderToConvertToOlk)
		{
			return genderToConvertToOlk switch
			{
				WhichGender.Feminino => 1,
				WhichGender.Masculino => 2,
				_ => 0,
			//_ => throw new ArgumentOutOfRangeException(nameof(genderToConvertToOlk), genderToConvertToOlk, null)
			};
		}

		public static WhichGender ParseGenderFromStr(string genderToParse)
		{
			var genderValue = genderToParse?.ToLower();
			var gender = WhichGender.Indeterminado;
			switch (int.TryParse(genderValue, out _) ? "StringAsEnum" : string.IsNullOrEmpty(genderValue) ? "StringAsEnum" : genderValue.Length > 1 ? "StrToParse" : genderValue.Length == 1 ? "CharToParse" : "NotPossible")
			{
				case "StringAsEnum":
					gender = (WhichGender)Enum.Parse(typeof(WhichGender), genderValue ?? WhichGender.Indeterminado.ToString(), true);
					break;
				case "StrToParse":
					// Attention to their order!
					var feminino = new[]
					{
						"feminino",
						"fem",
						"mulher",
						"women",
						"woman"
					};
					var masculino = new[]
					{
						"masculino",
						"masc",
						"homem",
						"men",
						"man"
					};
					if (feminino.Any(genderValue.Contains))
					{
						gender = WhichGender.Feminino;
					}
					else if (masculino.Any(genderValue.Contains))
					{
						gender = WhichGender.Masculino;
					}

					break;
				case "CharToParse":
					var fem = new[]
					{
						"f",
						"w"
					};
					if (fem.Any(genderValue.Contains))
						gender = WhichGender.Feminino;
					var masc = new[]
					{
						"m"
					};
					if (masc.Any(genderValue.Contains))
						gender = WhichGender.Masculino;
					break;
				case "NotPossible":
					throw new ArgumentOutOfRangeException();
			}

			return gender;
		}

		/// <summary>
		/// TODO: avaliar se precise ser Result ao invés de Maybe, caso dê erro de serialização
		/// </summary>
		/// <param name = "patientFullName"></param>
		/// <returns></returns>
		public static Maybe<WhichGender> GetGenderFromJsonOrParseFromName(string patientFullName)
		{
			if (!string.IsNullOrEmpty(patientFullName) && patientFullName.Contains(" ") && patientFullName.Length > 5)
				return Maybe<WhichGender>.None;
			//TODO: Plan if every folder will have a niny json with basic data, including gender and DOB, or if it will be in a central place   
			var maybeGender = ApplicationServices.GenderFromPatientJson(patientFullName);
			return maybeGender.HasNoValue ? ApplicationServices.GenderFromFullName(patientFullName) : maybeGender;
		}

		public static string WhichStringEtnia(WhichEtnia etniaToConvertToString)
		{
			return Enum.GetName(typeof(WhichEtnia), etniaToConvertToString);
		}

		public static string WhichStringTipoSang(WhichBloodType BloodTypeToConvertToString)
		{
			return Enum.GetName(typeof(WhichBloodType), BloodTypeToConvertToString);
		}

		public static string WhichStringFatorRh(WhichRhFactor RhFactorToConvertToString)
		{
			return Enum.GetName(typeof(WhichRhFactor), RhFactorToConvertToString);
		}
	}
}

namespace PatientManagerMD.ResourceCentral.DataHelper
{
	public static class EnumPatient
	{
		public enum Enums
		{
			WhichContactMethod,
			WhichContactType,
			CategoriaPaciente,
			HowToString,
			HowToDisplayAge,
			WhichGender,
			WhichEtnia,
			WhichBloodType,
			WhichRhFactor
		}

		/// <summary>
		/// try to use ObjectExtensions GetAllValuesByEnumType
		/// </summary>
		/// <param name = "whichType"></param>
		/// <returns></returns>
		/// <exception cref = "ArgumentOutOfRangeException"></exception>
		public static Dictionary<int, string> GetAllValues(Enums whichType)
		{
			switch (whichType)
			{
				case Enums.WhichContactMethod:
					return Utilities.EnumNamedValues<WhichContactMethod>();
				case Enums.WhichContactType:
					return Utilities.EnumNamedValues<WhichContactType>();
				case Enums.CategoriaPaciente:
					return Utilities.EnumNamedValues<PatientCategory>();
				case Enums.HowToString:
					return Utilities.EnumNamedValues<HowToString>();
				case Enums.HowToDisplayAge:
					return Utilities.EnumNamedValues<HowToDisplayAge>();
				case Enums.WhichGender:
					return Utilities.EnumNamedValues<WhichGender>();
				case Enums.WhichEtnia:
					return Utilities.EnumNamedValues<WhichEtnia>();
				case Enums.WhichBloodType:
					return Utilities.EnumNamedValues<WhichBloodType>();
				case Enums.WhichRhFactor:
					return Utilities.EnumNamedValues<WhichRhFactor>();
				default:
					throw new ArgumentOutOfRangeException(nameof(whichType), whichType, null);
			}
		}
	}

	public enum WhichContactMethod
	{
		EMAIL = 1,
		PHONE_TYPE,
		ADDRESS_TYPE
	}

	public enum WhichContactType
	{
		[Description("Não informado")]
		NOTINFORMED = -1,
		[Description("Pessoal")]
		PERSONAL = 1,
		[Description("Trabalho")]
		WORK,
		[Description("do Contato/Acompanhante")]
		AssistantContact,
	}

	public enum WhichPhoneType
	{
		[Description("Outros")]
		NOTINFORMED = -1,
		[Description("Residencial 1")]
		HomeTelephoneNumber = 1,
		[Description("Residencial 2")]
		Home2TelephoneNumber,
		[Description("Celular principal")]
		PrimaryTelephoneNumber,
		[Description("Celular 2")]
		MobileTelephoneNumber,
		[Description("Trabalho 1")]
		BusinessTelephoneNumber,
		[Description("Trabalho 2")]
		Business2TelephoneNumber,
		[Description("Contato/Acompanhante 1")]
		AssistantTelephoneNumber,
		// There is AssistantName but I will not use; Olk lets store something like: 
		//(21)9999-5467|Esposa Sr.a Maria Francisca Tavares
		[Description("Contato/Acompanhante 2")]
		Assistant2TelephoneNumber //Mapped to ISDNNumber
	}

	public enum PatientCategory // vbTiposCategoriaPacientes
	{
		//'strCategoriaPacientes
		[Description("Pacientes Meus")]
		Pacientes_meus = 1,
		[Description("Pacientes de Colegas")]
		Pacientes_de_outros = 2,
		[Description("Pacientes USA Consulate")]
		Pacientes_USAConsulate = 3,
		[Description("Pacientes outros")]
		Pacientes_Outros = 4
	} //End enum

	public enum HowToString
	{
		[Description("Nome todo")]
		OnlyFullName = 1,
		[Description("Só iniciais")]
		OnlyInitials,
		[Description("Só primeiro nome")]
		OnlyFirstName,
		[Description("Só idade")]
		OnlyAge,
		[Description("Nome todo, idade")]
		FullNameWithAge,
		[Description("Iniciais, idade")]
		InitialsWithAge,
		[Description("Nome todo, idade, niver")]
		FullNameWithAgeAndBirthDay
	}

	public enum HowToDisplayAge
	{
		[Description("Idade")]
		OnlyYears = 1,
		[Description("Idade, com meses")]
		YearsAndMonths,
		[Description("Idade, com meses e dias")]
		YearsMonthsAndDays
	}

	public enum WhichGender
	{
		Indeterminado = 0,
		Masculino = 1,
		Feminino
	}

	public enum WhichGenderToFromOlk
	{
		Indeterminado = 0,
		Feminino = 1,
		Masculino
	}

	public enum WhichEtnia
	{
		[Description("Não especificada")]
		Indeterminada = 0,
		Branca = 1,
		Negra,
		Parda,
		Amarela,
		[Description("Indígena")]
		Indigena
	}

	public enum WhichBloodType
	{
		[Description("Não informado")]
		Unspecified = 0,
		[Description("Tipo 0")]
		Zero = 1,
		[Description("Tipo A")]
		A = 2,
		[Description("Tipo B")]
		B = 3,
		[Description("Tipo AB")]
		AB = 4
	}

	public enum WhichRhFactor
	{
		Unspecified = 0,
		Positivo = 1,
		Negativo = 2
	}
}

namespace PatientManagerMD.ResourceCentral.AppResource
{
	public static class Utilities
	{
		//...
		/// <summary>
		/// https://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum
		/// Only after 7.3
		/// </summary>
		/// <typeparam name = "T"></typeparam>
		/// <returns></returns>
		public static Dictionary<int, string> EnumNamedValues<T>()
			where T : System.Enum
		{
			var result = new Dictionary<int, string>();
			var values = Enum.GetValues(typeof(T));
			foreach (int item in values)
				result.Add(item, Enum.GetName(typeof(T), item));
			return result;
		}
	//...
	}
}

namespace PatientManagerMD.ResourceCentral.EnumHelper
{
	public class CommonEnums
	{
		public enum LanguageName
		{
			//https://stackoverflow.com/questions/8852253/how-can-i-get-enum-to-contain-a-dash
			//https://stackoverflow.com/questions/4367723/get-enum-from-description-attribute
			//https://stackoverflow.com/questions/2650080/how-to-get-c-sharp-enum-description-from-value
			[Description("PT-BR")]
			PT_BR = 1,
			[Description("EN-US")]
			EN_US
		//^^^^ Description Attribute is not serializable.
		//Use [EnumMember(Value = "PT-BR")] from System.Runtime.Serialization
		//https://stackoverflow.com/a/14394694/2752308
		}

		/// <summary>
		/// From: http://www.mimekit.net/docs/html/T_MimeKit_Text_TextFormat.htm
		/// https://stackoverflow.com/questions/22502924/how-to-determine-text-format-in-c-sharp
		/// </summary>
		public enum TextFormat
		{
			Plain = 0, //	The plain text format.
			Text = 0, //	An alias for the plain text format.
			Flowed = 1, //	The flowed text format (as described in rfc3676).
			Html = 2, //	The HTML text format.
			Enriched = 3, //	The enriched text format.
			CompressedRichText = 4, //	The compressed rich text format.
			RichText = 5 //	The rich text format.
		}
	}
}

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

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

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

		public static string GetRidOfNonLetterCharsInKeyOrPairElements(this string rawString) => rawString.RemoveAllPunctuation().RemoveAllSpaces().RemoveBrackets();
		public static string GetNumberOfCharsJustBeforeSubstring(this string text, string beforeThis, int numberOfChars = 1)
		{
			string txtBefore = null;
			try
			{
				txtBefore = text.GetUntilOrEmpty(beforeThis);
				return txtBefore.Length > 0 ? text.GetUntilOrEmpty(beforeThis).Substring(txtBefore.Length - numberOfChars) : string.Empty;
			}
			catch (Exception ex)
			{
				//Console.WriteLine(ex.Message);
				Console.WriteLine($"GetNumberOfCharsJustBeforeSubstring error {ex.Message}: tried to subtract {txtBefore.Length} – {numberOfChars}");
				return string.Empty;
			}
		}

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

			return string.Empty;
		}

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

			return string.Empty;
		}

		public static string SubstituteSubstringAtSpecificPositionForAnother(this string text, string substringToReplace, string replacement, int position)
		{
			//https://stackoverflow.com/questions/8809354/replace-a-character-at-a-specific-index-in-a-string
			var sb = new StringBuilder(text);
			sb.Remove(position, substringToReplace.Length).Insert(position, replacement);
			return sb.ToString();
		}

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

		public static bool NextCharAfterThisExcerpt(this string text, string uniqueExcerpt, char dot)
		{
			return text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length < text.Length && text[text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length] == dot;
		}

		//TODO test it
		public static bool NextCharAfterThisExcerpt(this string text, string uniqueExcerpt, char[] chars)
		{
			return text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length < text.Length && chars.Contains(text[text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length]);
		}

		public static string AddSubstringAfterThisFoundExcerpt(this string text, string uniqueExcerpt, string toAdd)
		{
			return text.ToLower().Replace(uniqueExcerpt, uniqueExcerpt + toAdd);
		}

		public static string RemoveSubstringAfterThisFoundExcerpt(this string text, string uniqueExcerpt, string toRemove)
		{
			return text.ToLower().Replace(uniqueExcerpt + toRemove, uniqueExcerpt);
		}

		public static string AddSubstringAfterThisFirstFoundExcerpt(this string text, string uniqueExcerpt, string toAdd)
		{
			var index = text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal);
			if (index < 0)
				return text;
			var firstPart = text.Substring(0, index);
			var secondPart = text.Substring(index + uniqueExcerpt.Length);
			return firstPart + uniqueExcerpt + toAdd + secondPart;
		}

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

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

			return stringBuilder.ToString();
		}

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

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

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

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

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

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

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

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

			return new string (array);
		}

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

			return newText.ToString();
		}

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

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

			return false;
		}

		public static int CountOccurrences(this string text, string pattern)
		{
			//https://stackoverflow.com/questions/541954/how-would-you-count-occurrences-of-a-string-within-a-string-c
			return (text.Length - text.Replace(pattern, "").Length) / pattern.Length;
		}

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

			return false;
		}

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

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

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

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

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

		/// <summary>
		/// inHexadecimal = false : returns a decimal hash code
		/// </summary>
		/// <param name = "input"></param>
		/// <param name = "hashSize"></param>
		/// <param name = "inHexadecimal"></param>
		/// <returns></returns>
		public static string ReturnParentFolder(this string pathSource)
		{
			//https://stackoverflow.com/a/30902714/2752308
			return Path.GetFullPath(Path.Combine(pathSource, @"..\"));
		}

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

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

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

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

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

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

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

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

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

			return default(T);
		}

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

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

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

			return enumDL;
		}

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

			return enumDL;
		}

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

			return enumDL;
		}

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

​x
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Reflection;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using System.Text.RegularExpressions;
using static System.IO.Path;
using CSharpFunctionalExtensions;
using static PatientManagerMD.ResourceCentral.EnumHelper.CommonEnums;
//using static PatientManagerMD.ResourceCentral.Properties.Resources;
using PatientManagerMD.ResourceCentral.DataHelper;
using PatientManagerMD.ResourceCentral.ExtensionMethods;
using PatientManagerMD.ResourceCentral.AppResource;
​
public class Program
{
    public static void Main()
    {
        Console.WriteLine("Hello World");
    }
}
​
namespace PatientManagerMD.ResourceCentral.Services
{
    public class ApplicationServices
    {
        //private readonly XDocument _xDoc;
        //TODO: is it necessary to be static!?!?!?
        public static XDocument XDoc { get; set; }
        private string Path { get; set; }
        private XMLDataServices XMLDataServices { get; set; }
        /// <summary>
        /// In Linux machines or in the DotFiddleNet Core, it will be false
        /// </summary>
        public bool IsInMachineWithMappedDriveLetters { get; }
​
        public ApplicationServices(XDocument sourceGenderFromFirstName, string pathXDoc)
        {
            XDoc = sourceGenderFromFirstName;
            Path = pathXDoc;
            XMLDataServices = new XMLDataServices(pathXDoc);
            IsInMachineWithMappedDriveLetters = System.IO.Directory.GetLogicalDrives().Any(name => name.Contains(":"));
        }
​
#region Static XDoc dependency
        public void SaveXDoc()
        {
            XDoc.Save(Path); //, ResourceCentral.Properties.Resources.GenderFromName
        }
​
        /// <summary>
        /// If it not find Gender from Name, it will return default that is 0
        /// </summary>
        /// <param name = "nameToTest"></param>
        /// <returns></returns>
        public WhichGender LoadGenderInferredFromFirstName(string firstNameToTest)
        {
            var genderValue = PatientServices.ParseGenderFromStr(GetGenderFromFirstNameOrDefault(firstNameToTest));
            return genderValue;
        }
​
        public static WhichGender GetGenderFromName(string firstName)
        {
            if (string.IsNullOrEmpty(firstName) || !GenderCanBeInferred(firstName))
                return WhichGender.Indeterminado;
            return PatientServices.ParseGenderFromStr(GetGenderFromFirstNameOrDefault(firstName));
        }
​
        public int HowManyNameVsGenderCatalogued()
        {
            return XDoc.Descendants("NomevsSexo").Elements("PrimeiroNome").Count();
        }
​
#endregion
        /// <summary>
        /// Não é estática!!!
        /// TODO avaliar esta confusão; claro que é para ser estática...
        /// </summary>
        /// <param name = "strToParseGender"></param>
        /// <param name = "genderOfName"></param>
        /// <returns></returns>
        public bool GenderCannotBeInferred(string strToParseGender, WhichGender genderOfName)
        {
            //Only for test purpose
            return WhichGender.Indeterminado == (genderOfName != WhichGender.Indeterminado ? genderOfName : PatientServices.ParseGenderFromStr(strToParseGender));
        }
​
        public static bool GenderCanBeInferred(string strToParseGender)
        {
            return WhichGender.Indeterminado != PatientServices.ParseGenderFromStr(GenderStringFromFirstName(strToParseGender));
        }
​
        /// <summary>
        /// nameToTest is the full name; it parses it and test first name only
        /// </summary>
        /// <param name = "nameToTest"></param>
        /// <returns></returns>
        public static string GenderStringFromFirstName(string fullNameToTest)
        {
            var firstName = fullNameToTest.Split(' ')[0];
            if (XDoc == null)
                return "Indeterminado";
            try
            {
                return GetGenderFromFirstNameOrDefault(firstName);
            }
            catch (Exception)
            {
                return "Indeterminado";
            }
        }
​
        private static string GetGenderFromFirstNameOrDefault(string firstName)
        {
            return XDoc.Descendants("NomevsSexo").Where(x => x.Element("PrimeiroNome").Value == firstName).Select(y => y.Element("sexo").Value).FirstOrDefault();
        }
​
        public static WhichGender GenderFromFullName(string fullNameToTest)
        {
            //ParseGenderFromStr(nameToTest).EnumToInt().ToString()
            return PatientServices.ParseGenderFromStr(GenderStringFromFirstName(fullNameToTest));
        }
​
        public static Maybe<WhichGender> GenderFromPatientJson(string patientFullName)
        {
            //TODO: implement it
            return Maybe<WhichGender>.None;
        }
​
        public static WhichGender ParseGenderFromStr(string genderToParse)
        {
            return PatientServices.ParseGenderFromStr(genderToParse);
        }
​
        public void DeleteFirstNameAndGenderFromXML(string nameToTest)
        {
            XMLDataServices.DeleteFirstNameAndGenderFromXML(nameToTest, XDoc);
            SaveXDoc();
        }
​
        public void AddFirstNameAndGenderToXML(string nameToTest, WhichGender genderOfName, LanguageName whichLanguage)
        {
            //https://stackoverflow.com/questions/8642980/inserting-particular-xelement-at-specific-position-in-a-xml-using-linq
            XMLDataServices.AddFirstNameAndGenderToXML(nameToTest, genderOfName, XDoc, whichLanguage);
            SaveXDoc();
        }
​
        public static List<string> PreposicoesNomeProprio()
        {
            var fileToRead = ""; // Combine(AuxiliaryFolderStructure.Data.Path, PreposicoesTextoNormal);
            var lines = File.ReadLines(fileToRead, Encoding.UTF8).ToList();
            return lines;
        }
​
        //TODO: get above and below fileToRead from SourceJson as a Singleton, loading it once in ApplicationServices instantiation
        //tradeoff to avoid global variables for state that is the result of one-time, heavy operations                 
        public static string FullNameInProperCase(string name)
        {
            var space = " ";
            var parts = name.Split(' ');
            var fileToRead = ""; //Combine(AuxiliaryFolderStructure.Data.Path, Resources.PreposicoesNomeProprio);
            //https://stackoverflow.com/questions/2182342/parse-lines-using-linq-to-txt
            var allLines =
                from line in File.ReadLines(fileToRead, Encoding.UTF8)let cleanedLines = line.RemoveBrackets()select cleanedLines;
            var preposicoesNomeProprio = allLines.ToList();
            var fullName = string.Empty;
            foreach (var part in parts)
            {
                if (preposicoesNomeProprio.Contains(part))
                {
                    fullName += part + space;
                }
                else
                {
                    if (NameHasApostrophe(part))
                    {
                        fullName += char.ToUpper(part[0]) + "'" + part.Substring(2, part.Length - 2).CapitalizeFirstLetter() + space;
                    }
                    else if (part == "TESTE")
                    {
                        fullName += part + space;
                    }
                    else
                    {
                        fullName += part.CapitalizeFirstLetter() + space;
                    }
                }
            }
​
            return fullName.Trim();
        }
​
        public static string ReturnCorrectFirstLetterOfNameThatHasApostrophe(string part) => //part.Substring(2,part.Length-2);
        char.ToUpper(part[2]).ToString();
        public static bool NameHasApostrophe(string part) //, int positionOfApostrophe = 1)
 => part.Contains("'");
​
         //public static DateTime OutlookEarliestDateThatDoesntProvokeError => Convert.ToDateTime(OutlookEarliestDateThatDoesntProvokeErrorEntry);
        public static DateTime MinBirthYearToStillBeAlive => DateTime.Now.AddYears(-119);
        //public static DateTime GetDateOrAppropriateMinimalDate(DateTime dateToTest)
        //public static string DefaultCountry() => Resources.DefaultCountry;
        //public static string DefaultCountryLocalName() => Resources.DefaultCountryLocalName;
        //public static string DefaultState() => Resources.DefaultState;
        //public static string DefaultCity() => Resources.DefaultCity;
        public static string HeaderRTFLatin => @"{\rtf1\ansi\ansicpg1252\deff0\deflang2070" + @"{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;}" + @"{\fonttbl{\f0\fnil\fcharset0 Microsoft Sans Serif;}}\viewkind4\uc1\pard\fs20 ";
​
        //To get below or similar Enum based on HeaderRTFLatin:
        // => Documents\Consultório Impressos\DB Pacientes\LINQPad Queries\Generating Enum Colors for RTF.linq
        //https://stackoverflow.com/questions/11728209/how-to-get-the-name-of-color-while-having-its-rgb-value-in-c
        //public enum ColorString       
​
        public static string ConvertString2RTF(string input)
        {
            //first take care of special RTF chars
            StringBuilder backslashed = new StringBuilder(input);
            backslashed.Replace(@"\", @"\\");
            backslashed.Replace(@"{", @"\{");
            backslashed.Replace(@"}", @"\}");
            //then convert the string char by char
            StringBuilder sb = new StringBuilder();
            foreach (char character in backslashed.ToString())
            {
                if (character <= 0x7f)
                    sb.Append(character);
                else
                    sb.Append("\\u" + Convert.ToUInt32(character) + "?");
            }
​
            return sb.ToString();
        }
​
        //public static List<int, string> ReturnKeyValuePairList<TValue>(Enum TValue) where TValue : Enum
        //{
        //    return  Enum.GetValues(typeof(enumType))
        //                    .Cast<T>()
        //    //                ^^^^^^ https://stackoverflow.com/a/15457453/2752308
        //                    .Select(e => new { Key = e, Value = e }).ToList();
        //    //                  ^^^^  https://stackoverflow.com/a/42345540/2752308
        //}
        public class KeyValuePair
        {
            //https://stackoverflow.com/a/6294585/2752308
            //var EtniaSource = ApplicationServices.KeyValuePair.ListFrom<WhichEtnia>();
            public string Key { get; set; }
            public string Name { get; set; }
            public int Value { get; set; }
​
            public static List<KeyValuePair> ListFrom<T>(bool splitCapitalizedWords = false)
            {
                var array = (T[])(Enum.GetValues(typeof(T)));
                return array.Select(a => new KeyValuePair { Key = a.ToString(), Name = (splitCapitalizedWords ? a.ToString().SplitCapitalizedWords() : a.ToString()), Value = Convert.ToInt32(a) }).OrderBy(kvp => kvp.Value).ToList();
            }
        }
    }
//namespace PatientManagerMD.ResourceCentral.Services
//{
    public static class XMLServices
    {
        public static int Position(this XNode node)
        {
            return node.NodesBeforeSelf().Count();
        }
​
        public static void SortElemByName(this XContainer container)
        {
            container.ReplaceNodes(
                from childEl in container.Elements()
                orderby childEl.Name.LocalName
                select childEl
            );
            foreach (XElement childEl in container.Elements().Where(e => e.HasElements))
            {
                SortElemByName(childEl);
            }
        }
​
        public static void SortElementsByNameInPlace(this XContainer xContainer)
        {
            //foreach (XElement element in xContainer.Descendants("NomevsSexo").Elements("PrimeiroNome"))//Descendants())
            foreach (XElement element in xContainer.Descendants("NomevsSexo")) //Descendants())
            {
                var orderedElements =
                (
                    from child in element.Elements()
                    orderby child.Value
                    select child
                ).ToList(); // ToList matters, since we remove all of the child elements next
​
                element.Elements().Remove();
                element.Add(orderedElements);
            }
        }
​
        public static void
            SortAllElements(this XContainer container) //this XElement source, bool bSortAttributes = true)
        {
            container.ReplaceNodes(
                from childEl in container.Elements()
                orderby childEl.Value
                select childEl
            );
            foreach (XElement childEl in container.Elements().Where(e => e.HasElements))
            {
                SortAllElements(childEl);
            }
        }
    }
    //namespace PatientManagerMD.ResourceCentral.Services
    //{
    public class XMLDataServices
    {
        public string Path { get; private set; }
​
        public XMLDataServices(string path)
        {
            Path = path;
        }
​
        private void GuardClauseAgainstInjectorNotInitialized()
        {
            if (string.IsNullOrEmpty(Path))
            {
                throw new ArgumentNullException("Path não pode ser vazia!!!");
            }
        }
​
        public void DeleteFirstNameAndGenderFromXML(string nameToTest, XDocument doc)
        {
            try
            {
                GuardClauseAgainstInjectorNotInitialized();
                doc.Descendants("NomevsSexo").Where(x => x.Element("PrimeiroNome").Value == nameToTest).Remove();
            //doc.Save(Path);//Path.Combine(AuxiliaryFolderStructure.SupportPathTest, ResourceCentral.Properties.Resources.GenderFromName));
            }
            catch (ArgumentNullException)
            {
                throw;
            }
        }
​
        public void AddFirstNameAndGenderToXML(string nameToTest, WhichGender genderOfName, XDocument doc, LanguageName languageName)
        {
            GuardClauseAgainstInjectorNotInitialized();
            //https://stackoverflow.com/questions/8642980/inserting-particular-xelement-at-specific-position-in-a-xml-using-linq
            var indexFirstNode = doc.Descendants("NomevsSexo").FirstOrDefault(x => string.Compare(x.Element("PrimeiroNome")?.Value, nameToTest) == -1)?.Position();
            //var nodeLower =
            //    doc.Descendants("NomevsSexo")
            //        .LastOrDefault(x => string.Compare(x.Element("PrimeiroNome")?.Value, nameToTest) == -1);
            //var indexNodeLower = nodeLower?.Position();
            var indexNodeHigher = doc.Descendants("NomevsSexo").FirstOrDefault(x => string.Compare(x.Element("PrimeiroNome")?.Value, nameToTest) == 1)?.Position();
            // Se fosse usar indexNodeLower seria AddAfterSelf()
            var nodeToAdd = new XElement("NomevsSexo", new XElement("PrimeiroNome", nameToTest, new XAttribute("Language", languageName.GetDescription())), new XElement("sexo", (int)genderOfName));
            if (indexNodeHigher.HasValue && indexFirstNode.HasValue)
            {
                //https://stackoverflow.com/questions/24623391/add-xelement-to-another-xelement-in-specific-location
                doc.Element("InfereSexoPorNome")?.Elements("NomevsSexo").ElementAt((int)(indexNodeHigher - indexFirstNode)).AddBeforeSelf(nodeToAdd);
            }
            else
            {
                doc.Element("InfereSexoPorNome")?.LastNode.AddAfterSelf(nodeToAdd);
            }
        //doc.Save(Path);//Path.Combine(AuxiliaryFolderStructure.SupportPathTest, ResourceCentral.Properties.Resources.GenderFromName));
        }
    }
​
    //namespace PatientManagerMD.ResourceCentral.Services
    //{
    /// <summary>
    /// Paradoxically, despite it's name, it is for Application wide services that does not depends on Model;
    /// if I allow that, it would create a Circular Reference error.
    /// That is why I had to move a lot of helpers and enums to this assembly
    /// </summary>
    public static class PatientServices
    {
#region Deals with ID
        /// <summary>
        /// It coordinates logic to extract ID from Olk, if there is a valid ID;
        /// if ID is valid, but repeated, it generates a random one, very out of range to be a marker that
        /// it has to be modified
        /// If ID is not valid number, or null, it uses incremental counter, but assures that it
        /// is not repeated too
        /// </summary>
        /// <param name = "candidateID"></param>
        /// <param name = "onlyDifferentRandomIDs"></param>
        /// <param name = "onlyDifferentIncrementIDs"></param>
        /// <param name = "count"></param>
        /// <returns></returns>
         //..public static long IDToUse(string candidateID, ref List<long> onlyDifferentRandomIDs, ref List<long> onlyDifferentIncrementIDs,
        /// <summary>
        /// Random long
        /// </summary>
        /// <param name = "seed">Seed cannot be less than 1 or greater than 100.000</param>
        /// <param name = "range">Range cannot be zero or negative or greater than 1000</param>
        /// <returns></returns>
        /// ", nameof(range));
         //...public static long GetNewRandomID(long seed, long range)
        //..public static long GetProperIDToUse(string customerId)
        public static bool AddedIfNotAlreadyExists(ref List<long> nonRepeat, long numToTry)
        {
            var exists = nonRepeat.Any(l => l == numToTry);
            if (!exists)
                nonRepeat.Add(numToTry);
            return !exists;
        }
​
        //.. public static long UseThisID_orGenerateProperID(ref List<long> nonRepeat, long numToTry)
        /// <summary>
        /// It will increment before trying: ++counter
        /// </summary>
        /// <param name = "nonRepeat"></param>
        /// <param name = "numToTry"></param>
        /// <returns></returns>
        public static long GetNonRepeatedIncrementalID(ref List<long> nonRepeat, long numToTry)
        {
            if (AddedIfNotAlreadyExists(ref nonRepeat, numToTry))
                return numToTry;
            bool added;
            do
            {
                ++numToTry;
                added = AddedIfNotAlreadyExists(ref nonRepeat, numToTry);
            }
            while (!added);
            return numToTry;
        }
​
#endregion
        //From VBA:
        //?Outlook.OlGender.olUnspecified
        //0 
        //?Outlook.OlGender.olMale
        //2 
        //?Outlook.OlGender.olFemale   
        //1
        public enum OlGender
        {
            OlUnspecified = 0,
            OlFemale = 1,
            OlMale = 2
        }
​
        public static string WhichStringGender(OlGender genderToConvertToString)
        {
            return genderToConvertToString switch
            {
                OlGender.OlFemale => Enum.GetName(typeof(WhichGender), WhichGender.Feminino),
                OlGender.OlMale => Enum.GetName(typeof(WhichGender), WhichGender.Masculino),
                _ => Enum.GetName(typeof(WhichGender), WhichGender.Indeterminado),
            };
        }
​
        public static WhichGender WhichGenderFromOutlook(OlGender genderToConvertToPatient)
        {
            return genderToConvertToPatient switch
            {
                OlGender.OlFemale => WhichGender.Feminino,
                OlGender.OlMale => WhichGender.Masculino,
                _ => WhichGender.Indeterminado,
            };
        }
​
        public static WhichGender WhichGenderFromOutlook(int genderToConvertToPatient)
        {
            return genderToConvertToPatient switch
            {
                1 => WhichGender.Feminino,
                2 => WhichGender.Masculino,
                _ => WhichGender.Indeterminado,
            };
        }
​
        public static WhichGender GetGenderFromOutlook(WhichGender appropriateGenderToUse)
        {
            //TODO: rever esta lógica e ver se dá para usar as anteriores...
            //Era o que estava no GenderToFromOutlook Setr da Patient.cls
            if (appropriateGenderToUse == WhichGender.Feminino)
                return (WhichGender)WhichGenderToFromOlk.Feminino;
            if (appropriateGenderToUse == WhichGender.Masculino)
                return (WhichGender)WhichGenderToFromOlk.Masculino;
            if (appropriateGenderToUse == WhichGender.Indeterminado)
                return appropriateGenderToUse;
            return WhichGender.Indeterminado;
        }
​
        public static OlGender WhichGenderToOutlookEnum(WhichGender genderToConvertToOlk)
        {
            return genderToConvertToOlk switch
            {
                WhichGender.Feminino => OlGender.OlFemale,
                WhichGender.Masculino => OlGender.OlMale,
                _ => OlGender.OlUnspecified,
            //_ => throw new ArgumentOutOfRangeException(nameof(genderToConvertToOlk), genderToConvertToOlk, null)
            };
        }
​
        public static int WhichGenderToOutlookInt(WhichGender genderToConvertToOlk)
        {
            return genderToConvertToOlk switch
            {
                WhichGender.Feminino => 1,
                WhichGender.Masculino => 2,
                _ => 0,
            //_ => throw new ArgumentOutOfRangeException(nameof(genderToConvertToOlk), genderToConvertToOlk, null)
            };
        }
​
        public static WhichGender ParseGenderFromStr(string genderToParse)
        {
            var genderValue = genderToParse?.ToLower();
            var gender = WhichGender.Indeterminado;
            switch (int.TryParse(genderValue, out _) ? "StringAsEnum" : string.IsNullOrEmpty(genderValue) ? "StringAsEnum" : genderValue.Length > 1 ? "StrToParse" : genderValue.Length == 1 ? "CharToParse" : "NotPossible")
            {
                case "StringAsEnum":
                    gender = (WhichGender)Enum.Parse(typeof(WhichGender), genderValue ?? WhichGender.Indeterminado.ToString(), true);
                    break;
                case "StrToParse":
                    // Attention to their order!
                    var feminino = new[]
                    {
                        "feminino",
                        "fem",
                        "mulher",
                        "women",
                        "woman"
                    };
                    var masculino = new[]
                    {
                        "masculino",
                        "masc",
                        "homem",
                        "men",
                        "man"
                    };
                    if (feminino.Any(genderValue.Contains))
                    {
                        gender = WhichGender.Feminino;
                    }
                    else if (masculino.Any(genderValue.Contains))
                    {
                        gender = WhichGender.Masculino;
                    }
​
                    break;
                case "CharToParse":
                    var fem = new[]
                    {
                        "f",
                        "w"
                    };
                    if (fem.Any(genderValue.Contains))
                        gender = WhichGender.Feminino;
                    var masc = new[]
                    {
                        "m"
                    };
                    if (masc.Any(genderValue.Contains))
                        gender = WhichGender.Masculino;
                    break;
                case "NotPossible":
                    throw new ArgumentOutOfRangeException();
            }
​
            return gender;
        }
​
        /// <summary>
        /// TODO: avaliar se precise ser Result ao invés de Maybe, caso dê erro de serialização
        /// </summary>
        /// <param name = "patientFullName"></param>
        /// <returns></returns>
        public static Maybe<WhichGender> GetGenderFromJsonOrParseFromName(string patientFullName)
        {
            if (!string.IsNullOrEmpty(patientFullName) && patientFullName.Contains(" ") && patientFullName.Length > 5)
                return Maybe<WhichGender>.None;
            //TODO: Plan if every folder will have a niny json with basic data, including gender and DOB, or if it will be in a central place   
            var maybeGender = ApplicationServices.GenderFromPatientJson(patientFullName);
            return maybeGender.HasNoValue ? ApplicationServices.GenderFromFullName(patientFullName) : maybeGender;
        }
​
        public static string WhichStringEtnia(WhichEtnia etniaToConvertToString)
        {
            return Enum.GetName(typeof(WhichEtnia), etniaToConvertToString);
        }
​
        public static string WhichStringTipoSang(WhichBloodType BloodTypeToConvertToString)
        {
            return Enum.GetName(typeof(WhichBloodType), BloodTypeToConvertToString);
        }
​
        public static string WhichStringFatorRh(WhichRhFactor RhFactorToConvertToString)
        {
            return Enum.GetName(typeof(WhichRhFactor), RhFactorToConvertToString);
        }
    }
}
​
namespace PatientManagerMD.ResourceCentral.DataHelper
{
    public static class EnumPatient
    {
        public enum Enums
        {
            WhichContactMethod,
            WhichContactType,
            CategoriaPaciente,
            HowToString,
            HowToDisplayAge,
            WhichGender,
            WhichEtnia,
            WhichBloodType,
            WhichRhFactor
        }
​
        /// <summary>
        /// try to use ObjectExtensions GetAllValuesByEnumType
        /// </summary>
        /// <param name = "whichType"></param>
        /// <returns></returns>
        /// <exception cref = "ArgumentOutOfRangeException"></exception>
        public static Dictionary<int, string> GetAllValues(Enums whichType)
        {
            switch (whichType)
            {
                case Enums.WhichContactMethod:
                    return Utilities.EnumNamedValues<WhichContactMethod>();
                case Enums.WhichContactType:
                    return Utilities.EnumNamedValues<WhichContactType>();
                case Enums.CategoriaPaciente:
                    return Utilities.EnumNamedValues<PatientCategory>();
                case Enums.HowToString:
                    return Utilities.EnumNamedValues<HowToString>();
                case Enums.HowToDisplayAge:
                    return Utilities.EnumNamedValues<HowToDisplayAge>();
                case Enums.WhichGender:
                    return Utilities.EnumNamedValues<WhichGender>();
                case Enums.WhichEtnia:
                    return Utilities.EnumNamedValues<WhichEtnia>();
                case Enums.WhichBloodType:
                    return Utilities.EnumNamedValues<WhichBloodType>();
                case Enums.WhichRhFactor:
                    return Utilities.EnumNamedValues<WhichRhFactor>();
                default:
                    throw new ArgumentOutOfRangeException(nameof(whichType), whichType, null);
            }
        }
    }
​
    public enum WhichContactMethod
    {
        EMAIL = 1,
        PHONE_TYPE,
        ADDRESS_TYPE
    }
​
    public enum WhichContactType
    {
        [Description("Não informado")]
        NOTINFORMED = -1,
        [Description("Pessoal")]
        PERSONAL = 1,
        [Description("Trabalho")]
        WORK,
        [Description("do Contato/Acompanhante")]
        AssistantContact,
    }
​
    public enum WhichPhoneType
    {
        [Description("Outros")]
        NOTINFORMED = -1,
        [Description("Residencial 1")]
        HomeTelephoneNumber = 1,
        [Description("Residencial 2")]
        Home2TelephoneNumber,
        [Description("Celular principal")]
        PrimaryTelephoneNumber,
        [Description("Celular 2")]
        MobileTelephoneNumber,
        [Description("Trabalho 1")]
        BusinessTelephoneNumber,
        [Description("Trabalho 2")]
        Business2TelephoneNumber,
        [Description("Contato/Acompanhante 1")]
        AssistantTelephoneNumber,
        // There is AssistantName but I will not use; Olk lets store something like: 
        //(21)9999-5467|Esposa Sr.a Maria Francisca Tavares
        [Description("Contato/Acompanhante 2")]
        Assistant2TelephoneNumber //Mapped to ISDNNumber
    }
​
    public enum PatientCategory // vbTiposCategoriaPacientes
    {
        //'strCategoriaPacientes
        [Description("Pacientes Meus")]
        Pacientes_meus = 1,
        [Description("Pacientes de Colegas")]
        Pacientes_de_outros = 2,
        [Description("Pacientes USA Consulate")]
        Pacientes_USAConsulate = 3,
        [Description("Pacientes outros")]
        Pacientes_Outros = 4
    } //End enum
​
    public enum HowToString
    {
        [Description("Nome todo")]
        OnlyFullName = 1,
        [Description("Só iniciais")]
        OnlyInitials,
        [Description("Só primeiro nome")]
        OnlyFirstName,
        [Description("Só idade")]
        OnlyAge,
        [Description("Nome todo, idade")]
        FullNameWithAge,
        [Description("Iniciais, idade")]
        InitialsWithAge,
        [Description("Nome todo, idade, niver")]
        FullNameWithAgeAndBirthDay
    }
​
    public enum HowToDisplayAge
    {
        [Description("Idade")]
        OnlyYears = 1,
        [Description("Idade, com meses")]
        YearsAndMonths,
        [Description("Idade, com meses e dias")]
        YearsMonthsAndDays
    }
​
    public enum WhichGender
    {
        Indeterminado = 0,
        Masculino = 1,
        Feminino
    }
​
    public enum WhichGenderToFromOlk
    {
        Indeterminado = 0,
        Feminino = 1,
        Masculino
    }
​
    public enum WhichEtnia
    {
        [Description("Não especificada")]
        Indeterminada = 0,
        Branca = 1,
        Negra,
        Parda,
        Amarela,
        [Description("Indígena")]
        Indigena
    }
​
    public enum WhichBloodType
    {
        [Description("Não informado")]
        Unspecified = 0,
        [Description("Tipo 0")]
        Zero = 1,
        [Description("Tipo A")]
        A = 2,
        [Description("Tipo B")]
        B = 3,
        [Description("Tipo AB")]
        AB = 4
    }
​
    public enum WhichRhFactor
    {
        Unspecified = 0,
        Positivo = 1,
        Negativo = 2
    }
}
​
namespace PatientManagerMD.ResourceCentral.AppResource
{
    public static class Utilities
    {
        //...
        /// <summary>
        /// https://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum
        /// Only after 7.3
        /// </summary>
        /// <typeparam name = "T"></typeparam>
        /// <returns></returns>
        public static Dictionary<int, string> EnumNamedValues<T>()
            where T : System.Enum
        {
            var result = new Dictionary<int, string>();
            var values = Enum.GetValues(typeof(T));
            foreach (int item in values)
                result.Add(item, Enum.GetName(typeof(T), item));
            return result;
        }
    //...
    }
}
​
namespace PatientManagerMD.ResourceCentral.EnumHelper
{
    public class CommonEnums
    {
        public enum LanguageName
        {
            //https://stackoverflow.com/questions/8852253/how-can-i-get-enum-to-contain-a-dash
            //https://stackoverflow.com/questions/4367723/get-enum-from-description-attribute
            //https://stackoverflow.com/questions/2650080/how-to-get-c-sharp-enum-description-from-value
            [Description("PT-BR")]
            PT_BR = 1,
            [Description("EN-US")]
            EN_US
        //^^^^ Description Attribute is not serializable.
        //Use [EnumMember(Value = "PT-BR")] from System.Runtime.Serialization
        //https://stackoverflow.com/a/14394694/2752308
        }
​
        /// <summary>
        /// From: http://www.mimekit.net/docs/html/T_MimeKit_Text_TextFormat.htm
        /// https://stackoverflow.com/questions/22502924/how-to-determine-text-format-in-c-sharp
        /// </summary>
        public enum TextFormat
        {
            Plain = 0, //   The plain text format.
            Text = 0, //    An alias for the plain text format.
            Flowed = 1, //  The flowed text format (as described in rfc3676).
            Html = 2, //    The HTML text format.
            Enriched = 3, //    The enriched text format.
            CompressedRichText = 4, //  The compressed rich text format.
            RichText = 5 // The rich text format.
        }
    }
}
​
namespace PatientManagerMD.ResourceCentral.ExtensionMethods
{
    // ###################            ##################################      StringTextExtensions      ##################################            ###################
    public static class StringTextExtensions
    {
        private const char OneBlankSpace = ' ';
        public static string RemoveUnnecessarySpaces(this string textToTrim)
        {
            return Regex.Replace(textToTrim, @"\s+", " ").Trim();
        }
​
        public static string RemoveAllSpaces(this string textToTrim)
        {
            return textToTrim.Replace(" ", string.Empty);
        }
​
        public static string RemoveAllPunctuation(this string textToTrim)
        {
            //https://stackoverflow.com/questions/421616/how-can-i-strip-punctuation-from-a-string
            return new string (textToTrim.Where(c => !char.IsPunctuation(c)).Where(c => !char.IsSymbol(c)).ToArray());
        //return Regex.Replace(textToTrim, @"[a-zA-ZçÇ à-úÀ-Ú]+", string.Empty).Trim();
        //return Regex.Replace(textToTrim, @"\p{P}+", string.Empty).Trim();
        //^^^^^cuidado! @"\p{P}+" ou "\\p{P}+": nunca @"\\p{P}+"
        }
​
        public static string GetRidOfNonLetterCharsInKeyOrPairElements(this string rawString) => rawString.RemoveAllPunctuation().RemoveAllSpaces().RemoveBrackets();
        public static string GetNumberOfCharsJustBeforeSubstring(this string text, string beforeThis, int numberOfChars = 1)
        {
            string txtBefore = null;
            try
            {
                txtBefore = text.GetUntilOrEmpty(beforeThis);
                return txtBefore.Length > 0 ? text.GetUntilOrEmpty(beforeThis).Substring(txtBefore.Length - numberOfChars) : string.Empty;
            }
            catch (Exception ex)
            {
                //Console.WriteLine(ex.Message);
                Console.WriteLine($"GetNumberOfCharsJustBeforeSubstring error {ex.Message}: tried to subtract {txtBefore.Length} – {numberOfChars}");
                return string.Empty;
            }
        }
​
        public static string GetUntilOrEmpty(this string text, string stopAt = "-")
        {
            if (!string.IsNullOrWhiteSpace(text))
            {
                int charLocation = text.IndexOf(stopAt, StringComparison.Ordinal);
                if (charLocation > 0)
                {
                    return text.Substring(0, charLocation);
                }
            }
​
            return string.Empty;
        }
​
        public static string GetAfterOrEmpty(this string text, string stopAt = "-")
        {
            if (!string.IsNullOrWhiteSpace(text))
            {
                int charLocation = text.IndexOf(stopAt, StringComparison.Ordinal);
                if (charLocation > 0)
                {
                    return text.Substring(charLocation + stopAt.Length, text.Length - charLocation - stopAt.Length);
                }
            }
​
            return string.Empty;
        }
​
        public static string SubstituteSubstringAtSpecificPositionForAnother(this string text, string substringToReplace, string replacement, int position)
        {
            //https://stackoverflow.com/questions/8809354/replace-a-character-at-a-specific-index-in-a-string
            var sb = new StringBuilder(text);
            sb.Remove(position, substringToReplace.Length).Insert(position, replacement);
            return sb.ToString();
        }
​
        public static string GetMiddleString(this string inputString, char separator = OneBlankSpace)
        {
            //this is assuming that your tokens only happens one time in the string
            //https://stackoverflow.com/questions/2449561/retrieve-string-from-the-middle-of-a-string
            var input = inputString.Split(separator);
            var firstToken = input[0];
            var lastToken = input[input.Length - 1];
            var pos1 = inputString.IndexOf(firstToken) + firstToken.Length;
            var pos2 = inputString.IndexOf(lastToken);
            var result = inputString.Substring(pos1, pos2 - pos1).Trim() ?? string.Empty;
            return result;
        }
​
        public static bool NextCharAfterThisExcerpt(this string text, string uniqueExcerpt, char dot)
        {
            return text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length < text.Length && text[text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length] == dot;
        }
​
        //TODO test it
        public static bool NextCharAfterThisExcerpt(this string text, string uniqueExcerpt, char[] chars)
        {
            return text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length < text.Length && chars.Contains(text[text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal) + uniqueExcerpt.Length]);
        }
​
        public static string AddSubstringAfterThisFoundExcerpt(this string text, string uniqueExcerpt, string toAdd)
        {
            return text.ToLower().Replace(uniqueExcerpt, uniqueExcerpt + toAdd);
        }
​
        public static string RemoveSubstringAfterThisFoundExcerpt(this string text, string uniqueExcerpt, string toRemove)
        {
            return text.ToLower().Replace(uniqueExcerpt + toRemove, uniqueExcerpt);
        }
​
        public static string AddSubstringAfterThisFirstFoundExcerpt(this string text, string uniqueExcerpt, string toAdd)
        {
            var index = text.ToLower().IndexOf(uniqueExcerpt, StringComparison.Ordinal);
            if (index < 0)
                return text;
            var firstPart = text.Substring(0, index);
            var secondPart = text.Substring(index + uniqueExcerpt.Length);
            return firstPart + uniqueExcerpt + toAdd + secondPart;
        }
​
        public static (string textBefore, string textAfter) GetTextBeforeAndAfterSubstring(this string textToExtract, string stringToSearchFor, int desiredLengthToCut, int indexToSearchedString)
        {
            //var indexToSearchedString = textToExtract.IndexOf(stringToSearchFor, StringComparison.Ordinal);
            var textBefore = textToExtract.Substring(indexToSearchedString - desiredLengthToCut < 0 ? 0 : indexToSearchedString - desiredLengthToCut, indexToSearchedString - desiredLengthToCut > 0 ? desiredLengthToCut : indexToSearchedString);
            var textAfter = textToExtract.Substring(indexToSearchedString + stringToSearchFor.Length, DecideHowMuchItCanCutAfter(textToExtract.Length, indexToSearchedString + stringToSearchFor.Length, desiredLengthToCut));
            return (textBefore, textAfter);
            static int DecideHowMuchItCanCutAfter(int totalLength, int beginCut, int lengthToCut)
            {
                if (beginCut + lengthToCut < totalLength)
                    return lengthToCut;
                if (beginCut + lengthToCut >= totalLength)
                    return totalLength - beginCut;
                return 0;
            }
        }
​
        public static string RemoveDiacritics(this string s)
        {
            string normalizedString = s.Normalize(NormalizationForm.FormD);
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < normalizedString.Length; i++)
            {
                char c = normalizedString[i];
                if (CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
                    stringBuilder.Append(c);
            }
​
            return stringBuilder.ToString();
        }
​
        public static string RemoveBrackets(this string s)
        {
            return s.Replace("[", string.Empty).Replace("]", string.Empty);
        }
​
        public static string SurroundWithDoubleQuotes(this string text)
        {
            return SurroundWith(text, "\"");
        }
​
        public static string SurroundWith(this string text, string ends)
        {
            return ends + text + ends;
        }
​
        public static string EscapeSingleQuote(this string text)
        {
            return text.Replace("'", @"\'");
        }
​
        public static string AddSingleQuoteAsEscapeCharacter(this string text)
        {
            //https://docs.microsoft.com/pt-br/dotnet/api/microsoft.office.interop.outlook._items.find?view=outlook-pia
            return text.Replace("'", @"''");
        }
​
        public static string EnsureOneSingleSpaceAtBegin(this string text)
        {
            return OneBlankSpace + text.TrimStart();
        }
​
        public static string CapitalizeFirstLetter(this string value)
        {
            //In Case if the entire string is in UpperCase then convert it into lower
            value = value.ToLower();
            char[] array = value.ToCharArray();
            // Handle the first letter in the string.
            if (array.Length >= 1)
            {
                if (char.IsLower(array[0]))
                {
                    array[0] = char.ToUpper(array[0]);
                }
            }
​
            // Scan through the letters, checking for spaces.
            // ... Uppercase the lowercase letters following spaces.
            for (int i = 1; i < array.Length; i++)
            {
                if (array[i - 1] == ' ')
                {
                    if (char.IsLower(array[i]))
                    {
                        array[i] = char.ToUpper(array[i]);
                    }
                }
            }
​
            return new string (array);
        }
​
        /// <summary>
        /// Split a string on each occurrence of a capital (assumed to be a word)
        /// e.g. MyBigToe returns "My Big Toe"
        /// </summary>
        public static string SplitCapitalizedWords(this string source)
        {
            if (String.IsNullOrEmpty(source))
                return String.Empty;
            var newText = new StringBuilder(source.Length * 2);
            newText.Append(source[0]);
            for (int i = 1; i < source.Length; i++)
            {
                if (char.IsUpper(source[i]))
                    newText.Append(' ');
                newText.Append(source[i]);
            }
​
            return newText.ToString();
        }
​
        public static string TrimLastCharacter(this String str) => String.IsNullOrEmpty(str) ? str : str.TrimEnd(str[str.Length - 1]);
        /// <summary>
        /// https://stackoverflow.com/questions/6865419/indexof-for-multiple-results
        /// https://stackoverflow.com/questions/15993357/how-to-get-all-indexof-instances-of-string-in-another-string-c-sharp
        /// </summary>
        /// <param name = "str"></param>
        /// <param name = "searchString"></param>
        /// <returns></returns>
        public static IEnumerable<int> AllIndexesOf(this string str, string searchString)
        {
            int minIndex = str.IndexOf(searchString, StringComparison.Ordinal);
            while (minIndex != -1)
            {
                yield return minIndex;
                minIndex = str.IndexOf(searchString, minIndex + searchString.Length, StringComparison.Ordinal);
            }
        }
​
        /// <summary>
        ///     A string extension method that query if '@this' contains any values.
        /// </summary>
        /// <param name = "this">The @this to act on.</param>
        /// <param name = "values">A variable-length parameters list containing values.</param>
        /// <returns>true if it contains any values, otherwise false.</returns>
        public static bool ContainsAny(this string @this, params string[] values)
        {
            foreach (string value in values)
            {
                if (@this.IndexOf(value) != -1)
                {
                    return true;
                }
            }
​
            return false;
        }
​
        public static int CountOccurrences(this string text, string pattern)
        {
            //https://stackoverflow.com/questions/541954/how-would-you-count-occurrences-of-a-string-within-a-string-c
            return (text.Length - text.Replace(pattern, "").Length) / pattern.Length;
        }
​
        /// <summary>
        ///     A string extension method that query if '@this' contains any values.
        /// </summary>
        /// <param name = "this">The @this to act on.</param>
        /// <param name = "comparisonType">Type of the comparison.</param>
        /// <param name = "values">A variable-length parameters list containing values.</param>
        /// <returns>true if it contains any values, otherwise false.</returns>
        public static bool ContainsAny(this string @this, StringComparison comparisonType, params string[] values)
        {
            foreach (string value in values)
            {
                if (@this.IndexOf(value, comparisonType) != -1)
                {
                    return true;
                }
            }
​
            return false;
        }
​
        public static bool DoesNotContainAnySpace(this string @this) => !@this.Any(char.IsWhiteSpace);
        public static bool DoesNotContainAnyNumbers(this string @this) => @this.ReturnOnlyNumbers().Length == 0;
        public static bool StringHasOnlyNumbers(this string @this) => @this.ReturnOnlyNumbers().Length == @this.Length;
        //https://stackoverflow.com/questions/3293295/string-contains-only-a-given-set-of-characters
        public static bool ContainsOnly(this string @this, string allowedChars) => @this.All(allowedChars.Contains);
        //https://stackoverflow.com/questions/4734116/find-and-extract-a-number-from-a-string   
        public static List<string> ReturnOnlyInvalidChars(this string @this, string allowedChars) => (
            from c in @this
            where !allowedChars.Contains(c.ToString())select c.ToString()).ToList();
        //https://stackoverflow.com/questions/4734116/find-and-extract-a-number-from-a-string
        public static string ReturnOnlyNumbers(this string @this) => new(@this.Where(char.IsDigit).ToArray());
        public static int? ReturnOnlyNumbersAsInt(this string @this)
        {
            int.TryParse(@this.ReturnOnlyNumbers(), out var result);
            return result;
        }
​
        public static string ReturnOnlyNonNumericCharacters(this string @this) => Regex.Replace(@this, @"[\d-]", string.Empty);
        /// <summary>
        /// https://stackoverflow.com/a/10042595/2752308
        /// </summary>
        /// <param name = "this"></param>
        /// <returns></returns>
        public static int[] ReturnOnlyNumbersToArray(this string @this) => Regex.Matches(@this, "(-?[0-9]+)").OfType<Match>().Select(m => int.Parse(m.Value)).ToArray();
        public static int GetSingleDigitAtPositionInFilteredStrOnlyNumbers(this string @this, int position1Based)
        {
            if (position1Based < 1 || position1Based > @this.Length - 1)
            {
                throw new ArgumentOutOfRangeException(nameof(position1Based), $"{nameof(position1Based)} cannot be outer of string limits");
            }
​
            return int.Parse(@this.ReturnOnlyNumbers()[position1Based - 1].ToString());
        }
​
        public static string FormatPhoneNumber(this long number, string mask) => number.ToString(mask);
        //https://pt.stackoverflow.com/questions/283609/formatar-uma-string-para-formato-de-telefone
        public static string FormatPhoneNumber(this string number)
        {
            var mask = number.ReturnOnlyNumbers().Length switch
            {
                15 => @"0 000 (00) 00000-0000",
                13 => @"+00 (00) 00000-0000",
                11 => @"(00) 00000-0000",
                10 => @"(00) 0000-0000",
                _ => throw new ArgumentOutOfRangeException(nameof(FormatPhoneNumber), "FormatPhoneNumber only accepts certain ranges of phone numbers"),
            };
            //var mask = string.Empty;
            //switch (number.ReturnOnlyNumbers().Length)
            //{
            //    case 15:
            //        mask = @"0 000 (00) 00000-0000";
            //        break;
            //    case 13:
            //        mask = @"+00 (00) 00000-0000";
            //        break;
            //    case 11:
            //        mask = @"(00) 00000-0000";
            //        break;
            //    case 10:
            //        mask = @"(00) 0000-0000";
            //        break;
            //    default:
            //        throw new ArgumentOutOfRangeException(nameof(FormatPhoneNumber), "FormatPhoneNumber only accepts certain ranges of phone numbers");        
            //}
            return long.Parse(number.ReturnOnlyNumbers()).FormatPhoneNumber(mask);
        }
​
        public static bool IsDate(this string @this, out DateTime date) => DateTime.TryParse(@this, out date);
        public static bool IsDate(this string @this) => DateTime.TryParse(@this, out var date);
        /// <summary>
        /// https://stackoverflow.com/questions/7461080/fastest-way-to-check-if-string-contains-only-digits-in-c-sharp
        /// TryParse won't work in some situations, like what happens if the string is a credit card number with 16 digits
        /// or if DateTime is in sortable format, like "20210620150000"
        /// </summary>
        /// <param name = "this"></param>
        /// <returns></returns>
        public static bool IsNumber(this string @this) => int.TryParse(@this, out var number);
        public static bool IsDigit(this string @this) => @this.All(c => c >= '0' && c <= '9');
        public static bool ContainsOnlyDigitsAndThisSubstring(this string @this, string substring)
        {
            var resultOk = @this.Contains(substring);
            if (!resultOk)
                return false;
            @this = @this.Replace(substring, string.Empty);
            return @this.IsDigit();
        }
​
        /// <summary>
        /// inHexadecimal = false : returns a decimal hash code
        /// </summary>
        /// <param name = "input"></param>
        /// <param name = "hashSize"></param>
        /// <param name = "inHexadecimal"></param>
        /// <returns></returns>
        public static string ReturnParentFolder(this string pathSource)
        {
            //https://stackoverflow.com/a/30902714/2752308
            return Path.GetFullPath(Path.Combine(pathSource, @"..\"));
        }
​
        /// <summary>
        /// Extension to use with Root path, adding distal path as argument
        /// </summary>
        /// <param name = "pathWithRoot"></param>
        /// <param name = "pathDistal"></param>
        /// <returns></returns>
        public static string CombinePaths(this string pathWithRoot, string pathDistal)
        {
            var networkFolder = !pathWithRoot.Contains(":");
            var pathOne = pathWithRoot.Split(@"\".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
            var pathTwo = pathDistal.Split(@"\".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
            var pathFinal = pathOne.Concat(pathTwo);
            var preFinalPath = Path.Combine(pathFinal.ToArray());
            if (networkFolder)
                return "\\\\" + preFinalPath;
            return preFinalPath.Contains(":\\") ? preFinalPath : preFinalPath.Replace(":", ":\\");
        }
    }
​
    // ###################            ##################################      StringTextExtensions      ##################################            ###################
    // ###################            ##################################      EasyOfficeFolderExtensions      ##################################            ###################
    public static class EasyOfficeFolderExtensions
    {
        public static string GetParentFolder(this string pathSource)
        {
            //https://stackoverflow.com/a/30902714/2752308
            return Path.GetFullPath(Path.Combine(pathSource, @"..\"));
        }
​
        /// <summary>
        /// Extension to use with Root path, adding distal path as argument
        /// </summary>
        /// <param name = "pathWithRoot"></param>
        /// <param name = "pathDistal"></param>
        /// <returns></returns>
        public static string CombinePaths(this string pathWithRoot, string pathDistal)
        {
            var networkFolder = !pathWithRoot.Contains(":");
            var pathOne = pathWithRoot.Split(@"\".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
            var pathTwo = pathDistal.Split(@"\".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
            var pathFinal = pathOne.Concat(pathTwo);
            var preFinalPath = Path.Combine(pathFinal.ToArray());
            if (networkFolder)
                return "\\\\" + preFinalPath;
            return preFinalPath.Contains(":\\") ? preFinalPath : preFinalPath.Replace(":", ":\\");
        }
    }
​
    // ###################            ##################################      EasyOfficeFolderExtensions      ##################################            ###################
    // ###################            ##################################      ObjectTextExtensions      ##################################            ###################
    public static class ObjectTextExtensions
    {
        public static T ObjToEnum<T>(this object o, int unknown = 0)
        {
            try
            {
                if (o != null)
                {
                    T enumVal = (T)Enum.Parse(typeof(T), o.ToString());
                    return enumVal;
                }
            }
            catch (Exception)
            {
                return (T)Enum.ToObject(typeof(T), unknown);
            }
​
            return (T)Enum.ToObject(typeof(T), unknown); //0 é o valor que estou dando para todos os enum Desconhecidos
        }
​
        //        public static T LookupItemExToEnum<T>(this object o, int unknown = 0)
        //        {
        //        }
        /// <summary>
        /// Returns true if Enum value exists
        /// </summary>
        /// <param name = "value"></param>
        /// <returns></returns>
        public static bool IsDefined(this System.Enum value)
        {
            return Enum.IsDefined(value.GetType(), value);
        }
​
        //       public static LookupItemEx EnumTo<TValue>(this TValue value) where TValue : System.Enum =>
        //            LookupItemEx.Create(value.EnumToInt(), value.ToString(), value.GetDescription());
        public static int EnumToInt<TValue>(this TValue value)
            where TValue : System.Enum => (int)(object)value;
        public static TValue IntToEnum<TValue>(this int value)
            where TValue : System.Enum => (TValue)(object)value;
        //=> (TValue)Convert.ChangeType(value, typeof(TValue));
        //(T)Convert.ChangeType(Email.FromString("m", WhichContactType.PERSONAL), typeof(T)), 
        public static T GetEnumValue<T>(this string value)
            where T : struct
        {
            Type t = typeof(T);
            if (!t.IsEnum)
                throw new Exception("T must be an enum");
            else
            {
                if (Enum.IsDefined(t, value))
                    return (T)Enum.Parse(t, value);
                else
                    return default(T);
            }
        }
​
        //https://stackoverflow.com/questions/483794/convert-enum-to-string/17034624#17034624
        public static T GetValueFromDescription<T>(this string description, bool throwException = true)
            where T : Enum
        {
            //https://stackoverflow.com/questions/4367723/get-enum-from-description-attribute
            foreach (var field in typeof(T).GetFields())
            {
                if (Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute))is DescriptionAttribute attribute)
                {
                    if (attribute.Description == description)
                        return (T)field.GetValue(null);
                }
                else
                {
                    if (field.Name == description)
                        return (T)field.GetValue(null);
                }
            }
​
            if (throwException)
            {
                throw new ArgumentException("Not found.", nameof(description));
            }
​
            return default(T);
        }
​
        public static string GetDescription(this Enum value)
        {
            //https://stackoverflow.com/questions/4367723/get-enum-from-description-attribute
            //https://stackoverflow.com/a/479417/2752308
            FieldInfo field = value.GetType().GetField(value.ToString());
            DescriptionAttribute attribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;
            return attribute == null ? value.ToString() : attribute.Description;
        }
​
        public static string GetDescription(this object e, Type enumType)
        {
            //var fields = Enum.GetValues(enumType).Cast<object>();
            //var fieldsName =
            //from o in fields
            //    where o.ToString() == e.ToString()
            //        select o.ToString();
            //var fieldValue = enumType.GetField(fieldsName.FirstOrDefault()).ToString();
            var fieldValue = enumType.GetField(Enum.GetValues(enumType).Cast<object>().Where(o => o.ToString() == e.ToString()).Select(o => o.ToString()).FirstOrDefault()).ToString();
            FieldInfo field = enumType.GetField(fieldValue.Contains(" ") ? fieldValue.Split().Last() : fieldValue);
            DescriptionAttribute attribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;
            return attribute == null ? e.ToString() : attribute.Description;
        }
​
        /// <summary>
        /// De um valor apenas, pega o Dictionary; meio estranho
        /// </summary>
        /// <typeparam name = "TValue"></typeparam>
        /// <param name = "value"></param>
        /// <returns></returns>
        public static Dictionary<int, TValue> EnumToDictionary<TValue>(this TValue value)
            where TValue : System.Enum
        {
            Type enumType = typeof(TValue);
            var allEnumValues = enumType.GetEnumValues().Cast<TValue>();
            var enumDL = new Dictionary<int, TValue>();
            foreach (TValue val in allEnumValues.ToList())
            {
                enumDL.Add(val.EnumToInt(), val);
            }
​
            return enumDL;
        }
​
        public static Dictionary<int, Enum> EnumToDictionaryNotGeneric(this Enum @enum)
        //where T : struct, Enum
        {
            Type enumType = @enum.GetType(); //typeof(@enum);
            var allEnumValues = Enum.GetValues(@enum.GetType()).Cast<Enum>();
            var enumDL = new Dictionary<int, Enum>();
            foreach (var val in allEnumValues.ToList())
            {
                enumDL.Add(val.EnumToInt(), val);
            }
​
            return enumDL;
        }
​
        /// <summary>
        /// Pega o Dictionary; a assinatura é muito estranha
        /// </summary>
        /// <typeparam name = "T"></typeparam>
        /// <returns></returns>
        public static Dictionary<int, T> EnumToDictionary<T>(this Type enumType)
            where T : Enum
        {
            //Type enumType = typeof(T);
            //var allEnumDescriptions = enumType.GetEnumNames();
            //non-generic equivalent:          ^^^^^^^^^^ Enum.GetValues<WhichGender>()
            var allEnumValues = enumType.GetEnumValues().Cast<T>();
            var converter = new EnumConverter(enumType);
            // Can't use generic type constraints on value types,
            // so have to do check like this
            //if (enumType.BaseType != typeof(Enum))
            //    throw new ArgumentException("T must be of type System.Enum");
            var enumDL = new Dictionary<int, T>();
            foreach (T val in allEnumValues.ToList())
            {
                enumDL.Add(val.EnumToInt(), val);
            }
​
            return enumDL;
        }
​
        //https://stackoverflow.com/a/972323/2752308
        public static IReadOnlyList<T> GetValues<T>()
        {
            return (T[])Enum.GetValues(typeof(T));
        }
    /// <summary>
    /// https://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum
    /// Only after 7.3
    /// see too: https://stackoverflow.com/questions/5005931/listing-values-within-enums-using-reflection-in-c-sharp
    /// Use this instead of EnumPatient.GetAllValues()
    /// </summary>
    /// <returns></returns>
     //        public static Dictionary<int, string> GetAllValuesByEnumType(this EnumPatient.Enums whichType)
    //        {
    //        }
    }
// ###################            ##################################      ObjectTextExtensions End     ##################################            ###################
}

View IL Code