fun main() {

    val verwaltung = Musikverwaltung()

    val song1 = Song("Led Zeppelin", "Led Zeppelin", 180, 90)
    val song2 = Song("Led Zeppelin II", "Led Zeppelin", 147, 80)
    val song3 = Song("Led Zeppelin III", "Led Zeppelin", 260, 72)
    val song4 = Song("[Led Zeppelin IV]", "Led Zeppelin", 451, 85)
    val song5 = Song("Houses of the Holy", "Led Zeppelin", 332, 94)
    val song6 = Song("Physical Graffiti", "Led Zeppelin", 174, 100)
    val song7 = Song("Presence", "Led Zeppelin", 80, 67)
    val song8 = Song("In Through the Out Door", "Led Zeppelin", 270, 93)

    verwaltung.hinzufuegen(song1)
    verwaltung.hinzufuegen(song2)
    verwaltung.hinzufuegen(song3)
    verwaltung.hinzufuegen(song4)
    verwaltung.hinzufuegen(song5)
    verwaltung.hinzufuegen(song6)
    verwaltung.hinzufuegen(song7)
    verwaltung.hinzufuegen(song8)

    val newPlaylist = Playlist(mutableListOf<Song>(song1, song2, song3))
    val zufallsPlaylist: Playlist = verwaltung.zufallsPlaylist()
    val dynPlaylist = DynamicPlaylist(mutableListOf<Song>(song1, song2, song3))

    val bew = 80

    newPlaylist.alleAbspielen()
    println("\nSpieldauer von newPlaylist: ${newPlaylist.gesamteSpieldauer()} Sekunden, ${String.format("%.2f",newPlaylist.gesamteSpieldauer() / 60.0)} Minuten")
    println("\nAnzahl der Songs mit einer  Bewertung von $bew oder besser: ${newPlaylist.SpieldauerMitXOderBesser(bew)}")

    println("\n-----SEPERATOR-----\n")

    zufallsPlaylist.alleAbspielen()
    println("\nSpieldauer von zufallPlaylist: ${zufallsPlaylist.gesamteSpieldauer()} Sekunden, ${String.format("%.2f",zufallsPlaylist.gesamteSpieldauer() / 60.0)} Minuten")
    println("\nAnzahl der Songs mit einer  Bewertung von $bew oder besser: ${zufallsPlaylist.SpieldauerMitXOderBesser(bew)}")

    println("\n-----SEPERATOR-----\n")

    dynPlaylist.alleAbspielen()
    println("\nSpieldauer von dynPlaylist: ${dynPlaylist.gesamteSpieldauer()} Sekunden, ${String.format("%.2f",dynPlaylist.gesamteSpieldauer() / 60.0)} Minuten")
    println("\nAnzahl der Songs mit einer  Bewertung von $bew oder besser: ${dynPlaylist.SpieldauerMitXOderBesser(bew)}")

    //dynPlaylist Test

    dynPlaylist.add(song6)

    println("\n-----SEPERATOR-----\n")

    dynPlaylist.alleAbspielen()
    println("\nSpieldauer von dynPlaylist: ${dynPlaylist.gesamteSpieldauer()} Sekunden, ${String.format("%.2f",dynPlaylist.gesamteSpieldauer() / 60.0)} Minuten")
    println("\nAnzahl der Songs mit einer  Bewertung von $bew oder besser: ${dynPlaylist.SpieldauerMitXOderBesser(bew)}")

    println("\n-----SEPERATOR-----\n")

    val testSong = dynPlaylist.take()

    println(testSong?.titel)

    dynPlaylist.alleAbspielen()
    println("\nSpieldauer von dynPlaylist: ${dynPlaylist.gesamteSpieldauer()} Sekunden, ${String.format("%.2f",dynPlaylist.gesamteSpieldauer() / 60.0)} Minuten")
    println("\nAnzahl der Songs mit einer  Bewertung von $bew oder besser: ${dynPlaylist.SpieldauerMitXOderBesser(bew)}")

    println("\n-----SEPERATOR-----\n")
    
    dynPlaylist.reset()

    dynPlaylist.alleAbspielen()
    println("\nSpieldauer von dynPlaylist: ${dynPlaylist.gesamteSpieldauer()} Sekunden, ${String.format("%.2f",dynPlaylist.gesamteSpieldauer() / 60.0)} Minuten")
    println("\nAnzahl der Songs mit einer  Bewertung von $bew oder besser: ${dynPlaylist.SpieldauerMitXOderBesser(bew)}")

    val besterSong: Song = verwaltung.besterSong()

    println("\nDer beste Song in der Datenbank ist: ${besterSong.titel} von ${besterSong.interpret}, Spieldauer: ${besterSong.spieldauer / 60.0}, Bewertung: ${besterSong.bewertung}")

    do{

        println("Bitte geben Sie einen Suchbegriff ein!")
        val eingabe = readLine().toString()

        if(eingabe != "stopp") {
            val seekSong = verwaltung.suchen(eingabe)
            seekSong?.abspielen() ?: println("\nIhre Suche ergab keine Treffer!\n")
        }
    }
    while(eingabe != "stopp")

    val  player = Wiedergabe(newPlaylist, 0)
    /*
    player.startStopErneut(0)
    player.nMalNeachsterSong(3)
    player.startStopErneut(1)
    println("aktuellerSong: ${player.aktuellerSong}")
    player.startStopErneut(1)
    player.neachsterSong()
    println("aktuellerSong: ${player.aktuellerSong}")
    player.wiedergabemodusSetzen(2)
    println("aktuellerSong: ${player.aktuellerSong}")
    player.neachsterSong()

    println("aktuellerSong: ${player.aktuellerSong}")
    */

}

