Многофазной сортировке

Помогите дописать метод слития файлов для Многофазной сортировки. Есть метод распределения элементов GetDistributedSeries, который распределяет серии по файлом, согласно принципам многофазной сортировки и возвращает массив с количеством фиктивных серий для каждого файла (индекс - номер файла, значение - количество фиктивных серий). Нужно реализовать метод, который будет сливать файлы в пустой до тех пор, пока один из них не вычитается полностью, затем сливание уже пойдет в файл, который вычитался. И так пока у нас в одном из файлов не образуется упорядоченный массив. Теперь про пустые серии. Если фиктивные серии мы имеем на всех файлах, то по сути, мы ничего не делаем , а просто уменьшаем значение фиктивных серий в массиве, и прибавляем 1 к индексу файла в массиве, в который мы сливаем. Если же мы сливаем фиктивные серии с обычными, то это значит, что мы по сути пропускаем одно слитие серии для файла с пустой серией и не забываем уменьшать значение в массиве.

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

namespace ConsoleApp1
{
    internal class PolyPhase
    {
        private int helpAmount = 4;

        public int ReadHelpFiles { get { return helpAmount; } }

        public string[] CreateHelpFile(string helpDirectoryPath)
        {
            string[] filePaths = new string[ReadHelpFiles];

            try
            {
                for (int i = 0; i < ReadHelpFiles; i++)
                {
                    string fileName = $"helpFile{i + 1}.txt";
                    string filePath = Path.Combine(helpDirectoryPath, fileName);
                    using (FileStream fileStream = File.Create(filePath)) { }

                    filePaths[i] = filePath;
                }
            }
            catch (Exception ex)
            {
                
            }

            return filePaths;
        }

        private List<int> GetPerfectSequence(List<int> a)
        {
            List<int> newA = new List<int>();
            for (int i = 0; i < a.Count - 1; i++)
            {
                newA.Add(a[i + 1] + a[0]);
            }
            newA.Add(0);

            return newA;
        }

        private List<int> SeriesCounter(List<int> a)
        {
            List<int> d = new List<int>();
            for (int k = 0; k < a.Count - 1; k++)
            {
                d.Add(a[k + 1] - a[k] + a[0]);
            }
            d.Add(0);

            return d;
        }

        public List<int> GetDistributedSeries(string mainPath, string[] helpFilePaths)
        {
            if (!File.Exists(mainPath) || helpFilePaths.Any(path => !File.Exists(path)))
            {
                
                return null;
            }

            List<int> a = new List<int>();
            List<int> d = new List<int>();

            int readHelpFiles = helpFilePaths.Length;
            for (int i = 0; i < readHelpFiles - 1; i++)
            {
                a.Add(1);
                d.Add(1);
            }
            a.Add(0);
            d.Add(0);

            List<int> fictionalSeries = new List<int>();
            int currentIndex = 0;
            List<int> input = new List<int>();

            try
            {
                var fileContent = File.ReadAllLines(mainPath);
                foreach (var line in fileContent)
                {
                    if (int.TryParse(line, out int number))
                    {
                        input.Add(number);
                    }
                    else
                    {
                        
                    }
                }
            }
            catch (Exception ex)
            {
                
                return null;
            }

            try
            {
                File.Delete(mainPath);
            }
            catch (Exception ex)
            {
                
                return null;
            }

            try
            {
                while (d.Any(x => x > 0) && currentIndex < input.Count)
                {
                    for (int i = 0; i < d.Count; i++)
                    {
                        using (StreamWriter sw = new StreamWriter(helpFilePaths[i], true))
                        {
                            while (d[i] > 0 && currentIndex < input.Count)
                            {
                                int seriesStartIndex = currentIndex;

                                while (currentIndex < input.Count - 1 && input[currentIndex] <= input[currentIndex + 1])
                                {
                                    currentIndex++;
                                }

                                for (int j = seriesStartIndex; j <= currentIndex; j++)
                                {
                                    sw.WriteLine(input[j]);
                                }

                                currentIndex++;
                                d[i]--;

                                for (int k = 0; k < d.Count; k++)
                                {
                                    fictionalSeries.Add(d[k]);
                                }
                            }

                            if (d[i] == 0 && i == d.Count - 1)
                            {
                                d = SeriesCounter(a);
                                a = GetPerfectSequence(a);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                return null;
            }

            int countToRemove = fictionalSeries.Count - 4;
            if (countToRemove > 0)
            {
                fictionalSeries.RemoveRange(0, countToRemove);
            }

            return fictionalSeries;
        }
    }
}