using System;

using System.Collections.Generic;

using System.ComponentModel.DataAnnotations;

using System.Linq;

using static System.Console;

public class Program

{

        private const string InputParameter = "--input";

        private const string PatternLengthParameter = "--patternLength";

        private static readonly string ExpectedUsage = $"Expected usage: {InputParameter} <string> {PatternLengthParameter} <integer>";

​

        static void Main(string[] args)

        {

            args = "--input zf3kabxcde224lkzf3mabxc51+crsdtzf3nab= --patternLength 3".Split(' ');

            WriteLine("----------------------------------------");

            WriteLine("Hello! Welcome to the pattern matcher!");

            WriteLine("----------------------------------------");

            WriteLine();

            WriteLine(ExpectedUsage);

            WriteLine();

            WriteLine("Validating input . . .");

            WriteLine();

            ValidateInput(args);

            WriteLine("Getting input . . .");

            WriteLine();

​

            var input = args.SkipWhile(p => !p.Equals(InputParameter, StringComparison.CurrentCultureIgnoreCase)).Skip(1).FirstOrDefault();

            var patternLength = Convert.ToInt32(args.SkipWhile(p => !p.Equals(PatternLengthParameter, StringComparison.CurrentCultureIgnoreCase)).Skip(1).FirstOrDefault());

​

            WriteLine(InputParameter + " " + input);

            WriteLine(PatternLengthParameter + " " + patternLength);

            WriteLine();

​

            WriteLine("Results:");

            WriteLine();

​

            var patterns = GetPatternMatches(input, patternLength);

            PrintSolution(patterns);

​

            WriteLine("");

            WriteLine("End of Results");

            //WriteLine("Press enter to exit the program . . .");

            //ReadLine();

        }

​

        #region solution Method

        private static List<PatternMatch> GetPatternMatches(string input, int patternLength)

        {

            var patterns = new List<PatternMatch>();

​

            for (var i = 0; i < input?.Length; i++)

            {

                if (input.Length - i < patternLength) break;

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

                var existingMatchingPattern = patterns.FirstOrDefault(p => p.Pattern.Equals(pattern, StringComparison.CurrentCultureIgnoreCase));

                if (existingMatchingPattern != null) existingMatchingPattern.MatchCount++;

                patterns.Add(new PatternMatch()

                {

                    Pattern = input.Substring(i, patternLength),

                    MatchCount = 1

                });

            }

            return patterns.Where(p => p.MatchCount > 1).ToList();

        }

        #endregion solution Method

​

        #region Helper Method

        private static void PrintSolution(List<PatternMatch> patterns)

        {

            foreach (var patternMatch in patterns)

            {

                WriteLine($"pattern {patternMatch.Pattern} occurs {patternMatch.MatchCount} times");

            }

        }

        #endregion Helper Method

​

        #region Validation Methods

        private static void ValidateInput(string[] args)

        {

            if (args == null || !args.Any()) throw new ValidationException("No parameters found! " + ExpectedUsage);

​

            var errorMessages = new List<string>();

            errorMessages.AddRange(GetParameterNameErrors(args));

            if (errorMessages.Any()) throw new ValidationException(string.Join('\n', errorMessages));

​

            errorMessages.AddRange(GetParameterValueErrors(args));

            if (errorMessages.Any()) throw new ValidationException(string.Join('\n', errorMessages));

        }

​

        private static IEnumerable<string> GetParameterNameErrors(string[] args)

        {

            var errorMessages = new List<string>();

            if (!args.Any(p => p.Equals(InputParameter, StringComparison.CurrentCultureIgnoreCase))) errorMessages.Add($"Missing {InputParameter} parameter!");

            if (!args.Any(p => p.Equals(PatternLengthParameter, StringComparison.CurrentCultureIgnoreCase))) errorMessages.Add($"Missing {PatternLengthParameter} parameter!");

            return errorMessages;

        }

​

        private static IEnumerable<string> GetParameterValueErrors(string[] args)

        {

            var errorMessages = new List<string>();

            var input = args.SkipWhile(p => !p.Equals(InputParameter, StringComparison.CurrentCultureIgnoreCase)).Skip(1).FirstOrDefault();

            var patternLength = args.SkipWhile(p => !p.Equals(PatternLengthParameter, StringComparison.CurrentCultureIgnoreCase)).Skip(1).FirstOrDefault();

            if (input == null || input.Equals(PatternLengthParameter, StringComparison.CurrentCultureIgnoreCase)) errorMessages.Add($"Please enter a valid string for {InputParameter}");

            if (patternLength == null || !patternLength.All(char.IsDigit)) errorMessages.Add($"Please enter a valid integer for {PatternLengthParameter}");

            return errorMessages;

        }

        #endregion Validation Methods

​

​

        private class PatternMatch

        {

            public string Pattern { get; set; }

            public int MatchCount { get; set; }

        }

}