using System;

using System.Threading;

using System.Threading.Channels;

using System.Threading.Tasks;

using System.Collections.Generic;

using System.Linq;

​

public record DrinkOrder

{

    public string CustomerName { get; init; }

    public string DrinkType { get; init; }

    public Channel<string> Complete { get; init; }

}

​

public class CoffeeShop

{

    private readonly Channel<DrinkOrder> _orders = Channel.CreateUnbounded<DrinkOrder>();

    private readonly Channel<DrinkOrder> _grinding = Channel.CreateBounded<DrinkOrder>(1);

    private readonly Channel<DrinkOrder> _espresso = Channel.CreateBounded<DrinkOrder>(2);

    private readonly Channel<DrinkOrder> _steaming = Channel.CreateBounded<DrinkOrder>(2);

    private readonly Channel<DrinkOrder> _finished = Channel.CreateUnbounded<DrinkOrder>();

​

    private async Task GrindBeansAsync()

    {

        while (await _grinding.Reader.WaitToReadAsync())

        {

            if (await _grinding.Reader.ReadAsync() is DrinkOrder order)

            {

                Console.WriteLine($"Grinding beans for {order.CustomerName}'s {order.DrinkType}");

                await Task.Delay(1000); // Grinding takes 1 second

​

                if (order.DrinkType == "Filter")

                {

                    await _finished.Writer.WriteAsync(order);

                }

                else

                {

                    await _espresso.Writer.WriteAsync(order);

                }

            }

        }

    }

​

    private async Task MakeEspressoAsync()

    {

        while (await _espresso.Reader.WaitToReadAsync())

        {

            if (await _espresso.Reader.ReadAsync() is DrinkOrder order)

            {

                Console.WriteLine($"Making espresso for {order.CustomerName}'s {order.DrinkType}");

                await Task.Delay(1000); // Espresso takes 1 second

​

                if (!NeedsMilk(order.DrinkType))

                {

                    await _finished.Writer.WriteAsync(order);

                }

                else

                {

                    await _steaming.Writer.WriteAsync(order);

                }

            }

        }

    }

​

    private async Task SteamMilkAsync()

    {

        while (await _steaming.Reader.WaitToReadAsync())

        {

            if (await _steaming.Reader.ReadAsync() is DrinkOrder order)

            {

                Console.WriteLine($"Steaming milk for {order.CustomerName}'s {order.DrinkType}");

                await Task.Delay(1000); // Steaming takes 1 second

                await _finished.Writer.WriteAsync(order);

            }

        }

    }

​

    private async Task ServeOrdersAsync()

    {

        while (await _finished.Reader.WaitToReadAsync())

        {

            if (await _finished.Reader.ReadAsync() is DrinkOrder order)

            {

                Console.WriteLine($"✓ {order.CustomerName}'s {order.DrinkType} is ready!");

                await order.Complete.Writer.WriteAsync("done");

            }

        }

    }

​

    private async Task ProcessOrdersAsync()

    {

        while (await _orders.Reader.WaitToReadAsync())

        {

            if (await _orders.Reader.ReadAsync() is DrinkOrder order)

            {

                Console.WriteLine($"Starting {order.CustomerName}'s {order.DrinkType}");

                await _grinding.Writer.WriteAsync(order);

            }

        }

​

        // Close all channels when orders are done

        _grinding.Writer.Complete();

        _espresso.Writer.Complete();

        _steaming.Writer.Complete();

        _finished.Writer.Complete();

    }

​

    private bool NeedsMilk(string drinkType) => drinkType switch

    {

        "Black Coffee" => false,

        "Filter" => false,

        _ => true

    };

​

    public async Task StartAsync(int grinders = 1, int espressoMachines = 2, int steamers = 2)

    {

        // Start grinders

        for (int i = 0; i < grinders; i++)

            _ = GrindBeansAsync();

​

        // Start espresso machines

        for (int i = 0; i < espressoMachines; i++)

            _ = MakeEspressoAsync();

​

        // Start milk steamers

        for (int i = 0; i < steamers; i++)

            _ = SteamMilkAsync();

​

        // Start server

        _ = ServeOrdersAsync();

​

        // Start order processor

        _ = ProcessOrdersAsync();

    }

​

    public async Task OrderDrinkAsync(string customerName, string drinkType)

    {

        var complete = Channel.CreateUnbounded<string>();

        var order = new DrinkOrder

        {

            CustomerName = customerName,

            DrinkType = drinkType,

            Complete = complete

        };

​

        Console.WriteLine($"{customerName} ordered a {drinkType}");

        await _orders.Writer.WriteAsync(order);

        await complete.Reader.ReadAsync(); // Wait for completion

    }

}

​

public class Program

{

    public static async Task Main()

    {

        var shop = new CoffeeShop();

        await shop.StartAsync(grinders: 1, espressoMachines: 2, steamers: 2);

​

        var orders = new List<Task>

        {

            shop.OrderDrinkAsync("Alice", "Latte"),

            shop.OrderDrinkAsync("Bob", "Cappuccino"),

            shop.OrderDrinkAsync("Charlie", "Filter"),

            shop.OrderDrinkAsync("Dave", "Black Coffee"),

            shop.OrderDrinkAsync("Eve", "Latte Macchiato")

        };

​

        await Task.WhenAll(orders);

        Console.WriteLine("All orders complete!");

    }

}