import kotlin.random.Random

class Wiedergabe(var aktuellePlaylist: Playlist, var wiedergabemodus: Int){

    var aktuellerSong: Int = 0

    fun aktuellePlaylistSetzen(zuSetzendePlaylist: Playlist){

        aktuellePlaylist = zuSetzendePlaylist
    }

    fun wiedergabemodusSetzen(zuSetzenderWiedergabemodus: Int){

        wiedergabemodus = zuSetzenderWiedergabemodus
    }

    fun neachsterSong(){

        var wiederholen: String = "n"

        if( wiedergabemodus == 0) {

            do {

                if(aktuellerSong < aktuellePlaylist.songliste.size) {
                    aktuellePlaylist.songliste.get(aktuellerSong).abspielen()
                    aktuellerSong++
                }

                if(aktuellerSong < aktuellePlaylist.songliste.size) {
                    println("Wiederholen? y/n")
                    wiederholen = readLine().toString()
                }
                else {
                    wiederholen = "n"
                    startStopErneut(1)
                }
            }while (wiederholen != "n")
        }
        else if(wiedergabemodus == 1){

            do {
                for (s in aktuellePlaylist.songliste)
                    s.abspielen()

                println("Wiederholen? y/n")
                wiederholen = readLine().toString()

            }while (wiederholen != "n")
        }
        else{
            do{
                aktuellePlaylist.songliste.get(Random.nextInt(aktuellePlaylist.songliste.size)).abspielen()

                println("Wiederholen? y/n")
                wiederholen = readLine().toString()
            }while (wiederholen != "n")
        }
    }

    fun nMalNeachsterSong(n: Int){

        for (s in 0..n)
            neachsterSong()
    }

    fun startStopErneut(action: Int){

        if(action == 0){
            neachsterSong()
        }
        else if(action == 1)
            aktuellerSong = 0
        else {
            aktuellerSong = 0
            neachsterSong()
        }
    }
}

open class Playlist(val songliste: MutableList<Song>) {

    open fun gesamteSpieldauer() = songliste.sumBy { it.spieldauer }

    fun SpieldauerMitXOderBesser(x: Int): Int {

        var tmp: Int = 0

        for (s in songliste) {
            if(s.bewertung >= x){
                tmp += 1
            }
        }

        return tmp
    }

    open fun alleAbspielen() {

        for (s in songliste) {

            s.abspielen()
        }
    }
}

class DynamicPlaylist (songlisteParam: MutableList<Song>): Playlist(songlisteParam){

    class SongNode(val song : Song, var nextSong : SongNode?)

    private var first: SongNode? = null
    private var last: SongNode? = null

