Array Manipulator

using System;
using System.Collections.Generic;
using System.Linq;

namespace _02_Array_Manipulator
{
    public class ArrayManipulator
    {
        public static void Main()
        {
            var nums = Console.ReadLine().Split().Select(int.Parse).ToList();

            while (true)
            {
                string line = Console.ReadLine();
                if (line == "end")
                    break;

                CommandProcess(nums, line);
            }

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

        private static void CommandProcess(List<int> nums, string line)
        {
            var tokens = line.Split().ToArray();
            var command = tokens[0];

            if (command == "exchange")
                Exchange(nums, tokens);
            else if (command == "max")
                Max(nums, tokens);
            else if (command == "min")
                Min(nums, tokens);
            else if (command == "first")
                First(nums, tokens);
            else if (command == "last")
                Last(nums, tokens);
        }

        static void Last(List<int> nums, string[] tokens)
        {
            int count = int.Parse(tokens[1]);
            string evenOrOdd = tokens[2];

            if (IsValidCount(nums, count))
            {
                if (evenOrOdd == "even")
                {
                    var evenNums = nums.Where(n => n % 2 == 0).Reverse().Take(count).Reverse().ToList();
                    Console.WriteLine($"[{string.Join(", ", evenNums)}]");
                }
                else if (evenOrOdd == "odd")
                {
                    var oddNums = nums.Where(n => n % 2 != 0).Reverse().Take(count).Reverse().ToList();
                    Console.WriteLine($"[{string.Join(", ", oddNums)}]");
                }
            }
        }

        static void First(List<int> nums, string[] tokens)
        {
            int count = int.Parse(tokens[1]);
            string evenOrOdd = tokens[2];

            if (IsValidCount(nums, count))
            {
                if (evenOrOdd == "even")
                {
                    var evenNums = nums.Where(n => n % 2 == 0).Take(count).ToList();
                    Console.WriteLine($"[{string.Join(", ", evenNums)}]");
                }
                else if (evenOrOdd == "odd")
                {
                    var oddNums = nums.Where(n => n % 2 != 0).Take(count).ToList();
                    Console.WriteLine($"[{string.Join(", ", oddNums)}]");
                }
            }
        }

        private static bool IsValidCount(List<int> nums, int count)
        {
            if (count > nums.Count || count < 0)
            {
                Console.WriteLine("Invalid count");
                return false;
            }

            return true;
        }

        static void Min(List<int> nums, string[] tokens)
        {
            string evenOrOdd = tokens[1];

            if (evenOrOdd == "even")
            {
                int minEvenNumberIndex = GetIndexOfMinEvenNumber(nums);
                MinOrMaxCommandResult(minEvenNumberIndex);
            }
            else if (evenOrOdd == "odd")
            {
                int minOddNumberIndex = GetIndexOfMinOddNumber(nums);
                MinOrMaxCommandResult(minOddNumberIndex);
            }
        }

        static int GetIndexOfMinOddNumber(List<int> nums)
        {
            int index = -1;
            int minNumber = Int32.MaxValue;

            for (int i = 0; i < nums.Count; i++)
            {
                if (nums[i] % 2 != 0)
                {
                    var currentNumber = nums[i];
                    if (currentNumber <= minNumber)
                    {
                        minNumber = currentNumber;
                        index = i;
                    }
                }
            }

            return index;
        }

        static int GetIndexOfMinEvenNumber(List<int> nums)
        {
            int index = -1;
            int minNumber = Int32.MaxValue;

            for (int i = 0; i < nums.Count; i++)
            {
                if (nums[i] % 2 == 0)
                {
                    var currentNumber = nums[i];
                    if (currentNumber <= minNumber)
                    {
                        minNumber = currentNumber;
                        index = i;
                    }
                }
            }

            return index;
        }

        static void Max(List<int> nums, string[] tokens)
        {
            string evenOrOdd = tokens[1];

            if (evenOrOdd == "even")
            {
                int maxEvenNumberIndex = GetIndexOfMaxEvenNumber(nums);
                MinOrMaxCommandResult(maxEvenNumberIndex);

            }
            else if (evenOrOdd == "odd")
            {
                int maxOddNumberIndex = GetIndexOfMaxOddNumber(nums);
                MinOrMaxCommandResult(maxOddNumberIndex);
            }
        }

        static void MinOrMaxCommandResult(int index)
        {
            if (index == -1)
                Console.WriteLine("No matches");
            else
                Console.WriteLine(index);
        }

        static int GetIndexOfMaxOddNumber(List<int> nums)
        {
            int maxOddNumberIndex = -1;
            int maxOddNumber = 0;
            for (int i = 0; i < nums.Count; i++)
            {
                if (nums[i] % 2 != 0)
                {
                    var currentEvenNumber = nums[i];
                    if (currentEvenNumber >= maxOddNumber)
                    {
                        maxOddNumber = currentEvenNumber;
                        maxOddNumberIndex = i;
                    }
                }
            }

            return maxOddNumberIndex;
        }

        static int GetIndexOfMaxEvenNumber(List<int> nums)
        {
            int maxEvenNumberIndex = -1;
            int maxEvenNumber = 0;
            for (int i = 0; i < nums.Count; i++)
            {
                if (nums[i] % 2 == 0)
                {
                    var currentEvenNumber = nums[i];
                    if (currentEvenNumber >= maxEvenNumber)
                    {
                        maxEvenNumber = currentEvenNumber;
                        maxEvenNumberIndex = i;
                    }
                }
            }

            return maxEvenNumberIndex;
        }

        static void Exchange(List<int> nums, string[] tokens)
        {
            int index = int.Parse(tokens[1]);
            if (index < 0 || index > nums.Count - 1)
            {
                Console.WriteLine("Invalid index");
            }
            else
            {
                var skipElementsCnt = index + 1;

                var splittedNums = nums.Skip(skipElementsCnt).ToList();
                nums.RemoveRange(skipElementsCnt, nums.Count - 1 - index);
                nums.InsertRange(0, splittedNums);
            }
        }
    }
}