package nl.voidcorp.dbot.commands

import com.jagrosh.jdautilities.command.CommandBuilder
import com.jagrosh.jdautilities.command.CommandEvent
import com.sedmelluq.discord.lavaplayer.player.AudioLoadResultHandler
import com.sedmelluq.discord.lavaplayer.player.AudioPlayer
import com.sedmelluq.discord.lavaplayer.source.AudioSourceManagers
import com.sedmelluq.discord.lavaplayer.source.soundcloud.SoundCloudAudioSourceManager
import com.sedmelluq.discord.lavaplayer.source.soundcloud.SoundCloudAudioTrack
import com.sedmelluq.discord.lavaplayer.tools.FriendlyException
import com.sedmelluq.discord.lavaplayer.track.AudioPlaylist
import com.sedmelluq.discord.lavaplayer.track.AudioTrack
import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame
import net.dv8tion.jda.core.EmbedBuilder
import net.dv8tion.jda.core.audio.AudioSendHandler
import nl.voidcorp.dbot.cb
import nl.voidcorp.dbot.log
import nl.voidcorp.dbot.music.TrackScheduler
import nl.voidcorp.dbot.playerManager
import java.awt.Color
import java.time.LocalDateTime


val guildMusicMap = mutableMapOf<Long, TrackScheduler>()

fun initMusic() {
    AudioSourceManagers.registerRemoteSources(playerManager)


    val queueCommand = CommandBuilder().setName("queue").addAlias("q").setHelp("Queue's a song").build { event ->


        val scheduler = if (guildMusicMap.containsKey(event.guild.idLong)) guildMusicMap[event.guild.idLong]!! else {
            val channel = event.guild.voiceChannels.firstOrNull { it.members.contains(event.member) }
            if (channel == null) {
                event.reply("Join a voice Channel please!")
                return@build
            }
            val s = TrackScheduler(playerManager.createPlayer(), event.guild, channel)
            guildMusicMap[event.guild.idLong] = s
            s
        }



        playerManager.loadItem(event.args, object : AudioLoadResultHandler {
            override fun loadFailed(exception: FriendlyException) {
                event.reply("Shit's fucked!")
            }

            override fun trackLoaded(track: AudioTrack) {
                scheduler.queue(track, event.member)
            }

            override fun noMatches() {
                getLinkFromSearch(event, scheduler, false)
            }

            override fun playlistLoaded(playlist: AudioPlaylist) {
                for (t in playlist.tracks) {
                    scheduler.queue(t, event.member)
                }


            }

        })
    }

    val ytCommand = CommandBuilder().setName("youtube").addAlias("yt").setHelp("Play a song from YouTube!").build { event ->
        queueCommand.run(event)
    }

    val soundcloudCommand = CommandBuilder().setName("soundcloud").addAlias("sc").setHelp("Play a song from SoundCloud!").build { event ->
        val scheduler = if (guildMusicMap.containsKey(event.guild.idLong)) guildMusicMap[event.guild.idLong]!! else {
            val channel = event.guild.voiceChannels.firstOrNull { it.members.contains(event.member) }
            if (channel == null) {
                event.reply("Join a voice Channel please!")
                return@build
            }
            val s = TrackScheduler(playerManager.createPlayer(), event.guild, channel)
            guildMusicMap[event.guild.idLong] = s
            s
        }



        playerManager.loadItem(event.args, object : AudioLoadResultHandler {
            override fun loadFailed(exception: FriendlyException) {
                event.reply("Shit's fucked!")
            }

            override fun trackLoaded(track: AudioTrack) {
                scheduler.queue(track, event.member)
            }

            override fun noMatches() {
                getLinkFromSearch(event, scheduler, false, "scsearch")
            }

            override fun playlistLoaded(playlist: AudioPlaylist) {
                for (t in playlist.tracks) {
                    scheduler.queue(t, event.member)
                }


            }

        })
    }

    val playCommand = CommandBuilder().setName("play").addAlias("p").setHelp("Plays the song instantly").build { event ->
        val scheduler = if (guildMusicMap.containsKey(event.guild.idLong)) guildMusicMap[event.guild.idLong]!! else {
            val channel = event.guild.voiceChannels.firstOrNull { it.members.contains(event.member) }
            if (channel == null) {
                event.reply("Join a voice Channel please!")
                return@build
            }
            val s = TrackScheduler(playerManager.createPlayer(), event.guild, channel)
            guildMusicMap[event.guild.idLong] = s
            s
        }

        playerManager.loadItem(event.args, object : AudioLoadResultHandler {
            override fun loadFailed(exception: FriendlyException) {
                event.reply("Shit's fucked!")
            }

            override fun trackLoaded(track: AudioTrack) {
                scheduler.insertFront(track, event.member)
            }

            override fun noMatches() {
                getLinkFromSearch(event, scheduler, true)
            }

            override fun playlistLoaded(playlist: AudioPlaylist) {
                for (t in playlist.tracks) {
                    scheduler.insertFront(t, event.member)
                }


            }

        })
    }


    val skipCommand = CommandBuilder().setName("skip").addAlias("s").setHelp("Skips the currently playing track").build { event ->
        val scheduler = guildMusicMap[event.guild.idLong]
        if (scheduler == null) {
            event.reply("There is no music playing?")
        } else {
            scheduler.skip()
        }

    }


    cb.addCommands(playCommand, skipCommand, queueCommand, ytCommand, soundcloudCommand)
}

