LINQ projection, filtering, sorting and paging

// Three bookings hold seven passengers. The bookings are made up for this lesson.
Booking[] bookings =
[
    new("PNR-4521", "B2", [new("Asha", 34), new("Ravi", 36)]),
    new("PNR-4522", "B1", [new("Meera", 61), new("Kabir", 8), new("Isha", 33)]),
    new("PNR-4523", "B2", [new("Dev", 27), new("Zoya", 29)]),
];

// Select makes one result per booking: here each result is a whole list of passengers.
var lists = bookings.Select(b => b.Passengers);
Console.WriteLine($"Select: {lists.Count()} results, lists of {string.Join(", ", lists.Select(l => l.Count))} passengers");

// SelectMany makes one flat sequence of the lists' items, booking after booking.
var everyone = bookings.SelectMany(b => b.Passengers);
Console.WriteLine($"SelectMany: {everyone.Count()} results: {string.Join(", ", everyone.Select(p => p.Name))}");

// A second lambda receives the booking and each of its passengers, so the result can keep both.
var rows = bookings.SelectMany(b => b.Passengers, (b, p) => new { b.Pnr, b.Coach, p.Name, p.Age });

// Index() (.NET 9) pairs every item with its position, counted from 0.
Console.WriteLine("Numbered with Index():");
foreach (var (index, row) in rows.Index())
{
    Console.WriteLine($"  {index + 1}. {row.Name,-6} {row.Age,2}  coach {row.Coach}  {row.Pnr}");
}

// An anonymous type has no name, so it cannot leave the method: project into a record to return the rows.
List<Ticket> tickets = BuildTickets(bookings);
Console.WriteLine($"Tickets: {tickets.Count}, the first is {tickets[0]}");

static List<Ticket> BuildTickets(IEnumerable<Booking> bookings) =>
    bookings
        .SelectMany(b => b.Passengers, (b, p) => (b.Pnr, p.Name))
        .Select((pair, index) => new Ticket(index + 1, pair.Name, pair.Pnr))
        .ToList();

record Passenger(string Name, int Age);
record Booking(string Pnr, string Coach, List<Passenger> Passengers);
record Ticket(int No, string Name, string Pnr);

Select: 3 results, lists of 2, 3, 2 passengers
SelectMany: 7 results: Asha, Ravi, Meera, Kabir, Isha, Dev, Zoya
Numbered with Index():
  1. Asha   34  coach B2  PNR-4521
  2. Ravi   36  coach B2  PNR-4521
  3. Meera  61  coach B1  PNR-4522
  4. Kabir   8  coach B1  PNR-4522
  5. Isha   33  coach B1  PNR-4522
  6. Dev    27  coach B2  PNR-4523
  7. Zoya   29  coach B2  PNR-4523
Tickets: 7, the first is Ticket { No = 1, Name = Asha, Pnr = PNR-4521 }

// Filtering, sorting and paging the passengers of the three bookings.
Booking[] bookings =
[
    new("PNR-4521", "B2", [new("Asha", 34), new("Ravi", 36)]),
    new("PNR-4522", "B1", [new("Meera", 61), new("Kabir", 8), new("Isha", 33)]),
    new("PNR-4523", "B2", [new("Dev", 27), new("Zoya", 29)]),
];
var rows = bookings.SelectMany(b => b.Passengers, (b, p) => (b.Coach, p.Name, p.Age));

// Where keeps the items whose test is true: the adults.
var adults = rows.Where(r => r.Age >= 18);
Console.WriteLine($"Adults: {adults.Count()} of {rows.Count()}");

// OrderBy sorts by a key; ThenBy breaks ties with a second key: by coach, then by name within a coach.
var ordered = adults.OrderBy(r => r.Coach).ThenBy(r => r.Name);
Console.WriteLine($"By coach, then name: {string.Join(", ", ordered.Select(r => $"{r.Coach} {r.Name}"))}");

// Skip and Take cut one page out of the ordered rows.
const int size = 4;
for (int page = 1; page <= 3; page++)
{
    var onPage = ordered.Skip((page - 1) * size).Take(size).Select(r => r.Name).ToList();
    Console.WriteLine($"Page {page} (Skip({(page - 1) * size}).Take({size})): {(onPage.Count == 0 ? "empty" : string.Join(", ", onPage))}");
}

