using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace EPS.Common
{
	/// <summary>
	/// Helper class for manipulating strings.
	/// </summary>
	public static class Inflector
	{
		#region CC: I added some custom code to Inflector
		/// <summary>
		/// Splits the pascal to words.
		/// </summary>
		/// <param name="pascalCasedWord">The pascal cased word.</param>
		/// <returns></returns>
		public static string SplitPascalToWords(string pascalCasedWord)
		{
			return String.Join(" ", new List<string>(SplitPascal(pascalCasedWord)).ToArray());
		}

		/// <summary>
		/// Helper method used for splitting words like AgencySystemComponent into three 
		/// separate words: Agency, System, Component.  Note that
		/// any two sequential capital letters are considered a single word, so TaxID would be
		/// split into Tax and ID.
		/// </summary>
		/// <param name="pascalCasedWord">The pascal cased word to split.</param>
		/// <returns></returns>
		public static IEnumerable<string> SplitPascal(string pascalCasedWord)
		{
			if (String.IsNullOrEmpty(pascalCasedWord))
				yield return null;

			List<char> buffer = new List<char>();
			for (int i = 0; i < pascalCasedWord.Length; i++)
			{
				char c = pascalCasedWord[i];
				if (Char.IsUpper(c))
				{
					//this code checks the previous character to see if the previous 
					//character was uppercase. If it was not, that indicates that a new 
					//word is starting so return what's in the buffer, clear it and start
					//the new word.
					if (buffer.Count > 0 && i > 0 && !Char.IsUpper(buffer[buffer.Count - 1]))
					{
						yield return new String(buffer.ToArray());
						buffer.Clear();
					}
				}
				buffer.Add(c);
			}
			if (buffer.Count > 0)
				yield return new String(buffer.ToArray());
		}
		#endregion


		#region Default Rules

		static Inflector()
		{
			AddPlural("$", "s");
			AddPlural("s$", "s");
			AddPlural("(ax|test)is$", "$1es");
			AddPlural("(octop|vir)us$", "$1i");
			AddPlural("(alias|status)$", "$1es");
			AddPlural("(bu)s$", "$1ses");
			AddPlural("(buffal|tomat)o$", "$1oes");
			AddPlural("([ti])um$", "$1a");
			AddPlural("sis$", "ses");
			AddPlural("(?:([^f])fe|([lr])f)$", "$1$2ves");
			AddPlural("(hive)$", "$1s");
			AddPlural("([^aeiouy]|qu)y$", "$1ies");
			AddPlural("(x|ch|ss|sh)$", "$1es");
			AddPlural("(matr|vert|ind)ix|ex$", "$1ices");
			AddPlural("([m|l])ouse$", "$1ice");
			AddPlural("^(ox)$", "$1en");
			AddPlural("(quiz)$", "$1zes");

			AddSingular("s$", "");
			AddSingular("(n)ews$", "$1ews");
			AddSingular("([ti])a$", "$1um");
			AddSingular("((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$", "$1$2sis");
			AddSingular("(^analy)ses$", "$1sis");
			AddSingular("([^f])ves$", "$1fe");
			AddSingular("(hive)s$", "$1");
			AddSingular("(tive)s$", "$1");
			AddSingular("([lr])ves$", "$1f");
			AddSingular("([^aeiouy]|qu)ies$", "$1y");
			AddSingular("(s)eries$", "$1eries");
			AddSingular("(m)ovies$", "$1ovie");
			AddSingular("(x|ch|ss|sh)es$", "$1");
			AddSingular("([m|l])ice$", "$1ouse");
			AddSingular("(bus)es$", "$1");
			AddSingular("(o)es$", "$1");
			AddSingular("(shoe)s$", "$1");
			AddSingular("(cris|ax|test)es$", "$1is");
			AddSingular("(octop|vir)i$", "$1us");
			AddSingular("(alias|status)es$", "$1");
			AddSingular("^(ox)en", "$1");
			AddSingular("(vert|ind)ices$", "$1ex");
			AddSingular("(matr)ices$", "$1ix");
			AddSingular("(quiz)zes$", "$1");

			AddIrregular("person", "people");
			AddIrregular("man", "men");
			AddIrregular("child", "children");
			AddIrregular("sex", "sexes");
			AddIrregular("move", "moves");

			AddUncountable("equipment");
			AddUncountable("information");
			AddUncountable("rice");
			AddUncountable("money");
			AddUncountable("species");
			AddUncountable("series");
			AddUncountable("fish");
			AddUncountable("sheep");
		}

		#endregion

		private class Rule
		{
			private readonly Regex _regex;
			private readonly string _replacement;

			public Rule(string pattern, string replacement)
			{
				_regex = new Regex(pattern, RegexOptions.IgnoreCase);
				_replacement = replacement;
			}

			public string Apply(string word)
			{
				if (!_regex.IsMatch(word))
				{
					return null;
				}

				return _regex.Replace(word, _replacement);
			}
		}

		private static void AddIrregular(string singular, string plural)
		{
			AddPlural("(" + singular[0] + ")" + singular.Substring(1) + "$", "$1" + plural.Substring(1));
			AddSingular("(" + plural[0] + ")" + plural.Substring(1) + "$", "$1" + singular.Substring(1));
		}

		private static void AddUncountable(string word)
		{
			_uncountables.Add(word.ToLower());
		}

		private static void AddPlural(string rule, string replacement)
		{
			_plurals.Add(new Rule(rule, replacement));
		}

		private static void AddSingular(string rule, string replacement)
		{
			_singulars.Add(new Rule(rule, replacement));
		}

		private static readonly List<Rule> _plurals = new List<Rule>();
		private static readonly List<Rule> _singulars = new List<Rule>();
		private static readonly List<string> _uncountables = new List<string>();

		/// <summary>
		/// Pluralizes the specified word.
		/// </summary>
		/// <param name="word">The word.</param>
		/// <returns></returns>
		public static string Pluralize(string word)
		{
			return ApplyRules(_plurals, word);
		}

		/// <summary>
		/// Singularizes the specified word.
		/// </summary>
		/// <param name="word">The word.</param>
		/// <returns></returns>
		public static string Singularize(string word)
		{
			return ApplyRules(_singulars, word);
		}

		private static string ApplyRules(List<Rule> rules, string word)
		{
			string result = word;

			if (!_uncountables.Contains(word.ToLower()))
			{
				for (int i = rules.Count - 1; i >= 0; i--)
				{
					if ((result = rules[i].Apply(word)) != null)
					{
						break;
					}
				}
			}

			return result;
		}

		/// <summary>
		/// Titleizes the specified word.
		/// </summary>
		/// <param name="word">The word.</param>
		/// <returns></returns>
		public static string Titleize(string word)
		{
			return Regex.Replace(Humanize(Underscore(word)), @"\b([a-z])",
								 delegate(Match match)
								 {
									 return match.Captures[0].Value.ToUpper();
								 });
		}

		/// <summary>
		/// Humanizes the specified lowercase and underscored word.
		/// </summary>
		/// <param name="lowercaseAndUnderscoredWord">The lowercase and underscored word.</param>
		/// <returns></returns>
		public static string Humanize(string lowercaseAndUnderscoredWord)
		{
			return Capitalize(Regex.Replace(lowercaseAndUnderscoredWord, @"_", " "));
		}

		/// <summary>
		/// Pascalizes the specified lowercase and underscored word.
		/// </summary>
		/// <param name="lowercaseAndUnderscoredWord">The lowercase and underscored word.</param>
		/// <returns></returns>
		public static string Pascalize(string lowercaseAndUnderscoredWord)
		{
			return Regex.Replace(lowercaseAndUnderscoredWord, "(?:^|_)(.)",
								 delegate(Match match)
								 {
									 return match.Groups[1].Value.ToUpper();
								 });
		}

		/// <summary>
		/// Camelizes the specified lowercase and underscored word.
		/// </summary>
		/// <param name="lowercaseAndUnderscoredWord">The lowercase and underscored word.</param>
		/// <returns></returns>
		public static string Camelize(string lowercaseAndUnderscoredWord)
		{
			return Uncapitalize(Pascalize(lowercaseAndUnderscoredWord));
		}

		/// <summary>
		/// Underscores the specified pascal cased word.
		/// </summary>
		/// <param name="pascalCasedWord">The pascal cased word.</param>
		/// <returns></returns>
		public static string Underscore(string pascalCasedWord)
		{
			return Regex.Replace(
			  Regex.Replace(
				Regex.Replace(pascalCasedWord, @"([A-Z]+)([A-Z][a-z])", "$1_$2"), @"([a-z\d])([A-Z])",
				"$1_$2"), @"[-\s]", "_").ToLower();
		}

		/// <summary>
		/// Capitalizes the specified word.
		/// </summary>
		/// <param name="word">The word.</param>
		/// <returns></returns>
		public static string Capitalize(string word)
		{
			return word.Substring(0, 1).ToUpper() + word.Substring(1).ToLower();
		}

		/// <summary>
		/// Uncapitalizes the specified word.
		/// </summary>
		/// <param name="word">The word.</param>
		/// <returns></returns>
		public static string Uncapitalize(string word)
		{
			return word.Substring(0, 1).ToLower() + word.Substring(1);
		}

		/// <summary>
		/// Ordinalizes the specified number.
		/// </summary>
		/// <param name="number">The number.</param>
		/// <returns></returns>
		public static string Ordinalize(string number)
		{
			int n = int.Parse(number);
			int nMod100 = n % 100;

			if (nMod100 >= 11 && nMod100 <= 13)
			{
				return number + "th";
			}

			switch (n % 10)
			{
				case 1:
					return number + "st";
				case 2:
					return number + "nd";
				case 3:
					return number + "rd";
				default:
					return number + "th";
			}
		}

		/// <summary>
		/// Dasherizes the specified underscored word.
		/// </summary>
		/// <param name="underscoredWord">The underscored word.</param>
		/// <returns></returns>
		public static string Dasherize(string underscoredWord)
		{
			return underscoredWord.Replace('_', '-');
		}
	}
}