public override void Run(UserConsole userConsole, Storage storage)
        {
            while (true)
            {
                var input = userConsole.ReadLine();
                switch (input.Trim())
                {
                case "exit":
                    return;

                case "add":
                    Add(userConsole);
                    break;

                case "median":
                    Median(userConsole);
                    break;

                case "help":
                    Help(userConsole);
                    break;

                case "rand":
                    x = Random(userConsole, x);
                    break;

                default:
                    userConsole.WriteLine("Такой команды нет, используйте help для списка команд");
                    break;
                }
            }
        }
        private void Add(UserConsole console)
        {
            var a = ReadNumber(console);
            var b = ReadNumber(console);

            console.WriteLine((a + b).ToString(Culture));
        }
 private void PrintHelp(UserConsole console, StateKeeper stateKeeper, List <string> helpText)
 {
     for (var i = stateKeeper.ShowedResults; i < helpText.Count; i++)
     {
         console.WriteLine(helpText[i]);
         stateKeeper.ShowedResults = i + 1;
         stateKeeper.SaveState();
     }
 }
 private void WriteInConsole(UserConsole console, string line)
 {
     if (previousIgnoreCounter > 0)
     {
         previousIgnoreCounter--;
     }
     else
     {
         console.WriteLine(line);
         UpgradeIgnore();
     }
 }
 public override void WriteLine(string content)
 {
     if (_unusedStorageLines.Count != 0)
     {
         _unusedStorageLines.Dequeue();
     }
     else
     {
         _console.WriteLine(content);
         AddToStorage(content);
     }
 }
        private void Median(UserConsole console)
        {
            var count   = ReadNumber(console);
            var numbers = new List <int>();

            for (var i = 0; i < count; i++)
            {
                numbers.Add(ReadNumber(console));
            }

            var result = CalculateMedian(numbers);

            console.WriteLine(result.ToString(Culture));
        }
        private void Add(UserConsole console, StateKeeper stateKeeper)
        {
            stateKeeper.ArgsCount = 2;
            var args = stateKeeper.GetArgs();
            var a    = args[0] == null?int.Parse(console.ReadLine().Trim(), Culture) : int.Parse(args[0], Culture);

            stateKeeper.Args[0] = a.ToString(Culture);
            stateKeeper.SaveState();
            var b = args[1] == null?int.Parse(console.ReadLine().Trim(), Culture) : int.Parse(args[1], Culture);

            stateKeeper.Args[1] = b.ToString(Culture);
            stateKeeper.SaveState();
            console.WriteLine((a + b).ToString(Culture));
        }
        private long Random(UserConsole console, long x)
        {
            const int a = 16807;
            const int m = 2147483647;

            var count = ReadNumber(console);

            for (var i = 0; i < count; i++)
            {
                console.WriteLine(x.ToString(Culture));
                x = a * x % m;
            }

            return(x);
        }
 public override void WriteLine(string content)
 {
     if (lastOutputCommand < data.lastOutputCommand)
     {
         lastOutputCommand++;
     }
     else
     {
         userConsole.WriteLine(content);
         data.outputCommands.Add(content);
         data.lastOutputCommand++;
         lastOutputCommand++;
         Serialize(data);
     }
 }
        public override void Run(UserConsole userConsole, Storage storage)
        {
            var myConsole = new MyConsole(storage, userConsole);

            while (true)
            {
                var input = myConsole.ReadLine();

                switch (input.Trim())
                {
                case "exit":
                    myConsole.data.x = 420;
                    myConsole.Serialize(new Datas());
                    myConsole.data = new Datas();

                    return;

                case "add":
                    Add(myConsole);
                    break;

                case "median":
                    Median(myConsole);
                    break;

                case "help":
                    Help(myConsole);
                    break;

                case "rand":
                    myConsole.data.x = Random(myConsole, myConsole.data.x);
                    break;

                default:
                    userConsole.WriteLine("Такой команды нет, используйте help для списка команд");
                    break;
                }

                long tempx = myConsole.data.x;
                myConsole.data              = new Datas();
                myConsole.lastInputCommand  = 0;
                myConsole.lastOutputCommand = 0;
                myConsole.data.x            = tempx;

                myConsole.Serialize(myConsole.data);
            }
        }
        private void Random(UserConsole console, StateKeeper stateKeeper)
        {
            const int a = 16807;
            const int m = 2147483647;

            stateKeeper.ResultsCount = stateKeeper.ResultsCount == 0
                ? int.Parse(console.ReadLine().Trim(), Culture)
                : stateKeeper.ResultsCount;
            stateKeeper.SaveState();
            for (var i = stateKeeper.ShowedResults; i < stateKeeper.ResultsCount; i++)
            {
                console.WriteLine(stateKeeper.x.ToString(Culture));
                stateKeeper.x             = a * stateKeeper.x % m;
                stateKeeper.ShowedResults = i + 1;
                stateKeeper.SaveState();
            }
        }
        private void Median(UserConsole console, StateKeeper stateKeeper)
        {
            stateKeeper.ArgsCount = stateKeeper.ArgsCount == -1
                ? int.Parse(console.ReadLine().Trim(), Culture)
                : stateKeeper.ArgsCount;
            stateKeeper.SaveState();
            var args = stateKeeper.GetArgs();

            for (var i = 0; i < stateKeeper.ArgsCount; i++)
            {
                args[i] = args[i] ?? console.ReadLine().Trim();
                stateKeeper.SaveState();
            }

            var result = CalculateMedian(args.Select(x => int.Parse(x, Culture)).ToList());

            console.WriteLine(result.ToString(Culture));
        }
        public override void Run(UserConsole userConsole, Storage storage)
        {
            var stateKeeper = new StateKeeper(storage, Culture);

            while (true)
            {
                stateKeeper.CurrentCommand ??= userConsole.ReadLine().Trim();
                stateKeeper.SaveState();
                switch (stateKeeper.CurrentCommand)
                {
                case "exit":
                    stateKeeper.Dispose();
                    return;

                case "add":
                    Add(userConsole, stateKeeper);
                    break;

                case "median":
                    Median(userConsole, stateKeeper);
                    break;

                case "help":
                    Help(userConsole, stateKeeper);
                    break;

                case "rand":
                    Random(userConsole, stateKeeper);
                    break;

                default:
                    userConsole.WriteLine("Такой команды нет, используйте help для списка команд");
                    break;
                }

                stateKeeper.Clear();
                stateKeeper.SaveState();
            }
        }
        private static void Help(UserConsole console)
        {
            const string exitMessage = "Чтобы выйти из режима помощи введите end";
            const string commands    = "Доступные команды: add, median, rand";

            console.WriteLine("Укажите команду, для которой хотите посмотреть помощь");
            console.WriteLine(commands);
            console.WriteLine(exitMessage);
            while (true)
            {
                var command = console.ReadLine();
                switch (command.Trim())
                {
                case "end":
                    return;

                case "add":
                    console.WriteLine("Вычисляет сумму двух чисел");
                    console.WriteLine(exitMessage);
                    break;

                case "median":
                    console.WriteLine("Вычисляет медиану списка чисел");
                    console.WriteLine(exitMessage);
                    break;

                case "rand":
                    console.WriteLine("Генерирует список случайных чисел");
                    console.WriteLine(exitMessage);
                    break;

                default:
                    console.WriteLine("Такой команды нет");
                    console.WriteLine(commands);
                    console.WriteLine(exitMessage);
                    break;
                }
            }
        }