using System.Collections.Generic;

using System.Linq;

public class Program

{

    public static void Main()

    {

        var records = new List<Foo>() {

            new Foo(1, 1),

            new Foo(2, 1),

            new Foo(3, 1),

            new Foo(4, 2),

            new Foo(5, 2),

            new Foo(6, 3),

            new Foo(7, 4),

            new Foo(8, 5),

            new Foo(9, 6),

            new Foo(10, 7),

        };

        const int maxPerGroup = 3;

        var groups = records

            // Find and group all the Foo's that cannot be in the same collection.

            .GroupBy(r => r.GroupId) 

            // For each Foo with the same Group id, assign an index by its position.

            // This will be used in the next step to assign same-groupid foos to different buckets.

            .SelectMany(g => g.Select((r, i) => new {

                Bucket = i,

                Record = r

            }))

            // As mentioned above, assign phobic Foos to different buckets.

            .GroupBy(g => g.Bucket, p => p.Record)

            // Below is not *technically* necessary if `records` enumerable can be enumerated multiple times,

            // but I don't make that assumption. This converts items to an array so we can enumerate it more than once below.

            .Select(g => g.ToArray())

            // Now take each bucket and split it into members that fit and overflows, if any.

            .Select(b => new {

                Members = b.Take(maxPerGroup),

                Overflows = b.Skip(maxPerGroup)

            })

            // Via aggregation, go thru all buckets keeping them, but picking off their overflows into one signle overflow collection.

            // Further processing is actually nexted in projection argument of the aggregate since

            // aggregate wants to return a single item, and that's not what we need.

            .Aggregate(

                new { Groups = new List<IEnumerable<Foo>>(), Overflows = new Queue<Foo>()},

                (acc, next) => {

                    acc.Groups.Add(next.Members);

                    foreach(var o in next.Overflows)

                        acc.Overflows.Enqueue(o);

                    return acc;

                },

                // Here we have all buckets and a single overflow queue, now go thru each bucket and fill it up from overflow if it has any space left.

                t => t.Groups.Aggregate(

                    new { Groups = new List<IEnumerable<Foo>>(), Overflows = t.Overflows },

                    (dist, next) => {

                        var currentGroupMembers = next.ToList();

                        while (currentGroupMembers.Count() < maxPerGroup && dist.Overflows.Count > 0)

                            currentGroupMembers.Add(dist.Overflows.Dequeue());

                        dist.Groups.Add(currentGroupMembers);

                        return dist;

                    },

                    // And by the time we get here, we filled all existing buckets, but may have things left in overflow.

                    // So just chunk up overflow and add it to our list of buckets.

                    t2 => {

                        t2.Groups.AddRange(t2.Overflows.Chunk(maxPerGroup));

                        // And that returns the final result.

                        return t2.Groups;

                    }

                )

            )

            // This is not really necessary, but helps to see in memory with debugging.

            .ToArray();

        for (int i = 0; i < groups.Count(); ++i) {

            System.Console.WriteLine($"Group {i}: {Newtonsoft.Json.JsonConvert.SerializeObject(groups[i])}");

        }

    }

    public class Foo {

        public int Id;

        public int GroupId;

        public Foo(int id, int groupId) {

            this.Id = id;

            this.GroupId = groupId;

        }

    }

}