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

namespace Lab5
{
    class Program
    {
        //ограничения для размера массива (длина массива, число строк, число столбцов)
        const int MIN_LENGTH = 1;
        const int MAX_LENGTH = 100;
        //ограничения для элементов массива
        const int MIN_VALUE = -100;
        const int MAX_VALUE = 100;

        static int ReadIntNumber(string message, int left, int right) // ввод целого числа
        {
            bool ok = false;
            int number = MIN_VALUE;
            do
            {
                Console.WriteLine(message);
                try
                {
                    string buf = Console.ReadLine();
                    number = Convert.ToInt32(buf);// могут возникнуть исключения типа FormatException, OverflowException
                    if (number >= left && number < right)
                    {
                        ok = true;
                    }
                    else
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine("Ошибка! Повторите ввод.");
                        Console.ResetColor();
                        ok = false;
                    }
                }
                catch (FormatException)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("Ошибка! Повторите ввод.");
                    Console.ResetColor();
                    ok = false;
                }
                catch (OverflowException)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("Ошибка! Повторите ввод.");
                    Console.ResetColor();
                    ok = false;
                }
            } while (!ok);
            return number;
        }
        static void MainMenu()
        {
            int answer, size = 0, strings = 0, columns = 0;
            int[] arr = new int[size];
            int[,] matr = new int[strings, columns];
            int[][] ragg_arr = new int[strings][];
            do
            {
                Console.WriteLine("Выберите:");
                answer = ReadIntNumber("\n1.\t Работа с одномерными массивами. \n2.\t Работа с двумерными массивами. \n3.\t Работа с рваными массивами. \n4.\t Выход. ", 1, 5);
                switch (answer)
                {
                    case 1:
                        {
                            MenuForArray(size, arr);
                            break;
                        }
                    case 2:
                        {
                            MenuForMatr(strings, columns, matr);
                            break;
                        }
                    case 3:
                        {
                            MenuForRaggedArray(strings, ragg_arr);
                            break;
                        }
                }
            } while (answer != 4);


    }


        //___________________________________________Одномерный массив________________________________________________________

        static int[] MakeArray(int size) //для формирования массива двумя способами
        {
            int[] arr = null;
            int check = 0;
            Console.WriteLine("Выберите способ задания массива:");
            Console.WriteLine("\n1.\t Задать массив с помощью ДСЧ. \n2.\t Задать массив самостоятельно. \n3.\t Назад.");
            check = ReadIntNumber(" ", 1, 3);
            switch (check)
            {
                case 1:
                    {
                        arr = GetRandomArray(size);
                        break;
                    }
                case 2:
                    {
                        arr = GetArrayFromUser(size);
                        break;
                    }
                case 3:
                    {
                        MenuForArray(size, arr);
                        break;
                    }
            }
            Console.WriteLine();
            return arr;
        }
        static int[] GetRandomArray(int size) // массив задается с помощью ДСЧ
        {
            int[] arr = new int[size];
            Random rand = new Random();
            for (int i = 0; i < size; i++)
            {
                arr[i] = rand.Next(-100, 100);
            }
            return arr;
        }
        static int[] GetArrayFromUser(int size) // массив задаётся пользователем
        {
            int j = 0;
            bool OK;
            int[] arr = new int[size];
            for (int i = 0; i < size; i++)
            {
                do
                {
                    Console.WriteLine("Введите элемент массива № {0} ", i + 1);
                    OK = int.TryParse(Console.ReadLine(), out arr[i]);
                    if (arr[i] == 0) j++;
                    if (j == size)
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine("Внимание!\nВы создали нулевой массив");
                        Console.ResetColor();
                    }

                    if (!OK)
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine("Ошибка ввода. Повторите ввод");
                        Console.ResetColor();
                    }
                } while (!OK);
            }
            return arr;
        }
        static void PrintArray(int size, int[] arr) //вывод массива на экран
        {
            Console.ForegroundColor = ConsoleColor.Cyan;
            for (int i = 0; i < size; i++)
                Console.Write(arr[i] + " ");
            Console.ResetColor();
            Console.WriteLine();
        }

        static void ADDK(ref int size, ref int[] arr)
        {
            int k;
            k = ReadIntNumber("Введите количество элементов, которое хотите добавить", MIN_VALUE, MAX_VALUE);
            size = size + k;
            int[] arrK = new int[size];
            int[] arrK2 = new int[size + k];

            for (int i = 0; i < k; i++)
            {
                arrK[i] = ReadIntNumber("Введите элемент", MIN_VALUE, MAX_VALUE);
            }

            for (int i = k; i < size; i++)
            {
                arrK[i] = arr[i - k];
            }


            for (int i = 0; i < size; i++)
            {
                arrK2[i] = arrK[i];
            }
            arr = arrK2;
            size = size + k;
            return;

        }

        static void MenuForArray(int size, int[] arr) // выбор способа задания массива
        {
            int answer;
            do
            {
                Console.WriteLine("Выберите действие:");
                answer = ReadIntNumber("\n1.\t Создать одномерный массив. \n2.\t Добавить k элементов в начало и конец массива. \n3.\t Назад. ", 1, 4);
                switch (answer)
                {
                    case 1:
                        {
                            size = ReadIntNumber("Введите колличество элементов массива:", MIN_LENGTH, MAX_LENGTH);
                            arr = MakeArray(size);
                            PrintArray(size, arr);
                            break;
                        }
                    case 2:
                        {
                            ADDK(ref size, ref arr);
                            PrintArray(size, arr);
                            break;
                        }
                    case 3:
                        {
                            MainMenu();
                            break;
                        }
                }
            } while (answer < 4);

        }

        //___________________________________________Двумерный массив________________________________________________________

        static int[,] GetRandomMatr(int strings, int columns) //создание 2мерного массива
        {

            Random rand = new Random();
            int[,] matr = new int[strings, columns];
            for (int i = 0; i < strings; i++)
            {
                for (int j = 0; j < columns; j++)
                {
                    matr[i, j] = rand.Next(-100, 100);
                }
            }

            return matr;
        }
        static int[,] GetMatrFromUser(int strings, int columns) // двумерный массив создается пользователем
        {
            int el, count = 0;
            Random rand = new Random();
            int[,] matr = new int[strings, columns];
            for (int i = 0; i < strings; i++)
            {
                for (int j = 0; j < columns; j++)
                {
                    el = ReadIntNumber("Введите элемент", MIN_VALUE, MAX_VALUE);
                    matr[i, j] = el;
                    if (el == 0) count++;
                }
            }
            if (count == strings * columns)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("Вы создали нулевой массив\n Задайте его снова");
                Console.ResetColor();
            }
            return matr;
        }
        static int[,] MakeMatr(int strings, int columns) // 2 способа создания массива
        {
            int[,] matr = null;
            int check = 0;
            Console.WriteLine("Выберите способ задания массива:");
            Console.WriteLine("\n1.\t Задать массив с помощью ДСЧ. \n2.\t Задать массив самостоятельно. \n3.\t Назад.");
            check = ReadIntNumber(" ", 1, 3);
            switch (check)
            {
                case 1:
                    {
                        matr = GetRandomMatr(strings, columns);
                        PrintMatr(matr, strings, columns);
                        break;
                    }
                case 2:
                    {
                        matr = GetMatrFromUser(strings, columns);
                        PrintMatr(matr, strings, columns);
                        break;
                    }
                case 3:
                    {
                        MenuForMatr(strings, columns, matr);
                        break;
                    }
            }
            return matr;
        }

        static void DeleteZeroColumns(ref int[,] matr, ref int strings, ref int columns) // удаление столбцов, содержащих 0
        {
            int zero = 0, j, el = 0, count = 0;
            int[,] matr2 = new int[strings, columns];
            for (int i = 0; i < strings; i++)
            {
                for (j = 0; j < columns; j++)
                {
                    matr[i, j] = el;
                    if (el == 0) count++;
                }
                {
                    Console.WriteLine("В массиве нет нулей!");
                    return;
                }
            }
            columns = count;
            int[,] temp = new int[strings, columns];
            for (int i = 0; i < strings; i++)
            {
                temp[i, columns] = matr2[i, columns];

            }
            matr = temp;
        }
        static void PrintMatr(int[,] matr, int strings, int columns) // распечатать двумерный массив
        {
            for (int i = 0; i < strings; i++)
            {
                for (int j = 0; j < columns; j++)
                {
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.Write("  " + matr[i, j]);
                    Console.ResetColor();
                }
                Console.WriteLine();
            }
        }
        static void MenuForMatr(int strings, int columns, int[,] matr) // меню
        {
            int answer;
            do
            {
                Console.WriteLine("Выберите действие:");
                answer = ReadIntNumber("\n1.\t Создать двумерный массив. \n2.\t Удалить все столбцы, в которых есть хотя бы один нулевой элемент. \n3.\t Назад. ", 1, 4);
                switch (answer)
                {
                    case 1:
                        {
                            strings = ReadIntNumber("Введите количество строк: ", MIN_LENGTH, MAX_LENGTH);
                            columns = ReadIntNumber("Введите количество столбцов: ", MIN_LENGTH, MAX_LENGTH);
                            matr = MakeMatr(strings, columns);
                            break;
                        }
                    case 2:
                        {
                            DeleteZeroColumns(ref matr, ref strings, ref columns);
                            PrintMatr(matr, strings, columns);
                            break;
                        }
                    case 3:
                        {
                            MainMenu();
                            break;
                        }
                }
            } while (answer < 4);
        }

        //___________________________________________Рваный массив________________________________________________________

        static int[][] GetRandomRaggedArray(int strings) // с помощью ДСЧ
        {
            int[][] ragged_array = new int[strings][]; //выделить память под массив
            int i, j;
            int columns;
            Random rnd = new Random();

            for (i = 0; i < strings; i++)
            {
                columns = ReadIntNumber("Введите колличество столбцов в " + (i + 1) + "-й строке (длину " + (i + 1) + "-й строки):", MIN_LENGTH, MAX_LENGTH);
                ragged_array[i] = new int[columns];
                for (j = 0; j < columns; j++)
                    ragged_array[i][j] = rnd.Next(-100, 100);
            }


            return ragged_array;
        }
        static int[][] GetRaggedArrayFromUser(int strings) // пользователь вводит
        {
            int[][] ragged_array = new int[strings][]; //выделить память под массив
            int i, j;
            int columns;
            for (i = 0; i < strings; i++)
            {
                columns = ReadIntNumber("Введите колличество столбцов в " + (i + 1) + "-й строке (длину " + (i + 1) + "-й строки):", MIN_LENGTH, MAX_LENGTH);
                ragged_array[i] = new int[columns];
                for (j = 0; j < columns; j++)
                    ragged_array[i][j] = ReadIntNumber("Введите" + " " + (j + 1) + "-й элемент строки из диапазона от -100 до 100", MIN_VALUE, MAX_VALUE);
            }


            return ragged_array;
        }
        static int[][] MakeRaggedArray(int strings) // 2 способа задания массива
        {
            int[][] ragg_arr = null;
            int answer = 0;
            Console.WriteLine("Выберите способ задания массива:");
            Console.WriteLine("\n1.\t Задать массив с помощью ДСЧ. \n2.\t Задать массив самостоятельно. \n3.\t Назад.");
            answer = ReadIntNumber(" ", 1, 3);
            switch (answer)
            {
                case 1:
                    {
                        ragg_arr = GetRandomRaggedArray(strings);
                        PrintRaggedArray(strings, ragg_arr);
                        break;
                    }
                case 2:
                    {
                        ragg_arr = GetRaggedArrayFromUser(strings);
                        PrintRaggedArray(strings, ragg_arr);
                        break;
                    }
                case 3:
                    {
                        MenuForRaggedArray(strings, ragg_arr);
                        break;
                    }
            }
            return ragg_arr;
        }
        static void PrintRaggedArray(int strings, int[][] ragg_arr) // распечатать рваный массив
        {
            for (int i = 0; i < strings; i++)
            {
                foreach (int el in ragg_arr[i])
                {
                    Console.ForegroundColor = ConsoleColor.Magenta;
                    Console.Write("  " + el);
                    Console.ResetColor();
                }

                Console.WriteLine();
            }
        }


        static void AddString2(ref int[][] ragg_arr, ref int strings)
        {
            int element, columns, stringtoadd, ncolumns;
            int[][] ragg_arr2 = new int[strings][];

            stringtoadd = ReadIntNumber("Выберите строку", 1, strings);

            ncolumns = ReadIntNumber("Введите кол-во элементов", MIN_LENGTH, MAX_LENGTH);

            int count = 0;
            ragg_arr2[stringtoadd] = new int[ncolumns];

            for (int j = 0; j < ncolumns; j++)
            {
                element = ReadIntNumber("Введите элемент, чтобы добавить его в строку рваного массива", MIN_VALUE, MAX_VALUE);
                ragg_arr2[stringtoadd][j] = element;
                if (element == 0) count++;
            }
            if (count == ncolumns)
            {
                Console.WriteLine("Внимание! Добавлена нулевая строка. Она выведена не будет ");
            }
            else
            {
                for (int i = 0; i < strings; i++)
                {
                    ragg_arr2[i] = ragg_arr[i];
                }

            }
            ragg_arr2 = ragg_arr;
        }
        static void MenuForRaggedArray(int strings, int[][] ragg_arr)
        {
            int answer;
            do
            {
                Console.WriteLine("Выберите действие:");
                answer = ReadIntNumber("\n1.\t Создать рваный массив. \n2.\t Добавить строку с заданным номером. \n3.\t Назад. ", 1, 4);
                switch (answer)
                {
                    case 1:
                        {
                            strings = ReadIntNumber("Введите количество строк: ", MIN_LENGTH, MAX_LENGTH);
                            ragg_arr = MakeRaggedArray(strings);
                            break;
                        }
                    case 2:

                        {
                            //AddString(ragg_arr, strings);
                            AddString2(ref ragg_arr, ref strings);
                            PrintRaggedArray(strings, ragg_arr);
                            break;
                        }
                    case 3:
                        {
                            MainMenu();
                            break;
                        }
                }
            } while (answer < 4);
        }

        static void Main(string[] args)
        {
            MainMenu();

        }

    }
}