Markov 2.4

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Markov2
{
    class Program
    {
        static string s; // тут хранится строка глобально
        static string a; // здесь алфавит
        static string[] left = new string[100]; // массив левых частей введенных правил
        static string[] right = new string[100]; // массив правых частей
        static bool[] end = new bool[100]; // массив тру-фолс в зависимости от конечности или не конечности мета-символа в правиле соотв.
        static bool rulin;
        static bool strin;
        static int q = 0;

        static string Algoritm(string s, string[] left, string[] right, bool[] end, int numberofrules)
        {
            int i = 0;
            do
            {
                string newstringleft = null;
                string newstringright = null;
                q++;
                int j = -1;
                if (s.Contains(left[i]) == true)
                {
                    j = s.IndexOf(left[i]);
                }
                if ((j != -1) && (q <= 10000))
                {
                    if (j != 0)
                    {
                        newstringleft = s.Substring(0, j);
                    }
                    if (j != (s.Length - 1))
                    {
                        newstringright = s.Substring(j + left[i].Length, s.Length - left[i].Length - j);
                    }
                    s = newstringleft + right[i] + newstringright;
                    if (end[i] == true)
                    {
                        break;
                        i = numberofrules;
                        break;
                    }
                    else
                    {
                        i = 0;
                        j = -1;
                    }
                }
                else
                {
                    i++;
                }
            } while (i < numberofrules);
            return s;
        }
        static void RedLn(string str) // Console.WriteLine красного цвета
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(str);
            Console.ResetColor();
        }
        static void WhiteLn(string str) // Console.WriteLine белого цвета
        {
            Console.ForegroundColor = ConsoleColor.White;
            Console.WriteLine(str);
            Console.ResetColor();
        }

        static int AskForAction(int qtyOfActions) // запрос команды меню и проверка вводимых значений
        {
            int act;
            bool ok;
            do
            {
                Console.Write("Команда: ");
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out act) && act > 0 && act <= qtyOfActions;
                if (!ok)
                    RedLn("Доступны команды 1 - " + qtyOfActions + ".");
            } while (!ok);
            return act;
        }
        static string RemoveSpaces(string s)
        {
            s = s.Replace(" ", string.Empty);
            s = s.Trim().Replace(" ", string.Empty);
            return s;
        }
        static bool FindEquals(string sString)
        {
            bool ok = false;
            char[] sChar = new char[sString.Length];
            sChar = sString.ToCharArray();
            for (int i = 0; i < sChar.Length; i++)
            {
                if (i != 0)
                {
                    for (int j = 0; j < i; j++)
                    {
                        if (sChar[j] == sChar[i])
                        {
                            ok = true;
                            break;
                        }
                    }
                }
                if ((i != sChar.Length) && (ok != true))
                {
                    for (int j = i + 1; j < sChar.Length; j++)
                    {
                        if (sChar[j] == sChar[i])
                        {
                            ok = true;
                            break;
                        }
                    }
                }
                if (ok == true)
                {
                    break;
                }
            }
            return ok;
        }
        static bool Alf(string s) // проверка на соответствие алфавиту
        {
            bool ok = true;
            for (int i = 0; i < s.Length; i++)
            {
                if (!a.Contains(s[i]))
                {
                    ok = false;
                    break;
                }
            }
            return ok;
        }

        static int Check(string rule) // проверка на наличие в строке мета-символа и на его положение, возврат кода ошибки
        {
            int code = 0;
            if (rule.Contains("->"))
            {
                if (rule.IndexOf("->") == 0)
                {
                    code = 2;
                }
            }
            else
            {
                code = 1;
            }
            return code;
        }
        static int Split(string rule, int i) // проверяем левую-правую части переданной строки правила с переданным номером
        {                               // и записываем куски правила в соотв. массивы под соотв. номерами
            int index = -1;
            index = rule.IndexOf("->.");
            if (index == -1)
            {
                index = rule.IndexOf("->");
            }
            if (!Alf(rule.Substring(0, index)))
            {
                return 1;  // левая часть правила не соотв. алф.
            }

            left[i] = rule.Substring(0, index);

            if ((index + 2) == rule.Length)
            {
                end[i] = false;
                right[i] = null;
                return 0;
            }
            else
            {
                if (((index + 3) == rule.Length) && (rule[index + 2] == '.'))
                {
                    end[i] = true;
                    right[i] = null;
                    return 0;
                }
                else
                {
                    if (rule[index + 2] == '.')
                    {
                        if (!Alf(rule.Substring(index + 3, rule.Length - index - 3))) // правая часть правила с "->." не соотв. алф.
                        {
                            left[i] = null;
                            end[i] = false;
                            return 2;
                        }
                        else
                        {
                            end[i] = true;
                            right[i] = rule.Substring(index + 3, rule.Length - index - 3);
                            return 0;
                        }
                    }
                    else
                    {
                        if (!Alf(rule.Substring(index + 3, rule.Length - index - 3))) // правая часть правила c "->" не соотв. алф.
                        {
                            left[i] = "";
                            end[i] = false;
                            return 2;
                        }
                        else
                        {
                            end[i] = false;
                            right[i] = rule.Substring(index + 2, rule.Length - index - 2);
                            return 0;
                        }
                    }
                }
            }
        }

        static void WorkAlphabet(ref bool alfin)
        {
            string a1 = "";
            int act;
            Console.Clear();
            if (alfin) // если алфавит уже введен
            {
                Console.Write("Aлфавит: ");
                WhiteLn(a);
                Console.WriteLine();
                Console.WriteLine("1. Ввести новый алфавит\n2. Добавить символы в имеющийся\n");
                act = AskForAction(2);
                Console.Clear();
                if (act == 1)
                {
                    do
                    {
                        do
                        {
                            Console.Write("Введите алфавит в одну строку: ");
                            a1 = Console.ReadLine();
                            if (a1 == "")
                            {
                                RedLn("Ошибка. Алфавит не может быть пустым.\n");
                            }
                        } while (a1 == "");
                        a1 = RemoveSpaces(a1);
                        if (FindEquals(a1) == true)
                        {
                            RedLn("Ошибка. В вашем алфавите найдены повторяющиеся элементы. Повторите ввод.\n");
                        }
                    }
                    while (FindEquals(a1) == true);
                    a = a1 + " ";
                    if (strin && !Alf(s))
                    {
                        s = "";
                        left = new string[100];
                        right = new string[100];
                        end = new bool[100];
                        rulin = false;
                        strin = false;
                    }
                }
                else
                {
                    Console.Write("Aлфавит: ");
                    WhiteLn(a);
                    Console.WriteLine();
                    do
                    {
                        Console.Write("Введите символы для добавления к алфавиту: ");
                        a1 = Console.ReadLine();
                        a1 = RemoveSpaces(a1);
                        if (FindEquals(a1) == true)
                        {
                            RedLn("Ошибка. В введенной строке найдены повторяющиеся элементы. Повторите ввод.\n");
                        }
                        if (FindEquals(a + a1) == true)
                        {
                            RedLn("Ошибка. В введенной строке найдены элементы, которые уже есть в алфавите. Повторите ввод.\n");
                        }
                    }
                    while (FindEquals(a + a1) == true);
                    a = RemoveSpaces(a) + a1 + " ";
                }
            }
            else // если алфавита не было
            {
                do
                {
                    do
                    {
                        Console.Write("Введите алфавит в одну строку: ");
                        a1 = Console.ReadLine();
                        if (a1 == "")
                        {
                            RedLn("Ошибка. Алфавит не может быть пустым.\n");
                        }
                    } while (a1 == "");
                    a1 = RemoveSpaces(a1);
                    if (FindEquals(a1) == true)
                    {
                        RedLn("Ошибка. В вашем алфавите найдены повторяющиеся элементы. Повторите ввод.\n");
                    }
                }
                while (FindEquals(a1) == true);
                a = a1 + " ";
                alfin = true;
            }
        } // работа с алфавитом
        static void addRule(int ruleNumber)
        {
            int code = 0;
            do
            {
                Console.Write("Правило №" + (ruleNumber + 1) + ": ");
                string rule = Console.ReadLine();
                code = Check(rule);

                switch (code)
                {
                    case 1:
                        RedLn("Ошибка. В правиле отсутствует мета-символ.");
                        break;
                    case 2:
                        RedLn("Ошибка. Левая часть правила не может быть пустой.");
                        break;
                }
                if (code == 0)
                {
                    code = Split(rule, ruleNumber);
                    switch (code)
                    {
                        case 1: RedLn("Ошибка. Левая часть правила не соответствует алфавиту.");
                            break;
                        case 2: RedLn("Ошибка. Правая часть правила не соответствует алфавиту.");
                            break;
                    }
                }
                if (code != 0)
                {
                    Console.WriteLine("Повторите ввод.\n");
                }
            } while (code != 0);

        }
        static void WorkRules(ref int ruleNumber) // работа с правилами
        {
            Console.Clear();
            int act;
            if (left[0] == null)
            {
                right = new string[100];
                end = new bool[100];
                rulin = false;
                act = 1;
                ruleNumber = 0;

                Console.Write("Алфавит: ");
                WhiteLn(a);
                Console.Write("Строка: ");
                WhiteLn(s);
                Console.WriteLine();
                Console.WriteLine("Введите новые правила в формате ?*->* или ?*->.*");
                Console.WriteLine("Обратите внимание на принадлежность вводимых символов алфавиту.\n");
                do
                {
                    addRule(ruleNumber++);
                    rulin = true;
                    Console.WriteLine();
                    Console.WriteLine("1. Ввести еще одно правило\n2. Закончить ввод правил");
                    act = AskForAction(2);
                    Console.WriteLine();
                } while (act != 2);
            }
            else
            {
                do
                {
                    Console.Clear();
                    Console.Write("Алфавит: ");
                    WhiteLn(a);
                    Console.Write("Строка: ");
                    WhiteLn(s);
                    Console.WriteLine();
                    if (rulin)
                    {
                        Console.WriteLine("Правила: ");
                        PrintRules(ruleNumber);
                    }
                    Console.WriteLine("1. Ввести новый набор правил\n2. Добавить правила или заменить текущие\n3. Что я здесь забыл?");
                    Console.WriteLine();
                    act = AskForAction(3);
                    switch (act)
                    {
                        case 1:
                            left = new string[100];
                            right = new string[100];
                            end = new bool[100];
                            ruleNumber = 0;
                            WorkRules(ref ruleNumber);
                            break;
                        case 2:
                            Console.Clear();
                            Console.Write("Алфавит: ");
                            WhiteLn(a);
                            Console.Write("Строка: ");
                            WhiteLn(s);
                            Console.WriteLine("Правила: ");
                            PrintRules(ruleNumber);
                            Console.WriteLine("Введите номер правила, которое хотите заменить.\nДля добавления еще одного правила введите номер, на единицу больший максимального.");
                            bool ok;
                            int k;
                            do
                            {
                                Console.Write("Номер: ");
                                string buf = Console.ReadLine();
                                ok = int.TryParse(buf, out k) && k > 0 && k <= ruleNumber + 1;
                                if (!ok)
                                {
                                    RedLn("Ошибка. Ожидалось значение в пределах 1-" + (ruleNumber + 1));
                                }
                            } while (!ok);
                            addRule(k - 1);
                            break;
                    }
                } while (act != 3);
            }

        }
        static void PrintRules(int ruleNumber)
        {

            for (int i = 0; i < ruleNumber; i++)
            {
                Console.Write((i + 1) + ". ");
                Console.ForegroundColor = ConsoleColor.White;
                Console.Write(left[i] + "->");
                if (end[i] == true)
                {
                    Console.Write(".");
                }
                Console.WriteLine(right[i]);
                Console.ResetColor();
            }
            Console.WriteLine();

        }
        static void Main(string[] args)
        {
            bool alfin = false;
            strin = false;
            rulin = false;
            int act = 0;
            int ruleNumber = 0;
            int exit;
            Console.Clear();
            WhiteLn("Нормальные алгорифмы Маркова.");
            Console.WriteLine();
            WhiteLn("Нажмите любую клавишу для продолжения.");
            Console.WriteLine("\n\n\nВеселов Матлашевская Неганова Юрчак");
            Console.ReadKey();
            do
            {
                Console.Clear();
                if (alfin)
                {
                    Console.Write("Алфавит: ");
                    WhiteLn(a);
                }
                if (strin)
                {
                    Console.Write("Строка: ");
                    WhiteLn(s);
                }
                if (rulin)
                {
                    Console.WriteLine("Правила: ");
                    PrintRules(ruleNumber);
                }
                if (alfin && !rulin)
                {
                    Console.WriteLine();
                }
                int menuCounter = 0;

                if (!alfin)
                {
                    Console.WriteLine(++menuCounter + ". Ввести новый алфавит");
                }
                else
                {
                    Console.WriteLine(++menuCounter + ". Работа с алфавитом");
                    if (!strin)
                    {
                        Console.WriteLine(++menuCounter + ". Ввести новую строку");
                    }

                    else
                    {
                        Console.WriteLine(++menuCounter + ". Заменить строку");
                        if (!rulin)
                        {
                            Console.WriteLine(++menuCounter + ". Ввести новые правила");
                        }
                        else
                        {
                            Console.WriteLine(++menuCounter + ". Работа с правилами");

                            Console.WriteLine("\n" + ++menuCounter + ". Обработать строку");
                        }
                    }
                }

                Console.WriteLine("\n" + ++menuCounter + ". Выход"); exit = menuCounter;
                Console.WriteLine();

                act = AskForAction(exit);
                switch (act)
                {
                    case 1:
                        WorkAlphabet(ref alfin);
                        break;
                    case 2:
                        if (act != exit)
                        {
                            Console.Clear();
                            Console.Write("Алфавит: ");
                            WhiteLn(a);
                            Console.WriteLine();
                            bool ok;
                            do
                            {
                                do
                                {
                                    Console.Write("Введите новую строку для работы: ");
                                    s = Console.ReadLine();
                                    if (s == "")
                                    {
                                        RedLn("Ошибка. Строка не может быть пустой.");
                                        Console.WriteLine();
                                    }
                                } while (s == "");
                                ok = Alf(s);
                                if (!ok)
                                {
                                    RedLn("Ошибка. В строке обнаружены недопустимые символы.\n");
                                }
                            } while (!ok);
                            strin = true;
                        }
                        break;
                    case 3:
                        if (act != exit)
                        {
                            WorkRules(ref ruleNumber);
                        }
                        break;
                    case 4:
                        q = 0;
                        string copys = s;
                        s = Algoritm(s, left, right, end, ruleNumber);
                        if (q < 9000)
                        {

                            Console.Write("Результат: ");
                            WhiteLn(s);
                            Console.ReadKey();
                        }
                        else
                        {
                            s = copys;
                            RedLn("Зацикливание.");
                            Console.ReadKey();
                        }
                        break;


                }

            } while (act != exit);
        }
    }
}