using System;
using System.IO;
using System.Threading;

/*
 * Попов Виталий Леонидович
 * БПИ1910[1]
 * Вариант 0
 */

namespace KR
{
    class Program
    {
       //----------------------------------Требуемые методы по порядку.
        /// <summary>
        /// переменная, ответственная за рандом.
        /// </summary>
        static Random rnd = new Random();
        /// <summary>
        /// Создаёт строку случайных символов.
        /// </summary>
        /// <param name="N"></param>
        /// <returns></returns>
        static string MakeRndString(int N)
        {
            char[] str = new char[N];
            for (int i = 0; i < N; i++)
            {
                str[i] = (char)rnd.Next(97, 123);
            }
            Logging(string.Join("", str));
            return string.Join("", str);
        }
        /// <summary>
        /// Ищет самый частовстречающийся символ.
        /// </summary>
        /// <param name="arr"></param>
        /// <returns></returns>
        static char MostFrequentSearcher(char[] arr)
        {
            char[] buff = new char[arr.Length];
            Array.Copy(arr, 0, buff, 0, arr.Length);
            Array.Sort(buff);

            int max = 1, counter = 0;
            char count = buff[0], maxChar = buff[0];

            for (int i = 0; i < buff.Length; i++)
            {
                if (count == buff[i])
                {
                    counter++;
                    continue;
                }
                count = buff[i];
                if (max < counter)
                {
                    maxChar = buff[i - 1];
                    max = counter;
                }
            }
            return maxChar;
            //Альтернативное решение.
            //int[] amountLetters = CharCounter(arr);

            //int max = 0;
            //for (int i = 0; i < amountLetters.Length; i++)
            //{
            //    if (amountLetters[i] > max)
            //    {
            //        max = i;
            //    }
            //}

            //return (char)(97 + max);
        }
        /// <summary>
        /// Создаёт новую строку, которая состоит только из тех символов
        /// Которые кратны k
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="k"></param>
        /// <returns></returns>
        static char[] MakeNewArrByK(char[] arr, int k)
        {
            string buff = "";
            //Во имя избежания деления на 0.
            k = k == 0 ? 1 : k;

            for (int i = 0; i < arr.Length; i++)
            {

                if ((arr[i] - 97) % k == 0)
                {
                    buff += arr[i];
                }

            }
            return buff.ToCharArray();
        }
        /// <summary>
        /// Подсчитывает количество, попадающих в интервал.
        /// </summary>
        /// <param name="ch1"></param>
        /// <param name="ch2"></param>
        /// <param name="chArr"></param>
        /// <returns></returns>
        static int AmountCharsInInterval(char ch1, char ch2, char[] chArr)
        {
            int result = 0;
            for (int i = 0; i < chArr.Length; i++)
            {
                if (ch1 <= chArr[i] && chArr[i] <= ch2)
                {
                    result++;
                }
            }
            return result;
        }
        /// <summary>
        /// Подсчитывает количество каждого символа в массиве символов.
        /// </summary>
        /// <param name="arr"></param>
        /// <returns></returns>
        static int[] CharCounter(char[] arr)
        {
            int[] result = new int[26];

            foreach (var item in arr)
            {
                result[item - 97]++;
            }
            return result;
        }
       //----------------------------------Методы для базовой работоспособности программы.
        /// <summary>
        /// Для циклической работы программы.
        /// </summary>
        /// <param name="pass"></param>
        /// <param name="gool"></param>
        /// <returns></returns>
        static bool Continue(ConsoleKey pass, string gool)
        {
            StyleOUTAndLog($"\nЕсли Вы хотите продолжить {gool},\nнажмите: [ {pass.ToString()} ]\n");
            ConsoleKey buff = Console.ReadKey().Key;
            Logging(buff.ToString());
            return buff == pass;
        }
        /// <summary>
        /// Для чтения символа.
        /// </summary>
        /// <param name="min"></param>
        /// <param name="max"></param>
        /// <returns></returns>
        static char ReadChar(int min, int max)
        {
            string buff = Console.ReadLine();
            Logging(buff);

            while (buff.Length != 1 || buff[0] > 123 || buff[0] < 96)
            {
                StyleOUTAndLog("Это не буква алфавита.");
                buff = Console.ReadLine();
                Logging(buff);
            }
            return buff[0];
        }
        /// <summary>
        /// Для чтения целого числа в диапазоне.
        /// </summary>
        /// <param name="num"></param>
        /// <param name="min"></param>
        /// <param name="max"></param>
        static void ReadInt(out int num, int min, int max)
        {
            string buff = Console.ReadLine();
            Logging(buff);
            while (!int.TryParse(buff, out num)
                || num > max || num < min)
            {
                Logging(buff);
                if (num > max)
                {
                    StyleOUTAndLog("Слишком большое число. Давай заново");
                }
                else if (num < min)
                {
                    StyleOUTAndLog("Слишком маленькое число. Давай заново");
                }
                else
                {
                    StyleOUTAndLog("Это и близко не int. Давай заново");
                }
                buff = Console.ReadLine();
            }
        }
        /// <summary>
        /// Выводит массив символов.
        /// </summary>
        /// <param name="arr"></param>
        static void WriteChArr(char[] arr)
        {

            foreach (var item in arr)
            {
                Console.Write(item + " ");
            }
            Console.WriteLine();

            Logging(new string(arr));
        }
       //----------------------------------Логгирование.
        /// <summary>
        /// Путь до файла.
        /// </summary>
        static string FilePath = "../../log.txt";
        /// <summary>
        /// Выписывает любые действия в файл.
        /// </summary>
        /// <param name="message"></param>
        static void Logging(string message)
        {
            try
            {
                File.AppendAllText(FilePath, message + "\n");
            }
            catch (UnauthorizedAccessException)
            {
                Console.WriteLine("::ERROR::ERROR::ERROR::ERROR::");
                Console.WriteLine("Нет доступа для записи файлов.");
                Console.WriteLine("Укажите другой файл.");
                Console.WriteLine("Новый путь:");
                FilePath = Console.ReadLine();
                File.AppendAllText(FilePath, message);
            }
            catch (DirectoryNotFoundException)
            {
                Console.WriteLine("::ERROR::ERROR::ERROR::ERROR::");
                Console.WriteLine("Нет доступа для записи файлов.");
                Console.WriteLine("Укажите другой файл.");
                Console.WriteLine("Новый путь:");
                FilePath = Console.ReadLine();
                File.AppendAllText(FilePath, message);
            }
            catch (Exception e)
            {
                Console.WriteLine("::ERROR::ERROR::ERROR::ERROR::ERROR::");
                Console.WriteLine("Невозможно записать информацию в файл");
                Console.WriteLine($"Из-за того, что {e.Message}");
            }
        }
        /// <summary>
        /// Для красивого вывода.
        /// </summary>
        /// <param name="message"></param>
        static void StyleOUTAndLog(string message)
        {
            foreach (var item in message)
            {
                Console.Write(item);
                Thread.Sleep(15);
            }
            Console.Write("\n");
            Logging(message);
        }

