/**
 * You can edit, run, and share this code.
 * play.kotlinlang.org
 */
fun main() {
    println("Hello, world!!!")
    var neuerTyp: Any = 42
    
    println(neuerTyp::class.simpleName)
    
    neuerTyp = "String 42"
    
    println(neuerTyp::class.simpleName)
    
    var x ="10"
    
    x += 10
	
    println(x)
    x.chars().forEach { aChar ->
        println(aChar)
    }
    
    x.chars().forEach {
        println(it)
    }
    
    for (c in x.chars()) {
        println(c)
    }
    
    var p = 1 to "23"
	println(p::class.simpleName)
    
    var r = 6 downTo 0 step 2
    for (i in r) {
    	println(i)
    }
    println(r::class.simpleName)
    
    testIsEven()
}

fun isEven(x: Int): Boolean {
    return x % 2 == 0
}

fun testIsEven() {
    for (i in 1..3) {
        // println("$i is ${isEven(i) ? 1 : 2}")
        println("$i is ${if (isEven(i)) "even" else "odd"}")
    }
}

fun literale() {
    var s = "String Literal"
    var n = 3.41
    var r = 1..42
    var p = "key" to 24
    
	var a = mutableListOf(1,2,3,4)
    //var a1 = (1,2,3)
//    var a2 = [1,2,3]
//    var d = ["key" of 1, "key2" of 2]
}

/**
 * Übungsaufgabe: Autovermietung
 * https://gist.github.com/innicovation21/adc40fa1f502093a1e8e6b3b6b113860#%C3%BCbungsaufgabe-autovermietung
 */

class Autovermietung (
 	val filialLeiter: String,
    val standort: String
) {
    var anzahlAuto: UInt
    get() {
        println("getting anzahlAuto $field")
        return field
    }
    
    val info: String
    // Das geht nicht: `info` wird erst in `init` initialisiert
    // val info1 = info
    // Das geht nicht: `info3` wird erst unten initialisiert
    // val info2 = info3
    val info3 = "Leitung: $filialLeiter, Standort: $standort"
    var info4 = info3	// ok: `info` ist schon initialisiert
    
    get() {
        println("getting info4 $field")
        return field
    }
    
    set(wert) {
        field = wert
        println("setting info4 $field")
    }
    
    private val farbe: String = "rot"
    public fun getFarbe(): String {
        println("getting farbe $farbe")
        return farbe
    }
    
    fun getWert(): Any {
        return 1
    }
    
    
    constructor(x: UInt) : this("Leiter", "Ort") {
        println("-> second constructor")
        anzahlAuto = x
    }
    
    init {
        println("-> init")
        info = "Leitung: $filialLeiter, Standort: $standort"
        anzahlAuto = 0u
    }
    
    /**
     * Gibt ein Auto zurück in die Autovermietung.
     * Erhöht die Anzahl der verfügbaren Autos.
     */
    fun autoAbstellen(anzahl: UInt = 1u) {
        anzahlAuto += anzahl
    }
    
    /**
     * Vermietet ein Auto.
     * Verringert die Anzahl der verfügbaren Autos und gibt eine Bestätigungsnachricht aus.
     */
    fun autoRausgeben(anzahl: UInt = 1u) {
        if (anzahl > anzahlAuto) {
            anzahlAuto = 0u
        } else {
	        anzahlAuto -= anzahl
        }
        println("Aktueller Bestand:")
        println("$anzahlAuto Autos")
        println()
    }
    
    /**
     * Gibt den Namen des Filialleiters, Standort und die Anzahl der verfügbaren Autos aus
     */
    fun infoFiliale() {
        println("Filial-Info")
        println("$info, Anzahl: $anzahlAuto")
        println()
    }
}


fun main() {
    val filiale = Autovermietung("Max Mannmuster", "Berlin")	// Teilaufgabe 1 und 2
    filiale.autoAbstellen(2u)	// Teilaufgabe 3
    filiale.infoFiliale()		// Teilaufgabe 4
    filiale.autoRausgeben()		// Teilaufgabe 5
    filiale.infoFiliale()		// Teilaufgabe 6
    
    val filiale2 = Autovermietung(10u)
    filiale2.infoFiliale()
    
    var info = filiale2.info4
    filiale2.info4 = "keine Info"
    var anzahl = filiale2.anzahlAuto
    var farbe = filiale2.getFarbe()
}

