using System;

using System.Collections.Generic;

using System.Linq;

​

namespace FrozenMountainTest

{

    class Program

    {

        private static PatternAnalyzer _patternAnalyzer;

​

        static void Main(string[] args)

        {

            _patternAnalyzer = new PatternAnalyzer();

            TestCasePatternLengthThree();

            TestCase_CaseInsensitive();

            TestCase_CaseSensitive();

        }

        private static void TestCasePatternLengthThree()

        {

            // setup

            const int patternLength = 3;

            const string testPattern = "zf3kabxcde224lkzf3mabxc51+crsdtzf3nab=";

            const int abxExpectedCount = 2;

            const int zf3ExpectedCount = 3;

​

            // execute

            var result = _patternAnalyzer.Analyze(testPattern, patternLength);

​

            var abxActualCount = result.First(x => x.Pattern == "abx").Occurrences;

            var xf3ActualCount = result.First(x => x.Pattern == "zf3").Occurrences;

​

            // assert

            Assert(abxActualCount, abxExpectedCount, "abx pattern");

            Assert(xf3ActualCount, zf3ExpectedCount, "zf3 pattern");

        }

​

        private static void TestCase_CaseInsensitive()

        {

            // setup

            const string key = "mary";

            var patternLength = key.Length;

            const string testPattern = "Mary had a little lamb, little lamb, little lamb, Mary had a little lamb, its fleece was white as snow.";

            const int maryExpectedCount = 2;

            // execute

            var result = _patternAnalyzer.Analyze(testPattern, patternLength, StringComparison.OrdinalIgnoreCase);

            var maryActualCount = result.FirstOrDefault(x => x.Pattern.Equals(key, x.Comparison))?.Occurrences ?? 0; 

​

            // assert

            Assert(maryActualCount, maryExpectedCount, "marry pattern ignore case");

        }

​

        private static void TestCase_CaseSensitive()

        {

            // setup

            const string key = "mary";

            const int maryExpectedCount = 0;

            var patternLength = key.Length;

            const string testPattern = "Mary had a little lamb, little lamb, little lamb, Mary had a little lamb, its fleece was white as snow.";

            // execute

            var result = _patternAnalyzer.Analyze(testPattern, patternLength, StringComparison.CurrentCulture);

            var maryActualCount = result.FirstOrDefault(x => x.Pattern.Equals(key, x.Comparison))?.Occurrences ?? 0; 

​

            // assert

            Assert(maryActualCount, maryExpectedCount, "marry pattern case sensitive");

        }

​

        private static void Assert(in int actual, in int expected, string pattern)

        {

            if (actual != expected)

                throw new AssertionFailedException($"{pattern}: input value '{actual}' does not match expected value '{expected}'.");

​

            Console.WriteLine($"{pattern} assertion passed, both actual and expected values are {expected}");

        }

    }

​

    public class PatternAnalyzer

    {

        private static readonly Dictionary<StringComparison, StringComparer> _map = new Dictionary<StringComparison, StringComparer>

        {

            { StringComparison.Ordinal, StringComparer.Ordinal },

            { StringComparison.CurrentCulture, StringComparer.CurrentCulture },

            { StringComparison.InvariantCulture, StringComparer.InvariantCulture },

            { StringComparison.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase },

            { StringComparison.CurrentCultureIgnoreCase, StringComparer.CurrentCultureIgnoreCase },

            { StringComparison.InvariantCultureIgnoreCase, StringComparer.InvariantCultureIgnoreCase }

        };

        public IList<PatternResult> Analyze(string input, int patternLength) 

            => Analyze(input, patternLength, StringComparison.InvariantCultureIgnoreCase);

​

        public IList<PatternResult> Analyze(string input, int patternLength, StringComparison comparison)

        {

            _map.TryGetValue(comparison, out var comparer);

            var patterns = new List<string>();

            for (var index = 0; index < input.Length - patternLength; index++)

            {

                var pattern = input.Substring(index, patternLength);

                patterns.Add(pattern);

            }

​

            var patternResults = patterns

                .GroupBy(x => x, comparer)

                .Select(x => new PatternResult(x.Key, x.Count(), comparison))

                .ToList(); // since this will be inspected more than once, a list will prevent multiple enumeration warnings.

​

            return patternResults;

        }

    }

​

    public class PatternResult

    {

        public PatternResult(string pattern, int occurrences, StringComparison comparison)

        {

            Pattern = pattern;

            Occurrences = occurrences;

            Comparison = comparison;

        }

​

        public string Pattern { get; }

        public int Occurrences { get; }

        public StringComparison Comparison { get; }

    }

​

    public class AssertionFailedException : Exception

    {

        public AssertionFailedException(string message) : base(message)

        {

        }

    }

}