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 };

    // Enumerate all should return all of the integers in the input as an array

    static int[] EnumerateAll(int[][] toEnumerate)

    {

        throw new NotImplementedException();

    }

    // Enumerate all with resume should return batchSize integers in the array starting

    // where the resume token specifies. 

    static (int[], string) EnumerateWithResume(int[][] data, int batchSize, string resumeToken)

    {

        throw new NotImplementedException();

    }

    public class MoreComplicatedArray

    {

        int[] arrayData;

        public MoreComplicatedArray(int[] data)

        {

            this.arrayData = data;

        }

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

        {

            return (arrayData.AsSpan(resumeToken, pageSize).ToArray(), resumeToken+pageSize);

        }

    }

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

    {

        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> withoutResume = new List<int>();

        try 

        {

            withoutResume.AddRange(EnumerateAll(data));

        }

        catch(Exception e)

        {

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

        }

        bool withoutResumeWorksProperly = Enumerable.SequenceEqual(expectedResult, withoutResume);

        Console.WriteLine($"EnumerateAll successful: {withoutResumeWorksProperly}");

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

        int pageSize = 2;

        try

        {

            // null resume token means start at the beginning.

            string resume = null;

            int[] result = null;

            while(true)

            {

                (result, resume) = EnumerateWithResume(data, pageSize, resume);

​

                // 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(result == null) break;

​

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

                withResume.AddRange(result);

            }

        }

        catch(Exception e)

        {

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

        }

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

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

    }

}