Markov2.0

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; // массив левых частей введенных правил
        static string[] right; // массив правых частей
        static bool[] end; // массив тру-фолс в зависимости от конечности или не конечности мета-символа в правиле соотв.

        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))) // правая часть правила с "->." не соотв. алф.
                        {
                            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 "->" не соотв. алф.
                        {
                            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. Добавить символы в имеющийся");
                act = AskForAction(2);
                if (act == 1)
                {
                    do
                    {
                        Console.Write("Введите алфавит в одну строку:");
                        a1 = Console.ReadLine();
                        a1 = RemoveSpaces(a1);
                        if (FindEquals(a1) == true)
                        {
                            RedLn("Ошибка. В вашем алфавите найдены повторяющиеся элементы. Повторите ввод.\n");
                        }
                    }
                    while (FindEquals(a1) == true);
                    a = a1 + " ";
                }
                else
                {
                    // запросить новую строку, проверить на повторы внутри самой себя
                    // проверить на одинаковые символы старый алфавит и новый кусок
                    // если все ок - добавить ее в конец имеющегося алфавита
                }
            }
            else // если алфавита не было
            {
                do
                {
                    Console.Write("Введите алфавит в одну строку:");
                    a1 = Console.ReadLine();
                    a1 = RemoveSpaces(a1);
                    if (FindEquals(a1) == true)
                    {
                        RedLn("Ошибка. В вашем алфавите найдены повторяющиеся элементы. Повторите ввод.\n");
                    }
                }
                while (FindEquals(a1) == true);
                a = a1 + " ";
                alfin = true;
            }
        } // работа с алфавитом
        static void InputNewRule(/* сюда можно передать номер, на который мы вводим новые правило*/)
        {
            // запрашиваем ввод нового правила, проверяем всяко-разно, дописываем в массивы
        }
        static void WorkRules(ref bool rulin) // работа с правилами
        {
            Console.Clear();
            if (rulin)
            {
                // заменить (заменить старые на новые выборочно) или добавить новые (заменить пустое (n+1)-е правило на новое k раз, где n - номер максимального введенного правила)
                // если заменить - спрашивает у пользователя номера заменяемых правил, вызывает InputNewRules для всех нужных номеров
                // если ввести новые - вызывает InputNewRules, передавая ей в качестве номера вводимого правила номер, превышающий  на 1. потом спрашивает - ввести ли еще
            }
            else
            {
                // вызывает InputNewRules, передавая ей в качестве номера вводимого правила номер, превышающий номер максимального введенного правила на 1. потом спрашивает - ввести ли еще
            }

        }
        static void Main(string[] args)
        {
            //bool alfin = true; a = "стрк-алфовит";
            bool alfin = false;

            //bool strin = true; s = "строка-строка";
            bool strin = false;

            //bool rulin = true;
            bool rulin = false;

            int act = 0;
            right = null;
            end = null;
            left = null;
            int ruleNumber = 0;
            int exit;
            Console.Clear();
            //Console.WriteLine("Нормальные алгорифмы Маркова.\n\nДля продолжения нажмите любую клавишу");
            //Console.ReadKey();

            do
            {
                Console.Clear();
                if (alfin)
                {
                    Console.Write("Алфавит: ");
                    WhiteLn(a);
                }
                if (strin)
                {
                    Console.Write("Строка: ");
                    WhiteLn(s);
                }
                if (rulin)
                {

                }
                if (alfin || strin || 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
                            {
                                Console.Write("Введите строку для работы: ");
                                s = Console.ReadLine();
                                ok = Alf(s);
                                if (!ok)
                                {
                                    RedLn("Ошибка. В строке обнаружены недопустимые символы.\n");
                                }
                            } while (!ok);
                            strin = true;
                        }
                        break;
                    case 3:
                        if (act != exit)
                        {
                            //WorkRules();  здесь остановился
                        }
                        break;
                }

            } while (act != exit);

        }
    }
}