Array Manipulator

using System;
using System.Linq;

namespace Array_Manipulator
{
    class Program
    {
        static void Main()
        {
            int[] arrayNumbers = Console.ReadLine().Split().Select(int.Parse).ToArray();

            string[] command = Console.ReadLine().Split().ToArray();



            while (command[0] != "end")
            {
                switch (command[0])
                {
                    case "exchange":
                        {
                            int indexForSwitch = int.Parse(command[1]);
                            if (indexForSwitch > arrayNumbers.Length || indexForSwitch < 0)
                                Console.WriteLine("Invalid index");

                            else
                            {
                                arrayNumbers = SplitExchangePositions(arrayNumbers, indexForSwitch);
                            }

                            break;
                        }
                    case "max":
                        {
                            if (command[1] == "even")
                            {
                                int maxEvenIndex = MaxEvenIndex(arrayNumbers);
                                //if there is no such index, my method returns -1
                                if (maxEvenIndex == -1)
                                    Console.WriteLine("No matches");
                                else
                                    Console.WriteLine(maxEvenIndex);
                            }

                            else if (command[1] == "odd")
                            {
                                //if there is no such index, my method returns -1
                                int maxOddIndex = MaxOddIndex(arrayNumbers);
                                if (maxOddIndex == -1)
                                    Console.WriteLine("No matches");
                                else
                                    Console.WriteLine(maxOddIndex);
                            }

                            break;
                        }
                    case "min":
                        {
                            if (command[1] == "even")
                            {
                                //if there is no such index, my method returns -1
                                int minEvenIndex = MinEvenIndex(arrayNumbers);
                                if (minEvenIndex == -1)
                                    Console.WriteLine("No matches");
                                else
                                    Console.WriteLine(minEvenIndex);
                            }

                            else if (command[1] == "odd")
                            {
                                //if there is no such index, my method returns -1
                                int minOddIndex = MinOddIndex(arrayNumbers);
                                if (minOddIndex == -1)
                                    Console.WriteLine("No matches");
                                else
                                    Console.WriteLine(minOddIndex);
                            }

                            break;
                        }
                    case "first":
                        {
                            if (command[2] == "even")
                            {
                                int count = int.Parse(command[1]);
                                FirstEvenElements(arrayNumbers, count);
                            }

                            else if (command[2] == "odd")
                            {
                                int count = int.Parse(command[1]);
                                FirstOddElements(arrayNumbers, count);
                            }

                            break;
                        }
                    case "last":
                        {
                            if (command[2] == "even")
                            {
                                int count = int.Parse(command[1]);
                                LastEvenElements(arrayNumbers, count);
                            }

                            else if (command[2] == "odd")
                            {
                                int count = int.Parse(command[1]);
                                LastOddElements(arrayNumbers, count);
                            }
                            break;
                        }
                }
                command = Console.ReadLine().Split().ToArray();
            }

            Console.WriteLine($"[{string.Join(", ", arrayNumbers)}]");
        }

        static int[] SplitExchangePositions(int[] array, int index)
        {
            //skip the numbers from certain index, since array counts from 0, add 1 to the index
            var newEnd = array.Skip(index + 1).ToArray();

            //take the numbers from certain index
            var arrBegin = array.Take(array.Length - newEnd.Length).ToArray();

            //rearrange the array
            for (int i = 0; i < newEnd.Length; i++)
                array[i] = newEnd[i];

            for (int j = newEnd.Length; j < array.Length; j++)
            {
                int index1 = j - newEnd.Length;
                array[j] = arrBegin[index1];
            }

            return array;
        }

        static int MaxEvenIndex(int[] array)
        {
            // set the index at -1, so if there is no even/odd index I am looking for, to know it
            int maxEvenIndex = -1;
            int maxEven = int.MinValue;

            for (int i = 0; i < array.Length; i++)
                if (array[i] % 2 == 0)
                {
                    if (maxEven <= array[i])
                    {
                        maxEven = array[i];
                        maxEvenIndex = i;
                    }
                }
            return maxEvenIndex;
        }

        static int MaxOddIndex(int[] array)
        {
            // set the index at -1, so if there is no even/odd index I am looking for, to know it

            int maxOddIndex = -1;
            int maxOdd = int.MinValue;

            for (int i = 0; i < array.Length; i++)
                if (array[i] % 2 != 0)
                {
                    if (maxOdd <= array[i])
                    {
                        maxOdd = array[i];
                        maxOddIndex = i;
                    }
                }
            return maxOddIndex;
        }

        static int MinEvenIndex(int[] array)
        {
            // set the index at -1, so if there is no even/odd index I am looking for, to know it
            int minEvenIndex = -1;
            int minEven = int.MaxValue;

            for (int i = 0; i < array.Length; i++)
                if (array[i] % 2 == 0)
                {
                    if (minEven >= array[i])
                    {
                        minEven = array[i];
                        minEvenIndex = i;
                    }
                }
            return minEvenIndex;
        }

