#nullable enable

​

using System;

using System.Text;

using Humanizer;

​

public class Program

{

    /// <summary>

    /// Unit Test Tag!

    ///

    /// Output a currency amount in english words.

    /// 

    /// Press "Run" above, then check the output in the pane below to see if all the tests pass and

    /// the program is correct. 

    /// </summary>

    public static void Main()

    {

        // Unit tests. Add new tests to this list to check for new cases not covered by existing code.

        Test(2, Currency.NZD, "Two dollars.");

        Test(5, Currency.NZD, "Five dollars.");

        Test(5.20m, Currency.NZD, "Five dollars and twenty cents.");

        Test(10.01m, Currency.NZD, "Ten dollars and one cent.");

        Test(8m, Currency.GBP, "Eight pounds.");

        Test(100, Currency.NZD, "One hundred dollars.");

        Test(10.5m, Currency.GBP, "Ten pounds and fifty pence.");       

        Test(1, Currency.NZD, "One dollar.");

        Test(57m, Currency.JPY, "Fifty-seven yen.");

        Test(57.6m, Currency.JPY, "Fifty-seven yen.");

        Test(0.10m, Currency.NZD, "Zero dollars and ten cents.");

        Test(0, Currency.NZD, "Zero dollars.");

        Test(0.9999999999m, Currency.NZD, "One dollar.");

        Results();

    }

​

    /// <summary>

    /// Implementation. Make code changes here to make the tests pass.

    /// </summary>

    static string CurrencyInWords(decimal amount, Currency currency)

    {

        var builder = new StringBuilder();

        MaybeAddWholeAmountWords(builder, amount, currency);

        MaybeAddFactionalAmountWords(builder, amount, currency);

        builder.Append(".");

        return builder.ToString();

    }

    private static void  MaybeAddWholeAmountWords(StringBuilder builder, decimal amount, Currency currency) {

        var wholeAmount = (int)amount;

        builder.Append(wholeAmount.ToWords().Transform(To.SentenceCase));

        builder.Append(" ");

        if(wholeAmount > 1 || wholeAmount < 1) 

            builder.Append(currency.PluralisedWord());

        else

            builder.Append(currency.Word);

    } 

    private static void MaybeAddFactionalAmountWords(StringBuilder builder, decimal amount, Currency currency) {

        if(!currency.SupportsFractionalAmounts())

           return;

        var fractionAmount = (int)((amount - (int)amount) * 100m);

        if(fractionAmount == 0)

            return;

        builder.Append(" and ");

        builder.Append(fractionAmount.ToWords());

        if(fractionAmount > 1 && currency != Currency.GBP)

            builder.AppendFormat(" {0}", currency.SmallerWord.ToString().Pluralize());

        else 

            builder.AppendFormat(" {0}", currency.SmallerWord.ToString());

    }

​

    class Currency

    {

        public static readonly Currency NZD = new Currency("NZD", "dollar", "cent");

        public static readonly Currency GBP = new Currency("GBP", "pound", "pence");

        public static readonly Currency JPY = new Currency("JPY", "yen", "");

        public string Symbol { get; }

        public string Word { get; }     

        public string SmallerWord { get; }

        public bool SupportsFractionalAmounts() {

            return SmallerWord != "";

        }

        public string PluralisedWord() {

            return Symbol == "JPY" ? Word : Word.Pluralize();

        }

        Currency(string symbol, string word, string smallerWord)

        {

            Symbol = symbol;

            Word = word;

            SmallerWord = smallerWord;

        }

    }

    /*

     * What follows is a very short testing framework. You can ignore everything below here

     * if you want to, or add to it if you want better output from the tests above.

     */

    static int pass, fail;

​

    static void Test(decimal amount, Currency currency, string expected)

    {

        Console.WriteLine($"Test: {amount}, {currency.Symbol}, {expected}");

        string actual;

        try {

            actual = CurrencyInWords(amount, currency);

            if (actual == expected)

            {

                pass++;

                Console.WriteLine("PASS.\n");

                return;

            }

        } catch(Exception e) {

            actual = "Exception: " + e.Message;

        }

        fail++;

        Console.WriteLine("FAIL:");

        Console.WriteLine("    Expected: " + expected);

        Console.WriteLine("    Actual  : " + actual);

        Console.WriteLine();

    }

    static void Results()

    {

        Console.WriteLine($"{pass} / {pass + fail} tests passed.\n");

        Console.WriteLine(fail == 0 ? "SUCCESS!" : "FAILURE!");

    }

}

​