/**
 * Übungsaufgabe:
 * 
 * Erstelle eine Klasse namens Fahrzeug mit den Eigenschaften name und geschwindigkeit,
 * 	sowie der Methode beschleunigen() (in dieser Methode soll ein beliebiger Text ausgegeben werden)
 * Erstelle eine weitere Klasse namens Auto. Neben den Eigenschaften name und geschwindigkeit, 
 * 	hat diese Klasse desweiteren die Eigenschaft anzahlSitze
 * Außerdem soll die Klasse Auto eine abgewandelte Form der Methode beschleunigen() beinhalten, 
 * 	bei welcher die Anzahl der Sitze zusätzlich erwähnt wird.
 * Erstelle eine dritte Klasse namens Rennwagen. Neben den Eigenschaften name, 
 * 	geschwindigkeit und anzahlSitze, soll es hier noch die Eigenschaft rennstrecke geben.
 * Außerdem soll die Klasse Rennwagen eine Methode namens rennenFahren() beinhalten, welche ausgibt,
 *  auf welcher Rennstrecke gerade gefahren wird.
 */

open class Fahrzeug(n: String, g: UInt) {
    val name: String = n
    var geschwindigkeit: UInt = g
    
    open fun beschleunigen() {
        println("Fahrzeug auf $geschwindigkeit Sachen beschleunigt.")
    }
}

open class Auto(val anzahlSitze: UInt, name: String, geschwindigkeit: UInt) : Fahrzeug(name, geschwindigkeit) {
    override fun beschleunigen() {
        println("Auto beschleunigt $anzahlSitze Sitze auf $geschwindigkeit Sachen.")
    }
}

class Rennwagen(val rennstrecke: String, anzahlSitze: UInt, name: String, geschwindigkeit: UInt) : Auto(anzahlSitze, name, geschwindigkeit) {
	fun rennenFahren() {
        println("Rennwagen fährt ein $rennstrecke Rennen.")
    }
}


fun main() {
    val rw = Rennwagen("Nürburg-Ring", 2u, "FZ-Name", 250u)
    rw.rennenFahren()
    rw.beschleunigen()
}

/**
 * Übungsaufgabe
 * 
 * Aufgabe: Erstellen Sie ein Interface mit dem Namen Playable, das eine Methode namens play() und 
 * eine Eigenschaft namens duration definiert.
 * Implementieren Sie dann zwei Klassen, Song und Podcast, die das Playable-Interface implementieren.
 * Song sollte eine private Eigenschaft namens title und Podcast eine private Eigenschaft namens episode.
 * 
 * Hinweise:
 *  - Die Klasse Song sollte eine Methode showTitle() haben, die den Titel des Songs zurückgibt.
 *  - Die Klasse Podcast sollte eine Methode showEpisode() haben, die die Episodennummer des Podcasts zurückgibt.
 *  - Beide Klassen sollten die play-Methode implementieren und eine Konsolenausgabe erzeugen, die angibt, dass der Song bzw. der Podcast abgespielt wird und wie lange die Spielzeit ist.
 */

interface Playable {
    val duration: Int
    fun play()
}


class Song(
    override val duration: Int,
    val title: String
) : Playable {
    
    override fun play() {
        println("Playing title '$title', $duration sec.")
    }
    
    fun showTitle() {
        println("Title: $title")
    }
}


class Podcast(
    override val duration: Int,
    val episode: String
) : Playable {
    
    override fun play() {
        println("Playing episode '$episode', $duration sec.")
    }
    
    fun showEpisode() {
        println("Episode: $episode")
    }
}


fun main() {
    val song = Song(240, "Lieblingslied")
    val podcast = Podcast(345, "Beitrag vom 15.02.2024")
    
    song.showTitle()
    song.play()
    
    podcast.showEpisode()
    podcast.play()
}

