using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

class SampleProgram
{
    static void Main(string[] args)
    {
        //Fügen eine neuen Kaffee hinzu, obwohl diese Liste bereits gefüllt wurde, d.h. in diesem Fall ist lolli nur ein Alias für Kroenungs
        CoffeeFactory.Jacobs.Invent<KroenungsCoffee>("lolli");

        do
        {
            Console.Write("Bitte Wahl eingeben: ");
            var coffeeKind = Console.ReadLine();

            var coffee = CoffeeFactory.Jacobs.Brew(coffeeKind);
        } while (true);
    }
}

class CoffeeFactory
{
    #region Singleton

    static CoffeeFactory jacobs;

    public static CoffeeFactory Jacobs
    {
        get { return jacobs ?? (jacobs = new CoffeeFactory()); }
    }

    #endregion

    Dictionary<String, Type> coffeeKinds;

    private CoffeeFactory()
    {
        coffeeKinds = new Dictionary<String, Type>();
        //Wir füllen dieses Dictionary bereits mit einigen Einträgen
        PopulateCoffees();
    }

    void PopulateCoffees()
    {
        //Nehmen die Einträge aus der aktuellen Bibliothek
        var types = Assembly.GetExecutingAssembly()
            .GetTypes() //Schauen uns alle Typen an
            .Where(m => !m.IsAbstract && m.IsSubclassOf(typeof(CoffeeKind))); //Nehmen nur die, die nicht Abstrakt sind und vom Typ CoffeeKind erben

        foreach (var type in types)
        {
            //Diese fügen wir mit der Konvention, dass einfach Coffee im Namen durch nichts ersetzt wird, hinzu
            coffeeKinds.Add(type.Name.Replace("Coffee", String.Empty), type);
        }
    }

    public void Invent<T>(String kind)
        where T : CoffeeKind
    {
        //Ausnutzen von Generics um eine coolere Übergabe zu erhalten
        coffeeKinds.Add(kind, typeof(T));
        Console.WriteLine("Es wurde was erfunden: " + kind);
    }

    public CoffeeKind Brew(String kind)
    {
        if (coffeeKinds.ContainsKey(kind))
        {
            var type = coffeeKinds[kind];
            //Holen uns einen leeren Standardkonstruktor vom Typen
            var ctor = type.GetConstructor(Type.EmptyTypes);

            //Gibts so einen ? Falls ja:
            if (ctor != null)
            {
                Console.WriteLine("Hier bitte! Dein Kaffee ist fertig.");
                Console.WriteLine("zzzz (" + kind + ")");
                //Aufruf des Konstruktors und Rückgabe als CoffeeKind
                return ctor.Invoke(null) as CoffeeKind;
            }
        }

        Console.WriteLine("Deine Wahl war schlecht. Das haben wir nicht im Angebot!");
        return null;
    }
}

abstract class CoffeeKind
{
}

class EspressoCoffee : CoffeeKind
{
}

class LatteCoffee : CoffeeKind
{
}

class KroenungsCoffee : CoffeeKind
{
}