// Chunk cuts the whole sequence into arrays of the same size in one pass; the last one may be shorter.
foreach (var chunk in ordered.Chunk(size))
{
    Console.WriteLine($"Chunk of {chunk.Length}: {string.Join(", ", chunk.Select(r => r.Name))}");
}

record Passenger(string Name, int Age);
record Booking(string Pnr, string Coach, List<Passenger> Passengers);

Adults: 6 of 7
By coach, then name: B1 Isha, B1 Meera, B2 Asha, B2 Dev, B2 Ravi, B2 Zoya
Page 1 (Skip(0).Take(4)): Isha, Meera, Asha, Dev
Page 2 (Skip(4).Take(4)): Ravi, Zoya
Page 3 (Skip(8).Take(4)): empty
Chunk of 4: Isha, Meera, Asha, Dev
Chunk of 2: Ravi, Zoya

// Practice: write Best, Ranked and Page at the bottom so that every check passes, then run this file again.
// Nine quiz attempts by six learners; a learner may try more than once. The attempts are made up for this lesson.
Attempt[] attempts =
[
    new("Asha", 72), new("Ravi", 88), new("Asha", 91), new("meera", 88), new("Dev", 64),
    new("Ravi", 79), new("Zoya", 91), new("Kabir", 55), new("Asha", 85),
];

var checks = new List<(string Name, Func<string> Run, string Expected)>
{
    ("one row per learner", () => Best(attempts).Count().ToString(), "6"),
    ("Asha's best score", () => Best(attempts).Single(a => a.Learner == "Asha").Score.ToString(), "91"),
    ("Ravi's best score", () => Best(attempts).Single(a => a.Learner == "Ravi").Score.ToString(), "88"),
    ("page 1 of 3", () => string.Join(" | ", Page(Ranked(attempts), 1, 3)), "1. Asha 91 | 2. Zoya 91 | 3. meera 88"),
    ("page 2 of 4", () => string.Join(" | ", Page(Ranked(attempts), 2, 4)), "5. Dev 64 | 6. Kabir 55"),
    ("a page after the last one", () => string.Join(" | ", Page(Ranked(attempts), 3, 4)), ""),
    ("page 0", () => string.Join(" | ", Page(Ranked(attempts), 0, 4)), "ArgumentOutOfRangeException"),
};

int passed = 0;
foreach (var (name, run, expected) in checks)
{
    string got;
    try
    {
        got = run();
    }
    catch (Exception e)
    {
        got = e.GetType().Name;
    }
    string verdict = got == expected ? "ok" : $"FAIL, got \"{got}\"";
    if (verdict == "ok")
    {
        passed++;
    }
    Console.WriteLine($"{name}: {verdict}");
}
Console.WriteLine($"{passed} of {checks.Count} checks pass");
return passed == checks.Count ? 0 : 1;

// Each learner's best attempt, one attempt per learner.
static IEnumerable<Attempt> Best(IEnumerable<Attempt> attempts) =>
    throw new NotImplementedException("Put the highest scores first, then keep the first attempt of each learner.");

// "rank. Learner score" for every learner's best attempt: the highest score first, equal scores by name,
// ignoring upper and lower case, and ranks counted from 1.
static IEnumerable<string> Ranked(IEnumerable<Attempt> attempts) =>
    throw new NotImplementedException("Sort Best by score, then by name with a comparer, and number the rows with Select.");

// Page page (counted from 1) of size rows; a page before the first throws ArgumentOutOfRangeException.
static IEnumerable<string> Page(IEnumerable<string> rows, int page, int size) =>
    throw new NotImplementedException("Check page, then Skip the rows of the pages before it and Take one page.");

record Attempt(string Learner, int Score);

one row per learner: FAIL, got "NotImplementedException"
Asha's best score: FAIL, got "NotImplementedException"
Ravi's best score: FAIL, got "NotImplementedException"
page 1 of 3: FAIL, got "NotImplementedException"
page 2 of 4: FAIL, got "NotImplementedException"
a page after the last one: FAIL, got "NotImplementedException"
page 0: FAIL, got "NotImplementedException"
0 of 7 checks pass