/*

 * Welcome to the first Kampaay coding challenge!

​

​

You are requested to solve the quick assignments below, save your work and share the generated dotnetfiddle link with us by mail.

In case of any issue with dotnetfiddle, you can share directly the `.cs` file edited.

​

# PREMISE AND CONTEXT

​

You just started working in Kampaay and you are asked to complete a colleague's task about the retrieval and display in console 

(bottom panel of this view) of the drink list of our office cocktail bar (not yet there, but one day...).

​

You know there are some not-really-reliable services you can use (but you cannot modify at all!) to gather all needed drinks data 

and print them in your console: `DrinkLoaderServiceMock` and `PriceLoaderServiceMock`.

These mocked services sometimes (in a randomic way) throw an exception but since we cannot fix it, we should deal with it and do 

our best to mitigate this issue.

​

`DrinkLoaderServiceMock`'s method retrieves a list of tuple containing `Id` (a unique identifier) and `Name` (the cocktail's name).

Just one name can be associated to a drink.

​

`PriceLoaderServiceMock`'s method retrieves a list of tuple containing `Id` (a unique identifier, same as above) and `Price` 

(the cocktail's price). Multiple prices can be associated to the same drink.

​

From now on, we use `<className>.<methodName>()` to refer to a specific method (`methodName`) of a class (`className`) .

​

REMEMBER: 

- you can create new classes if needed, but DO NOT modify any predefined class unless explicitly requested in the assignments.

- before starting your code journey, fork this .netfiddle (button above, in menu bar). Yes, you will need an account .netfiddle for it.

- remember to SAVE often your work, especially before sharing it by mail! We suggest to test everything is fine by opening 

the URL in an incognito window: if you can see your last changes, then we'll be able too ;-)

​

​

************** Happy coding! ****************

​

​

# ASSIGNMENTS

​

1. Use the aforementioned services' async methods, to write the body of `DrinkList.LoadDrinks()` to build and return `Drink` class 

instances (in our Drink model we just have a single price associated to a drink, so we'll use the highest one associated to that 

drink id, returned by our price service).

​

2. Create a class named `DrinksExtensions` containing 2 extension methods for IEnumerable<Drink>: 

- `Sort` : it should accept a sort direction as parameter (Ascending or Descending) and return a new IEnumerable<Drink> sorted 

by `price` first, then by `name`: this means that when 2 drinks have the same price, (i.e: "Old Fashioned" and "Bloody Mary" 

have the same price, so "Bloody Mary" should precede "Old Fashioned" by alphabetical order).

- `Print`: parameterless method that prints in console every cocktail name and price formatting them this way: 

"<drinkName>: <price>€" (i.e: "Old Fashioned: 8€")

Use  those methods in `DrinkList.GetMenuAsync()` to sort gathered drinks and display them in console.

​

NOTE: you can read sometimes "data load failed!" in console because our services are (as already told) not-really-reliable ¯\_(ツ)_/¯ 

...but that's ok.

​

3. Complete `DrinkList` implementation. 

- when triggered, `SetFilter()` should set the string parameter as filtering criteria (`GetMenuAsync()` should filter just 

drinks whose name contains that string)

- when triggered, the parameterless `ToggleOrder()` should reverse the sorting (from ascending to descending and vice-versa)

- in `GetMenuAsync()` print the details of the cheapest drink (use same formatting defined above for `DrinksExtensions.Print()`)

​

Ok, we got it...but we detect too many data gathering errors in our services.... 

​

4. (BONUS) ...and, even if we cannot modify them...we can retry data load 5 time when failed and reduce the error rate and the 

annoying "service data load failed!" message in our console.

​

Please be as clean as possible in your implementation and optimize for performances.

​

​

# CONSOLE OUTPUT

​

one of the possible outputs we could obtain is the following:

​

******************  Console output (panel below) ********************** 

​

    FIRST MENU LOAD

    💣💣💣  Sorry, we could not load Kampaay drink list because of network errors 💣💣💣 

    SECOND MENU LOAD

    *** KAMPAAY BAR DRINK LIST ***

    Margarita: 12€

    Manhattan: 10€

    Bloody Mary: 8€

    cheapest drink is Bloody Mary: 8€

    THIRD MENU LOAD

    💣💣💣  Sorry, we could not load Kampaay drink list because of network errors 💣💣💣 

​

******************  End console output (panel below) ****************** 

​

 */

​

#nullable enable

​

using System;

using System.Linq;

using System.Collections.Generic;

using System.Threading.Tasks;

​

namespace Test;

​

public class DrinkList

{

    private ILoaderService<(int Id, string Name)> DrinkService { get; set; }

    private ILoaderService<(int Id, int Price)> PriceService { get; set; }

    public DrinkList()

    {

        DrinkService = new DrinkLoaderServiceMock();

        PriceService = new PriceLoaderServiceMock();

    }

    //reverse order DrinkList

    public void ToggleOrder() {

        Console.WriteLine("drinkList reversed: ");

        List<(int Id, string Name)> drinkList = DrinkService.LoadAsync().Result;

        drinkList.Reverse();

        foreach(var drink in drinkList)         

            Console.WriteLine(drink.Name);

        Console.WriteLine("\n");

    }

    //case Sensitive

