package nl.voidcorp.dbot

import com.jagrosh.jdautilities.command.CommandClient
import com.jagrosh.jdautilities.command.CommandClientBuilder
import com.jagrosh.jdautilities.examples.command.PingCommand
import com.sedmelluq.discord.lavaplayer.jdaudp.NativeAudioSendFactory
import com.sedmelluq.discord.lavaplayer.player.DefaultAudioPlayerManager
import com.sedmelluq.discord.lavaplayer.source.soundcloud.SoundCloudAudioSourceManager
import com.sedmelluq.discord.lavaplayer.source.youtube.YoutubeAudioSourceManager
import io.javalin.Javalin
import io.javalin.json.FromJsonMapper
import io.javalin.json.JavalinJson
import io.javalin.json.ToJsonMapper
import net.dv8tion.jda.core.EmbedBuilder
import net.dv8tion.jda.core.JDA
import net.dv8tion.jda.core.JDABuilder
import net.dv8tion.jda.core.MessageBuilder
import net.dv8tion.jda.core.entities.Game
import net.dv8tion.jda.webhook.WebhookClient
import net.dv8tion.jda.webhook.WebhookClientBuilder
import nl.voidcorp.dbot.commands.helloCommand
import nl.voidcorp.dbot.commands.initMusic
import nl.voidcorp.dbot.storage.GitlabWebhook
import org.slf4j.LoggerFactory
import java.io.File
import java.io.FileReader

val playerManager = DefaultAudioPlayerManager()

val cb = CommandClientBuilder()

val log = LoggerFactory.getLogger("UnityBot")


@Suppress("JoinDeclarationAndAssignment")
fun main(args: Array<String>) {

    playerManager.registerSourceManager(YoutubeAudioSourceManager(true))
    playerManager.registerSourceManager(SoundCloudAudioSourceManager(true))

    JavalinJson.apply {
        toJsonMapper = object : ToJsonMapper {
            override fun map(obj: Any): String = gson.toJson(obj)
        }
        fromJsonMapper = object : FromJsonMapper {
            override fun <T> map(json: String, targetClass: Class<T>): T = gson.fromJson(json, targetClass)
        }
    }

    if (!File(".hooks").exists()) {
        log.error("The .hooks file does not exist!")
        log.error("Exiting")
        System.exit(1)
    }

    val hooks = mutableListOf<WebhookClient>()
    FileReader(".hooks").forEachLine {
        val wh = WebhookClientBuilder(it).build()
        hooks += wh
    }

    log.info(hooks.toString())

    val app = Javalin.create().requestLogger { ctx, timeMs ->
        if (ctx.res.status >= 400) {
            log.error("${ctx.method()} ${ctx.path()} -> ${ctx.status()} (${timeMs}ms)")
        } else {
            log.info("${ctx.method()} ${ctx.path()} -> ${ctx.status()} (${timeMs}ms)")
        }
    }.disableStartupBanner().start(4466)

    app.post("/gitlab.json") { ctx ->
        val bod = ctx.validatedBody<GitlabWebhook>()
        if (bod.value != null) {
            bod.value!!.apply {
                val embed = EmbedBuilder()
                embed.setTitle(project.name, project.web_url)
                val builder = embed.descriptionBuilder
                var url = ""
                commits.forEach {
                    builder.append("${it.message} (${it.timestamp})")
                    url = it.url
                }
                embed.setAuthor("$user_name ($user_username)", url, user_avatar)
                hooks.forEach { it.send(embed.build()) }
            }
        }
        ctx.status(200).result("OK")
    }

    lateinit var client: CommandClient
    cb.setOwnerId("168743656738521088")
    cb.setPrefix("!")
    cb.setAlternativePrefix("+")
    cb.addCommand(PingCommand())
    cb.addCommand(helloCommand)
    cb.setGame(Game.watching("fraud and \uD83C\uDFB5"))

    cb.setHelpConsumer { event ->
        event.reply(MessageBuilder("Help for ${event.selfMember.asMention}\n").append {
            var st = ""
            for (c in client.commands) {
                st += "`${c.name}`: ${c.help}${if (c.aliases.isNotEmpty()) " (alias: `${c.aliases.first()}`)" else ""}\n"
            }
            st
        }.build()
        )
    }

    initMusic()


    client = cb.build()

    bot = JDABuilder(args[0]).addEventListener(client).addEventListener(nl.voidcorp.dbot.Events).setAudioSendFactory(NativeAudioSendFactory()).build()
}

lateinit var bot: JDA