    init {

        reset();

        /*first = SongNode(songliste.get(0), null)

        var runPointer = first

        for( i in 1..songliste.size){

            runPointer?.nextSong = SongNode(songliste.get(i), null)
            runPointer = runPointer?.nextSong ?: runPointer
        }

        last = runPointer*/
    }

    fun add(derSongTM : Song){

        last?.nextSong = SongNode(derSongTM, null)
    }

    fun take() : Song?{

        var tmp = first
        first = first?.nextSong

        return tmp?.song
    }

    fun reset(){

        first = SongNode(songliste.get(0), null)

        var runPointer = first

        for( i in 1..songliste.size-1){

            runPointer?.nextSong = SongNode(songliste.get(i), null)
            runPointer = runPointer?.nextSong ?: runPointer
        }

        last = runPointer
    }

    override fun gesamteSpieldauer() : Int{

        var runPointer = first
        var tmp : Int = 0

        while (runPointer != null){

            tmp += runPointer.song.spieldauer
            runPointer = runPointer.nextSong
        }

        return tmp
    }

    override fun alleAbspielen() {

        var runPointer = first

        while (runPointer != null){

            runPointer.song.abspielen()
            runPointer = runPointer.nextSong
        }
    }

}

import kotlin.random.Random

class Musikverwaltung() {

    val songliste: MutableList<Song> = mutableListOf<Song>()

    fun hinzufuegen(song: Song) {

        songliste.add(song)
    }

    fun suchen(begriff: String): Song?{

        for(s in songliste){

            if(s.search(begriff)) {

                return s
            }
        }

        return null
    }

    fun besterSong(): Song{

        var tmp = songliste.get(0)

        for(s in songliste){

            if(s.bewertung > tmp.bewertung)
                tmp = s
        }

        return tmp
    }

    fun zufallsPlaylist(): Playlist{

        val newSongliste: MutableList<Song> = mutableListOf<Song>()
        var laengePlaylist = Random.nextInt(songliste.size)

        var istVorhanden = false

        for(i in 0..laengePlaylist){

            for (s in newSongliste){

                if(songliste.get(Random.nextInt(songliste.size)) == s)
                    istVorhanden = true
            }

            if(!istVorhanden)
                newSongliste.add(songliste.get(Random.nextInt(songliste.size)))
            else
                laengePlaylist++
        }

        return Playlist(newSongliste)
    }
}

open class Song(val titel: String, val interpret: String, val spieldauer: Int, _bewertung: Int) {

    var bewertung = _bewertung
        set(value) {
            if (value !in 0..100)
                field = 0
            else
                field = value
        }

    open fun abspielen() {

        var decke: Int

        if (spieldauer % 60 == 0)
            decke = spieldauer / 60
        else
            decke = spieldauer / 60 + 1

        for (i in 1..decke)
            println("Spiele: $titel von $interpret (Bewertung: $bewertung Punkte)")
    }

    fun change(newValue: Int) {

        bewertung = newValue
    }

    open fun search(searchString: String): Boolean {

        var istDrin = false

        if (titel.contains(searchString))
            istDrin = true

        if (interpret.contains(searchString))
            istDrin = true

        return istDrin
    }

}

class SongMitText(titelParam: String, interpretParam: String, spieldauerParam: Int, bewertungParam: Int, var textzeile: String) : Song(titelParam, interpretParam, spieldauerParam, bewertungParam){

    override fun search(searchString: String): Boolean {

        var istDrin = false

        if (titel.contains(searchString))
            istDrin = true

        if (interpret.contains(searchString))
            istDrin = true

        if (textzeile.contains(searchString))
            istDrin = true

        return istDrin
    }
}

class SongMitAutobewertung(titelParam: String, interpretParam: String, spieldauerParam: Int, bewertungParam: Int) : Song(titelParam, interpretParam, spieldauerParam, bewertungParam){

    override fun abspielen() {

        var decke: Int

        if (spieldauer % 60 == 0)
            decke = spieldauer / 60
        else
            decke = spieldauer / 60 + 1

        bewertung++

        for (i in 1..decke)
            println("Spiele: $titel von $interpret (Bewertung: $bewertung Punkte)")
    }
}