       //----------------------------------Интерфейс и Main.
        /// <summary>
        /// Реализует диалог с пользователем.
        /// </summary>
        /// <param name="chArr"></param>
        static void Interface(char[] chArr)
        {
            do
            {
                Console.Write($"Полученный массив символов:\t");
                WriteChArr(chArr);

                StyleOUTAndLog("\nВыберете то, что вы хотите делать со строкой:\n" +
                                  "1] Показать самый частовстречающийся элемент.\n\n" +
                                  "2] Создания нового массива, содержащего символы,\n   коды которых кратны некоторому заданному числу k.\n" +
                                  "3] Нахождения в строке количества символов,\n   которые находятся в интервале (ch1, ch2)\n" +
                                  "4] Количество встречающихся символов.\n\n");
                int choice;
                Console.Write("Ваш выбор: ");
                ReadInt(out choice, 0, 4);
                switch (choice)
                {
                    case 1:
                        StyleOUTAndLog($"\nСамый частый элемент:\t{MostFrequentSearcher(chArr)}\n");
                        break;
                    case 2:
                        StyleOUTAndLog($"Введите число k в промежутке [0; 26)");
                        int buffer;
                        ReadInt(out buffer, 0, 26);

                        char[] newChArr = MakeNewArrByK(chArr, buffer);
                        if (newChArr.Length == 0)
                        {
                            StyleOUTAndLog("Нет таких элементов.");
                        }
                        else WriteChArr(newChArr);
                        break;
                    case 3:
                        StyleOUTAndLog("Введите букву для интервала [Минимум]");
                        char ch1 = ReadChar(97, 123);
                        StyleOUTAndLog("Введите букву для интервала [Максимум]");
                        char ch2 = ReadChar(97, 123);

                        StyleOUTAndLog($"Количество символов в интервале: {AmountCharsInInterval(ch1, ch2, chArr)}");
                        break;
                    case 4:
                        StyleOUTAndLog("Вывод количеств символов.");
                        int[] amountLetters = CharCounter(chArr);
                        for (int i = 97; i < 123; i++)
                        {
                            if (amountLetters[i - 97] != 0)
                            {
                                StyleOUTAndLog($"{(char)i} {amountLetters[i - 97]}");
                            }
                        }
                        break;
                }
            } while (Continue(ConsoleKey.Enter, "работать с этой строкой"));
        }
        static void Main(string[] args)
        {
            do
            {
                Console.Clear();
                //Создание массива символов.
                int buffer;
                StyleOUTAndLog($"Введите размер строки (0; +бесконечность)");
                Console.Write("Размер строки: ");
                Logging("Размер строки: ");
                ReadInt(out buffer, 1, int.MaxValue);
                string str = MakeRndString(buffer);

                //Выводим интерфейс.
                Interface(str.ToCharArray());
                StyleOUTAndLog("\nВы больше не работаете с этой строкой.\n");
            } while (Continue(ConsoleKey.Enter, "вводить строки"));
        }
    }
}