/**
 * Übungsaufgabe:
 * 
 * Erstelle eine Klasse namens MathUtils, die verschiedene mathematische Hilfsfunktionen bereitstellt.
 * Implementiere ein Companion Object, das eine Methode zur Berechnung der Summe einer Liste von Zahlen
 * enthält UND das eine Methode zur Berechnung des Durchschnitts einer Liste von Zahlen enthält.
 * 
 * Die Methode zur Summenberechnung soll den Namen summary() haben und eine Liste von Zahlen als
 * Parameter akzeptieren. Die Menge der Zahlen in der Liste und deren Summe ausgeben.
 * 
 * Die Methode zur Durchschnittsberechnung soll den Namen average() haben und eine Liste von Zahlen
 * als Parameter akzeptieren. Sie soll den Durchschnitt der Zahlen berechnen und zurückgeben.
 * 
 * Verwende beide Funktionen und wende sie auf eine Liste von Ganzzahlen an.
 */


class MathUtils {
    
    companion object {
        
		fun summary(l: List<Int>) = l.reduce {res, num -> res + num}
		
        fun summary1(l: List<Int>): Int {
            return l.reduce {res, num -> res + num}
        }
        
        fun average(l: List<Int>) = summary(l) / l.size
        
    }
}

fun main() {
    val zahlenListe = listOf(1, 3, 5)
    println("Summe von $zahlenListe ist ${MathUtils.summary(zahlenListe)}")
    println("Durchschnittswert von $zahlenListe ist ${MathUtils.average(zahlenListe)}")
}

/**
 * Übungsaufgabe: Schliessfach
 * 
 * Erstelle eine Klasse mit dem Namen "Schliessfach", um ein Schliessfachobjekt zu repräsentieren.
 * 
 * Die Klasse soll folgende Eigenschaften und Funktionen haben:
 * - nummer (privat): Eine eindeutige Nummer, die das Schließfach identifiziert.
 * - besetzt (privat): Ein Boolean-Wert, der angibt, ob das Schließfach besetzt ist oder nicht.
 * - belegeSchließfach(): Eine Funktion, die das Schließfach belegt.
 * - leereSchließfach(): Eine Funktion, die das Schließfach leert.
 * - istBesetzt(): Eine Funktion, die überprüft, ob das Schließfach besetzt ist oder nicht.
 * 
 * Implementiere die Klasse entsprechend der oben genannten Anforderungen und verwende geeignete
 * Datentypen für die Eigenschaften.
 * 
 * Zusatzaufgabe:
 * 
 * Erstelle eine subclass von Schliessfach namens SchliessSchublade. Diese subclass erhält zusätzlich
 * die Methode openSchublade(). In dieser Methode wird überprüft ob die Schublade besetzt ist oder nicht.
 * Wenn sie besetzt ist, soll eine entsprechende Rückmeldung erfolgen. Ist die Schublade nicht besetzt,
 * soll ausgegeben werden, dass die Schublade geöffnet wird. Außerdem soll sie dann als besetzt gelten.
 */

open class Fach {
    
    var istBesetzt: Boolean = false
//    	public get() = field	// redundant
    	protected set(value) { field = value }
    
}

fun Fach.toSting(): String {
    return if (this.istBesetzt) "belegt" else "leer"
}


class Schliessfach : Fach() {
    
	private val nummer: Int
    
    companion object {
        private var nextSchliessfachNummer = 0
    }
    
    init {
        nummer = nextSchliessfachNummer++
    }

    fun belegeSchließfach() {
        if (istBesetzt) { return }
        istBesetzt = true
    }
    
    fun leereSchließfach() {
        if (!istBesetzt) { return }
        istBesetzt = false
    }
    
}


fun main() {

    val meinSchliessfach = Schliessfach()
    println("Mein Schließfach ist ${meinSchliessfach.istBesetzt}")
    meinSchliessfach.belegeSchließfach()
    println("Mein Schließfach ist ${meinSchliessfach.istBesetzt}")
    meinSchliessfach.leereSchließfach()
    println("Mein Schließfach ist ${meinSchliessfach.istBesetzt}")
    
    //meinSchliessfach.istBesetzt = false	// geht nicht, weil nur der Getter public ist

}