fun getLinkFromSearch(event: CommandEvent, scheduler: TrackScheduler, shouldInsertFront: Boolean, searchPrefix: String = "ytsearch") {
    log.info("Searching youtube for '${event.args}'")

    playerManager.loadItem("$searchPrefix:${event.args}", object : AudioLoadResultHandler {
        override fun loadFailed(exception: FriendlyException) {
            event.reply("Shit's fucked!")
        }

        override fun trackLoaded(track: AudioTrack) {
            if (shouldInsertFront)
                scheduler.insertFront(track, event.member)
            else
                scheduler.queue(track, event.member)
            /*event.reply(
                    EmbedBuilder().setImage(r.snippet.thumbnails.high.url).setTitle(r.snippet.title, "https://youtu.be/$id")
                            .setAuthor(r.snippet.channelTitle).setFooter("Requested by ${event.member.effectiveName}", event.author.effectiveAvatarUrl)
                            .setDescription(r.snippet.description).build()
            )*/

        }

        override fun noMatches() {

        }

        override fun playlistLoaded(playlist: AudioPlaylist) {
            if (!playlist.isSearchResult)
                for (t in playlist.tracks) {
                    if (shouldInsertFront)
                        scheduler.insertFront(t, event.member)
                    else
                        scheduler.queue(t, event.member)
                }
            else {
                val track = playlist.tracks.first()

                if (!scheduler.isQueueEmpty() or scheduler.isSongPlaying()) {

                    if (track is SoundCloudAudioTrack) {
                        val scsm = track.sourceManager as SoundCloudAudioSourceManager
                        scsm.updateClientId()
                        val art = khttp.get("http://api.soundcloud.com/tracks/${track.info.identifier}?client_id=${scsm.clientId}",
                                headers = mapOf("Content-Type" to "application/json")).jsonObject["artwork_url"].toString().replace("large", "t300x300")

                        event.reply(EmbedBuilder()
                                .setFooter("Requested by ${event.member.effectiveName}", event.member.user.effectiveAvatarUrl)
                                .setAuthor(track.info.author).setTitle(track.info.title, track.info.uri)
                                .setThumbnail(art)
                                .setTimestamp(LocalDateTime.now()).setColor(Color.decode("#ff8800")).build())
                    } else {
                        event.reply(EmbedBuilder()
                                .setFooter("Requested by ${event.member.effectiveName}", event.member.user.effectiveAvatarUrl)
                                .setAuthor(track.info.author).setTitle(track.info.title, track.info.uri)
                                .setThumbnail("https://img.youtube.com/vi/${track.info.identifier}/hqdefault.jpg")
                                .setTimestamp(LocalDateTime.now()).setColor(Color.decode("#ff0000")).build())
                    }

                }

                if (shouldInsertFront)
                    scheduler.insertFront(track, event.member)
                else
                    scheduler.queue(track, event.member)


            }


        }

    })

}

class AudioPlayerSendHandler(private val audioPlayer: AudioPlayer) : AudioSendHandler {
    private var lastFrame: AudioFrame? = null

    override fun canProvide(): Boolean {
        lastFrame = audioPlayer.provide()
        return lastFrame != null
    }

    override fun provide20MsAudio(): ByteArray {
        return lastFrame!!.data
    }

    override fun isOpus(): Boolean {
        return true
    }
}