using System;

using System.Collections.Generic;

using System.Linq;

public class Program

{

    // data is an array of sorted arrays. The array of arrays represents the different storage accounts.

    // Each sorted array represents table data which is sorted by PK

    static int[][] data = new int[][] {

        new int[]{ 5, 10, 33, 45 },

        new int[]{ 3, 23, 44, 50, 700 },

        new int[]{ 7, 55, 105 }

    };

    static int[] expectedResult = new int[] { 5, 10, 33, 45, 3, 23, 44, 50, 700, 7, 55, 105 };

    public class MoreComplicatedArray

    {

        public const int BeginningResumeToken = 0;

        public const int FinishedResumeToken = -1;

        int[] arrayData;

        public MoreComplicatedArray(int[] data)

        {

            this.arrayData = data;

        }

        public (int[], int) GetItems(int resumeToken, int pageSize)

        {

            return (arrayData.AsSpan(resumeToken, Math.Min(pageSize, arrayData.Length-resumeToken)).ToArray(), 

                    resumeToken+pageSize <= arrayData.Length ? resumeToken+pageSize : -1);

        }

    }   

    static (int[], string) MoreComplicatedEnumerateWithResume(MoreComplicatedArray[] data, int batchSize, string resumeToken)

    {

        List<int> toReturn = new List<int>();

        int[] resumeInts = string.IsNullOrEmpty(resumeToken) ? new int[] {0, MoreComplicatedArray.BeginningResumeToken}

            : resumeToken.Split(':').Select( t => int.Parse(t)).ToArray();

        for(int i= 0; i < data.Length; i++)

        {

            if( i < resumeInts[0])

            {

                continue;

            }

            int arrayResume = resumeInts[0] == i ? resumeInts[1] : MoreComplicatedArray.BeginningResumeToken;

            while(arrayResume != MoreComplicatedArray.FinishedResumeToken)

            {

                int[] getData = null;

                (getData, arrayResume) = data[i].GetItems(arrayResume, 5);

                toReturn.AddRange(getData);

            }

        }

        return (toReturn.ToArray(), null);

        //throw new NotImplementedException();

    }

    // more ideas:

    //   randomly generate data, make sure without resume and with resume return the same data.

    //   try all page sizes and make sure they all return the same data

    public static void Main()

    {

        List<int> withResume = new List<int>();

        MoreComplicatedArray[] complicatedData = data

            .Select( ar => new MoreComplicatedArray(ar))

            .ToArray();

        int pageSize = 2;

        try

        {

            // null resume token means start at the beginning.

            string resume = null;

            int[] result = null;

            int guard = 10;

            while(true && guard > 0)

            {

                guard--;

                (result, resume) = MoreComplicatedEnumerateWithResume(complicatedData, pageSize, resume);

​

                Console.WriteLine($"{string.Join(',', result)}, {resume}");

​

                // Otherwise add "paged" data and resume when you left off

                withResume.AddRange(result);

​

                // EnumerateWithResume should return null for data once all data is enumerated.

                // or you could have a resume token that indicates enumeration is done

                // (but don't use null because that means start from the beginning!)

                if(resume == null) break;

            }

        }

        catch(Exception e)

        {

            Console.WriteLine($"Hit exception {e}");

        }

        Console.WriteLine($"{string.Join(',', withResume.ToArray())}");

        bool withResumeWorksProperly = Enumerable.SequenceEqual(expectedResult, withResume.ToArray());

        Console.WriteLine($"EnumerateAllWithResume successful: {withResumeWorksProperly}");

    }

}