    public void SetFilter(string? containedString) {

        Console.WriteLine("drinks filter by '" + containedString + "' are: ");

        foreach(var drink in DrinkService.LoadAsync().Result)

        {

            if (containedString != null && drink.Name.Contains(containedString))

            {

                Console.WriteLine(drink.Name);

            }

        }

        Console.WriteLine("\n");    

    }

    private Task<IEnumerable<Drink>> LoadDrinksAsync()

    {

        List<(int Id, string Name)> drinkList = DrinkService.LoadAsync().Result;

        List<(int Id, int Price)> priceList = PriceService.LoadAsync().Result;

        List<Drink> drinkListTmp = new List<Drink>();

        int tmpPrice = 0;

        //loop between all drinks and all prices

        foreach(var drink in drinkList)

        {

            foreach(var price in priceList)

            {

                //in case there are multiple prices for the same ID, we take the higher one

                if (drink.Id == price.Id && (tmpPrice == 0 || tmpPrice < price.Price))

                    tmpPrice = price.Price;

            }

            drinkListTmp.Add(new Drink(drink.Name, tmpPrice));

            tmpPrice = 0;

        }

        //cast to IEnumerable

        IEnumerable<Drink>? result = drinkListTmp;

        //return as Task<IEnumerable<Drink>?>

        return Task.Run(()=>

        {

            return result;

        });

    }

    public async Task GetMenuAsync() {

        var drinks = await LoadDrinksAsync();

        if (drinks == null)

        {

            Console.WriteLine("💣💣💣  Sorry, we could not load Kampaay drink list because of network errors 💣💣💣 ");

        } else {

            // TODO: filter and sort drinks

            DrinksExtensions de = new DrinksExtensions();

            drinks = de.Sort(drinks, "DESC");

            Console.WriteLine("🎉🎉🎉 KAMPAAY BAR DRINK LIST 🎉🎉🎉");

            // TODO: print the list of drinks

            de.Print(drinks);

            // TODO: print the details of the cheapest drink

            de.PrintCheapest(drinks);           

        }        

        Console.WriteLine();

    }

}

​

public class Drink

{

    public string Name { get; set; }

    public int Price { get; set; }

    public Drink(string name, int price) 

    {

        Name = name;

        Price = price;

    }

}

​

public class DrinksExtensions 

{

    //method to sort drinks, based on "order" parameter

    public IEnumerable<Drink> Sort(IEnumerable<Drink> drinkList, string order)

    {

        if (order.ToUpper() == "ASC")

        {

            drinkList = drinkList.OrderBy(drink => drink.Price).ThenBy(drink => drink.Name);

        }

        if (order.ToUpper() == "DESC")

        {

            drinkList = drinkList.OrderByDescending(drink => drink.Price).ThenByDescending(drink => drink.Name);

        }

        return drinkList;

    }

    //method to print the ordered Drink list

    public void Print(IEnumerable<Drink> drinkList)

    {

        foreach(var drink in drinkList)         

            Console.WriteLine(drink.Name + ": " + drink.Price + "€");

    }

    public void PrintCheapest(IEnumerable<Drink> drinkList)

    {

        //we sort the drinkList by price, then we print the first

        drinkList = Sort(drinkList, "ASC");

        Console.WriteLine("cheapest drink is " + drinkList.First().Name + ": " + drinkList.First().Price + "€");

    }

}

​

/*********************************************************************************************************

 * WARNING: DO NOT modify code below!

 * Please implement all your code above this separator

 *********************************************************************************************************/

​

public interface ILoaderService<TData> {

    Task<List<TData>> LoadAsync();

}

​

public abstract class LoaderService<TData> : ILoaderService<TData> {

    private readonly Random _rnd = new Random();

    protected async Task<List<TData>> EmulateNetworkAsync(List<TData> mock){

        var delay = _rnd.Next(-50, 100);

        await Task.Delay(Math.Abs(delay));

        if(delay < 0) {

            throw new Exception("💣💣💣 service data load failed!");

        }

        return mock;

    }

    public abstract Task<List<TData>> LoadAsync();

}

​

​

public class DrinkLoaderServiceMock : LoaderService<(int Id, string Name)> {

    public override Task<List<(int Id, string Name)>> LoadAsync() 

        => EmulateNetworkAsync(new List<(int Id, string Name)>() {

            ( 1, "Manhattan" ),

            ( 3, "Margarita" ),

            ( 2, "Old Fashioned" ),

            ( 4, "Bloody Mary" ),

        }) ;

}

​

public class PriceLoaderServiceMock : LoaderService<(int Id, int Price)>  {

    public override Task<List<(int Id, int Price)>> LoadAsync() 

        => EmulateNetworkAsync(new List<(int Id, int Price)>() {

            ( 4, 8 ),

            ( 3, 12 ),

            ( 1, 10 ),

            ( 4, 8 ),

            ( 1, 7 ),

            ( 2, 8 ),

            ( 4, 5 ),

        });

}

​

​

public class Program

{

    public static async Task Main()

    {

        var drinkList = new DrinkList();

        Console.WriteLine("FIRST MENU LOAD");

        await drinkList.GetMenuAsync();

        drinkList.SetFilter("M");

        drinkList.ToggleOrder();

        Console.WriteLine("SECOND MENU LOAD");

        await drinkList.GetMenuAsync();

        drinkList.SetFilter("a");

        drinkList.ToggleOrder();

​

        Console.WriteLine("THIRD MENU LOAD");

        await drinkList.GetMenuAsync();

    }   

}

​

​