        static int MinOddIndex(int[] array)
        {
            // set the index at -1, so if there is no even/odd index I am looking for, to know it
            int minOddIndex = -1;
            int minOdd = int.MaxValue;

            for (int i = 0; i < array.Length; i++)
                if (array[i] % 2 != 0)
                {
                    if (minOdd >= array[i])
                    {
                        minOdd = array[i];
                        minOddIndex = i;
                    }
                }
            return minOddIndex;
        }

        static int CountEvenElements(int[] array)
        {
            int counterEven = 0;
            for (int i = 0; i < array.Length; i++)
                if (array[i] % 2 == 0)
                    counterEven++;

            return counterEven;
        }

        static int CountOddElements(int[] array)
        {
            int counterOdd = 0;
            for (int i = 0; i < array.Length; i++)
                if (array[i] % 2 != 0)
                    counterOdd++;

            return counterOdd;
        }

        static void FirstEvenElements(int[] array, int count)
        {
            int evenElementsTotal = CountEvenElements(array);

            if (evenElementsTotal == 0)
                Console.WriteLine("[]");

            else if (count > array.Length)
                Console.WriteLine("Invalid count");

            else if (count >= evenElementsTotal)
            {
                int[] arrayFirstEven = new int[evenElementsTotal];
                arrayFirstEven = FillArrayWithEven(array, arrayFirstEven, 0);

                Console.WriteLine($"[{string.Join(", ", arrayFirstEven)}]");
            }

            else if (count < evenElementsTotal)
            {
                int[] arrayFirstEven = new int[count];
                arrayFirstEven = FillArrayWithEven(array, arrayFirstEven, 0);

                Console.WriteLine($"[{string.Join(", ", arrayFirstEven)}]");
            }
        }

        static void FirstOddElements(int[] array, int count)
        {
            int oddElementsTotal = CountOddElements(array);

            if (oddElementsTotal == 0)
                Console.WriteLine("[]");

            else if (count > array.Length)
                Console.WriteLine("Invalid count");

            else if (count >= oddElementsTotal)
            {
                int[] arrayFirstOdd = new int[oddElementsTotal];
                arrayFirstOdd = FillArrayWithOdd(array, arrayFirstOdd, 0);

                Console.WriteLine($"[{string.Join(", ", arrayFirstOdd)}]");
            }

            else if (count < oddElementsTotal)
            {
                int[] arrayFirstOdd = new int[count];
                arrayFirstOdd = FillArrayWithOdd(array, arrayFirstOdd, 0);

                Console.WriteLine($"[{string.Join(", ", arrayFirstOdd)}]");
            }
        }

        static void LastEvenElements(int[] array, int count)
        {
            int evenElementsTotal = CountEvenElements(array);

            if (evenElementsTotal == 0)
                Console.WriteLine("[]");

            else if (count > array.Length)
                Console.WriteLine("Invalid count");

            else if (count >= evenElementsTotal)
            {
                int[] arrayLastEven = new int[evenElementsTotal];
                arrayLastEven = FillArrayWithEven(array, arrayLastEven, array.Length - count);

                Console.WriteLine($"[{string.Join(", ", arrayLastEven)}]");
            }

            else if (count < evenElementsTotal)
            {
                int[] arrayLastEven = new int[count];
                arrayLastEven = FillArrayWithEven(array, arrayLastEven, array.Length - count);

                Console.WriteLine($"[{string.Join(", ", arrayLastEven)}]");
            }
        }

        static void LastOddElements(int[] array, int count)
        {
            int oddElementsTotal = CountOddElements(array);

            if (oddElementsTotal == 0)
                Console.WriteLine("[]");

            else if (count > array.Length)
                Console.WriteLine("Invalid count");

            else if (count >= oddElementsTotal)
            {
                int[] arrayLastOdd = new int[oddElementsTotal];
                arrayLastOdd = FillArrayWithOdd(array, arrayLastOdd, array.Length - count);

                Console.WriteLine($"[{string.Join(", ", arrayLastOdd)}]");
            }

            else if (count < oddElementsTotal)
            {
                int[] arrayLastOdd = new int[count];
                arrayLastOdd = FillArrayWithOdd(array, arrayLastOdd, array.Length - count);

                Console.WriteLine($"[{string.Join(", ", arrayLastOdd)}]");
            }
        }
        static int[] FillArrayWithOdd(int[] array, int[] arrayOdd, int startcount)
        {
            int indexArrayFirstOdd = 0;
            for (int i = startcount; i < array.Length; i++)
            {
                if (array[i] % 2 != 0)
                {
                    arrayOdd[indexArrayFirstOdd] = array[i];
                    indexArrayFirstOdd++;
                }

                if (indexArrayFirstOdd >= arrayOdd.Length)
                    break;

            }
            return arrayOdd;
        }
        static int[] FillArrayWithEven(int[] array, int[] arrayEven, int startcount)
        {
            int indexArrayFirstEven = 0;
            for (int i = startcount; i < array.Length; i++)
            {
                if (array[i] % 2 == 0)
                {
                    arrayEven[indexArrayFirstEven] = array[i];
                    indexArrayFirstEven++;
                }

                if (indexArrayFirstEven >= arrayEven.Length)
                    break;

            }
            return arrayEven;
        }

    }
}