/**
 * Übungsaufgabe: Teilnehmer und Kurse
 * 
 * In dieser Übungsaufgabe sollst du eine Klasse für Teilnehmer und eine innere Klasse für Kurse
 * erstellen. Ein Teilnehmer kann mehrere Kurse besuchen, und ein Kurs hat einen Namen und eine
 *  maximale Anzahl von Teilnehmern.
 * 
 * Teilnehmer-Klasse
 * Erstelle eine Klasse mit dem Namen "Teilnehmer". Die Klasse soll folgende Eigenschaften haben:
 * - name (String): Der Name des Teilnehmers.
 * - kurse (Liste von Kursen): Eine Liste der Kurse, die der Teilnehmer besucht.
 * 
 * Die Klasse soll die folgenden Methoden haben:
 * - kursHinzufügen(kurs: Kurs): Diese Methode fügt einen Kurs zur Liste der Kurse des Teilnehmers hinzu.
 * - kursEntfernen(kurs: Kurs): Diese Methode entfernt einen Kurs aus der Liste der Kurse des Teilnehmers.
 * - kurseAnzeigen(): Diese Methode gibt die Namen der Kurse aus, die der Teilnehmer besucht.
 * 
 * Kurs-Innere-Klasse
 * Erstelle eine innere Klasse mit dem Namen "Kurs" innerhalb der Teilnehmer-Klasse. 
 * Die Kurs-Klasse soll folgende Eigenschaften haben:
 * - name (String): Der Name des Kurses.
 * - maxTeilnehmer (Int): Die maximale Anzahl von Teilnehmern für den Kurs.
 * 
 * Die Kurs-Klasse soll keine eigenen Methoden haben.
 * Anleitung:
 * - Erstelle die Teilnehmer-Klasse mit den oben genannten Eigenschaften und Methoden.
 * - Erstelle die Kurs-Innere-Klasse innerhalb der Teilnehmer-Klasse mit den oben genannten Eigenschaften.
 * - Implementiere die Methoden der Teilnehmer-Klasse, um Kurse hinzuzufügen, zu entfernen und anzuzeigen.
 * - Erstelle ein Objekt der Teilnehmer-Klasse und füge einige Kurse hinzu.
 * - Rufe die Methode kurseAnzeigen() auf, um die Namen der besuchten Kurse auszugeben.
 */

class Teilnehmer(val name: String) {
    
    inner class IClass {
        fun printInfo() {
            kurseAnzeigen()
        }
    }
    
    /* nested */ class Kurs(
        val name: String,
        private val maxTeilnehmer: Int = 30,
        private val teilnehmerListe: MutableSet<Teilnehmer> = mutableSetOf()
    ) {
        
        fun teilnehmen(teilnehmer: Teilnehmer): Boolean {
            if (maxTeilnehmer > teilnehmerListe.size) {
            	teilnehmerListe.add(teilnehmer)
                return true
            }
            return false
        }
        
        fun austragen(teilnehmer: Teilnehmer) {
            if (teilnehmerListe.contains(teilnehmer)) {
                teilnehmerListe.remove(teilnehmer)
            }
        }
        
        fun teilnehmerAnzeigen() {
    		println("Teilnehmer für ${name}: ${teilnehmerListe.map { it.name }}")
        }
        
    }
    
    val kurse: MutableSet<Kurs> = mutableSetOf()
    
    fun hinzufügen(kurs: Kurs) {
        val kursVoll = !kurs.teilnehmen(this)
        if (kursVoll) {
            kurse.add(kurs)
        }
    }
    
    fun entfernen(kurs: Kurs) {
        if (kurse.contains(kurs)) {
            kurse.remove(kurs)
            kurs.austragen(this)
        }
    }
    
    fun kurseAnzeigen() {
        println("$name nimmt an folgenden Kursen teil: ${kurse.map {it.name}}")
    }
    
}



fun main() {
    val henrik = Teilnehmer("Henrik")
    val nico = Teilnehmer("Nico")
    
    val kotlinKurs = Teilnehmer.Kurs("Kotlin")
    val iOSKurs = Teilnehmer.Kurs("iOS")
    
    henrik.hinzufügen(kotlinKurs)
    henrik.hinzufügen(iOSKurs)
    nico.hinzufügen(iOSKurs)
    
    henrik.kurseAnzeigen()
    
    iOSKurs.teilnehmerAnzeigen()
    
    println()
    println("mit inner class")
    val ic = henrik.IClass()
    val ic2 = nico.IClass()
    ic.printInfo()
    ic2.printInfo()
    
}