LAB5

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

namespace Lab5
{
    /*
       одномерный - Удалить все нечетные элементы
       двумерный  - Добавить строку после строки, содержащей наибольший элемент
       рваный     - Добавить строку в начало масссива
     */
    class Program
    {

        // ввод массивов
        static Random rnd = new Random();

        static int AskForArraySize()
        {
            bool ok;
            int size;
            do
            {
                Console.Write("Размерность: ");
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out size) && (size > 0);
                if (!ok)
                    RedLn("Размерность должна быть натуральной.");
            } while (!ok);
            Console.WriteLine();
            return size;
        }
        static int AskForArraySize(int dimention)
        {
            bool ok;
            int size;
            string[] arrayOfDimentions = { "Количество строк: ",
                                         "Количество столбцов: ",
                                         "Количество элементов в глубину:"};
            do
            {
                Console.Write(arrayOfDimentions[dimention]);
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out size) && (size > 0);
                if (!ok)
                {
                    RedLn("Размерность должна быть натуральной.");
                }
                } while (!ok);
                Console.WriteLine();
            return size;
        }
        static int AskForJaggedArrayStringSize(int rowNumber)
        {
            bool ok;
            int length;
            do
            {
                Console.Write("Длина строки {0}: ", rowNumber+1);
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out length) && (length>0);
            } while (!ok);
            return length;
        }
        static int[] InputRandom(int size, int lowest, int highest)
        {
            int[] randAr = new int[size];
            //Random rnd = new Random();
            for (int i = 0; i < size; i++)
            {
                randAr[i] = rnd.Next(lowest, highest);
            }
            return randAr;
        }
        static int[,] InputRandom(int rows, int cols, int lowest, int highest)
        {
            int[,] randomMatrix = new int[rows,cols];
            Random rnd = new Random();
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < cols; j++)
                {
                    randomMatrix[i, j] = rnd.Next(lowest, highest);
                }
            }
            return randomMatrix;
        }
        static int[] InputManual(int size)
        {
            bool ok;
            int n;
            int[] keybAr = new int[size];

            for (int i = 0; i < size; i++)
            {
                do
                {
                    Console.Write("Элемент {0}: ", i + 1);
                    string buf = Console.ReadLine();
                    ok = int.TryParse(buf, out n);
                } while (!ok);
                keybAr[i] = n;
            }
            Console.WriteLine();
            return keybAr;
        }
        static int[,] InputManual(int rows, int cols)
        {
            bool ok;
            int item;
            int[,] matrix = new int[rows,cols];

            Console.WriteLine("Введите матрицу. ");
            for (int i = 0; i < rows; i++)
            {
                Console.WriteLine("Строка {0}:", i + 1);
                for (int j = 0; j < cols; j++)
                {
                    do
                    {
                        Console.Write("\tячейка  {0}: ", j + 1);
                        string buf = Console.ReadLine();
                        ok = int.TryParse(buf, out item);
                    } while (!ok);

                    matrix[i, j] = item;
                }
            }
            Console.WriteLine();
            return matrix;
        }

        // интерфейс и взаимодействие
        static void Red(string str)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.Write(str);
            Console.ResetColor();
        }
        static void RedLn(string str)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            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);
            Console.WriteLine();
            return act;
        }
        static void ShowMenu(params string[] menu)
        {
            for (int i = 0; i < menu.Length; i++)
            {
                Console.WriteLine(i + 1 + ". " + menu[i]);
            }
            Console.WriteLine();
        }

        // функциональные методы
        static int[] OddElementsDeleted(int[] vector)
        {
            //фint i = 0;

            int[] evenItems = Array.FindAll(vector, element => element % 2 == 0);
            /*foreach (int element in vector)
            {
                if (element % 2 ==0)
                {
                    evenItems[i++] = element;
                }
            }*/
            return evenItems;
        }
        static int MaxItemOfMatrix(int[,] matrix)
        {
            int maxItem = matrix[0, 0];
            for (int i = 0; i < matrix.GetLength(0); i++)
            {
                for (int j = 0; j < matrix.GetLength(1); j++)
                {
                    if (matrix[i,j] > maxItem)
                    {
                        maxItem = matrix[i, j];
                    }
                }
            }
            return maxItem;
        }
        static int RowWithMaxItem(int[,] matrix, int max)
        {
            for (int i = 0; i < matrix.GetLength(0); i++)
            {
                for (int j = 0; j < matrix.GetLength(1); j++)
                {
                    if (matrix[i, j] == max)
                    {
                        return i;
                    }
                }

            }
            return -1;
        }
        static int[,] RowInserted(int[,] matrix, int[] row, int place)
        {
            int rows = matrix.GetLength(0)+1;
            int cols = matrix.GetLength(1);
            int[,] resultMatrix = new int[rows, cols];
            int i = 0;
            for (i = 0; i < place+1; i++)
            {
                for (int j = 0; j < cols; j++)
                {
                    resultMatrix[i, j] = matrix[i, j];
                }
            }
            for (int j = 0; j < cols; j++)
            {
                resultMatrix[i, j] = row[j];
            }
            i++;
            for (; i < rows; i++)
            {
                for (int j = 0; j < cols; j++)
                {
                    resultMatrix[i, j] = matrix[i-1, j];
                }
            }
            return resultMatrix;
        }
        static int[][] FirstRowInserted(int[][] jagged, int[] row)
        {
            int[][] newJagged = new int[jagged.Length][];
            newJagged[0] = row;
            for (int i = 1; i < newJagged.Length; i++)
            {
                newJagged[i] = jagged[i - 1];
            }
            return newJagged;
        }

        // вывод массивов
        static void Print(int[] vector)
        {
            if (vector.Length == 0)
            {
                Console.Write("Массив пуст.");
            }
            else
            {
                foreach (int element in vector) Console.Write("{0,4:00}", element);
            }
            Console.WriteLine();

        }
        static void Print(int[,] matrix)
        {
            if (matrix.GetLength(0) == 0)
            {
                Console.WriteLine("Массив пуст.");
            }
            else
            {
                for (int i = 0; i < matrix.GetLength(0); i++)
                {
                    for (int j = 0; j < matrix.GetLength(1); j++)
                    {
                        Console.Write("{0,4:00}",matrix[i, j]);
                    }
                    Console.WriteLine();
                }
            }
            Console.WriteLine();
        }
        static void Print(int[][] jagged)
        {
            if (jagged.Length == 0)
            {
                Console.WriteLine("Массив пуст");
            }
            else
            {
                for (int i = 0; i < jagged.Length; i++)
                {
                    Print(jagged[i]);
                }
            }
        }

        // точка входа
        static void Main(string[] args)
        {
            int mainAct;
        MainMenu:
            do
            {
                ShowMenu("Работа с одномерным массивом",
                    "Работа с двумерным массивом",
                    "Работа с рваным массивом",
                    "Выход из программы");
                mainAct = AskForAction(4);
                int lowest = -99, highest = 99;
                switch (mainAct)
                {
                    case 1:                                                             // vector operations
                        int[] vector = new int[0];
                        int act;

                VectorInputMethodChoise:
                        ShowMenu("Сгенерировать массив случайных чисел",
                            "Ввести массив с клавиатуры",
                            "Назад в главное меню");
                        int inputAct = AskForAction(3);

                VectorSizeChoise:
                        if (inputAct == 3)
                        {
                            goto MainMenu;
                        }
                        int size = AskForArraySize();
                        switch (inputAct)
                        {
                            case 1: // random vector
                                vector = InputRandom(size, lowest, highest + 1);
                                break;
                            case 2: // manual entered vector
                                Console.WriteLine("Введите массив из {0} элементов. ", size);
                                vector = InputManual(size);
                                break;
                        }
                        Print(vector);
                        do
                        {
                            ShowMenu("Удалить нечетные элементы",
                                "Назад к вводу размерности",
                                "Назад к выбору способа ввода",
                                "Назад в главное меню");
                            act = AskForAction(4);

                            switch (act)
                            {
                                case 1:
                                    vector = OddElementsDeleted(vector);
                                    Print(vector);
                                    break;
                                case 2:
                                    goto VectorSizeChoise;
                                case 3:
                                    goto VectorInputMethodChoise;
                            }
                        } while (act < 4);
                        break;

                    case 2:                                                             // matrix operations
                        int[,] matrix = new int[0,0];
                    MatrixInputMethodChoise:
                        ShowMenu("Сгенерировать массив случайных чисел",
                            "Ввести массив с клавиатуры",
                            "Назад в главное меню");
                        inputAct = AskForAction(3);

                        if (inputAct == 3)
                        {
                            goto MainMenu;
                        }
                    MatrixSizeChoise:
                        int rows = AskForArraySize(0);
                        int cols = AskForArraySize(1);
                        switch (inputAct)
                        {
                            case 1:
                                matrix = InputRandom(rows, cols, lowest, highest + 1);
                                break;
                            case 2:
                                matrix = InputManual(rows, cols);
                                break;
                        }
                        Print(matrix);

                        do
                        {
                            ShowMenu("Вставить строку после строки, содержащей максимальный элемент",
                                "Назад к вводу размерности",
                                "Назад к выбору способа ввода",
                                "Назад в главное меню");
                            act = AskForAction(4);

                            switch (act)
                            {
                                case 1:

                                    ShowMenu("Сгенерировать случайную строку",
                                        "Ввести строку с клавиатуры");
                                    int act2 = AskForAction(2);
                                    int[] row = new int[cols];
                                    switch (act2)
                                    {
                                        case 1:
                                            row = InputRandom(cols, lowest, highest);
                                            break;
                                        case 2:
                                            Console.WriteLine("Введите элементы строки.");
                                            row = InputManual(cols);
                                            break;
                                    }
                                    int max = MaxItemOfMatrix(matrix);
                                    int place = RowWithMaxItem(matrix, max);
                                    matrix = RowInserted(place: place, matrix: matrix, row: row);

                                    Print(matrix);
                                    break;
                                case 2:
                                    goto MatrixSizeChoise;
                                case 3:
                                    goto MatrixInputMethodChoise;
                            }
                        } while (act < 4);

                        break;
                    case 3:                                                                 // jagged array operations

                JaggedArrayInputMethodChoise:

                        ShowMenu("Сгенерировать массив случайных чисел",
                            "Ввести массив с клавиатуры",
                            "Назад в главное меню");

                        inputAct = AskForAction(3);
                        if (inputAct == 3)
                        {
                            goto MainMenu;
                        }
                JaggedArraySizeChoise:

                        int[][] jag = new int[0][];
                        int[] newRow = new int[0];
                        rows = 0;

                        switch (inputAct)
                        {
                            case 1:

                                rows = AskForArraySize(0);
                                jag = new int[rows][];

                                for (int i = 0; i < rows; i++)
                                {
                                    size = rnd.Next(1, 11);
                                    jag[i] = InputRandom(size, lowest, highest);
                                }
                                break;

                            case 2:
                                rows = AskForArraySize(0);
                                jag = new int[rows][];
                                for (int i = 0; i < rows; i++)
                                {
                                    size = AskForJaggedArrayStringSize(i);
                                    jag[i] = InputManual(size);
                                }

                                break;

                        }

                        Print(jag);
                        Console.WriteLine();

                        do
                        {
                            ShowMenu("Вставить строку перед первой строкой",
                                                "Назад к вводу размерности",
                                                "Назад к выбору способа ввода",
                                                "Назад в главное меню");
                            act = AskForAction(4);

                            switch (act)
                            {
                                case 1:
                                    cols = AskForArraySize();
                                    ShowMenu("Сгенерировать строку",
                                        "Ввести строку с клавиатуры");
                                    act = AskForAction(2);
                                    switch (act)
                                    {
                                        case 1:
                                            newRow = InputRandom(cols, lowest, highest);
                                            break;
                                        case 2:
                                            newRow = InputManual(cols);
                                            break;
                                    }
                                    jag = FirstRowInserted(jag, newRow);

                                    Print(jag);
                                    Console.WriteLine();
                                    break;
                                case 2:
                                    goto JaggedArraySizeChoise;
                                case 3:
                                    goto JaggedArrayInputMethodChoise;
                                case 4:
                                    goto MainMenu;
                            }
                        } while (act < 4);

                        break;
                }
            } while (mainAct != 4);


        }
    }
}