module Degenz.Bot

open System.IO
open System.Threading.Tasks
open DSharpPlus
open DSharpPlus.SlashCommands
open Degenz
open Emzi0767.Utilities

type EmptyGlobalCommandToAvoidFamousDuplicateSlashCommandsBug() = inherit ApplicationCommandModule ()

let guild = GuildEnvironment.guildId

let hackerBattleConfig = DiscordConfiguration()
let storeConfig = DiscordConfiguration()
let jpegConfig = DiscordConfiguration()
//let stealConfig = DiscordConfiguration()
let inviterConfig = DiscordConfiguration()
let slotsConfig = DiscordConfiguration()
let adminConfig = DiscordConfiguration()
//adminConfig.MinimumLogLevel <- Microsoft.Extensions.Logging.LogLevel.Trace
//storeConfig.MinimumLogLevel <- Microsoft.Extensions.Logging.LogLevel.Trace

hackerBattleConfig.TokenType <- TokenType.Bot
hackerBattleConfig.Intents <- DiscordIntents.All

storeConfig.TokenType <- TokenType.Bot
storeConfig.Intents <- DiscordIntents.All

jpegConfig.TokenType <- TokenType.Bot
jpegConfig.Intents <- DiscordIntents.All

//stealConfig.TokenType <- TokenType.Bot
//stealConfig.Intents <- DiscordIntents.All

inviterConfig.TokenType <- TokenType.Bot
inviterConfig.Intents <- DiscordIntents.All

slotsConfig.TokenType <- TokenType.Bot
slotsConfig.Intents <- DiscordIntents.All

adminConfig.TokenType <- TokenType.Bot
adminConfig.Intents <- DiscordIntents.All

hackerBattleConfig.Token <- GuildEnvironment.tokenHackerBattle
storeConfig.Token <- GuildEnvironment.tokenStore
jpegConfig.Token <- GuildEnvironment.tokenJpeg
//stealConfig.Token <- GuildEnvironment.tokenSteal
inviterConfig.Token <- GuildEnvironment.tokenInviter
slotsConfig.Token <- GuildEnvironment.tokenSlots
adminConfig.Token <- GuildEnvironment.tokenAdmin

let hackerBattleBot = new DiscordClient(hackerBattleConfig)
let storeBot = new DiscordClient(storeConfig)
let jpegBot = new DiscordClient(jpegConfig)
//let stealBot = new DiscordClient(stealConfig)
let inviterBot = new DiscordClient(inviterConfig)
let slotsBot = new DiscordClient(slotsConfig)
let adminBot = new DiscordClient(adminConfig)

let hackerCommands = hackerBattleBot.UseSlashCommands()
//let jpegCommands = jpegBot.UseSlashCommands()
//let stealCommands = stealBot.UseSlashCommands()
let inviterCommands = inviterBot.UseSlashCommands()
//let slotsCommands = slotsBot.UseSlashCommands()
let adminCommands = adminBot.UseSlashCommands()

hackerCommands.RegisterCommands<HackerBattle.HackerGame>(guild);
//stealCommands.RegisterCommands<Thief.StealGame>(guild);
inviterCommands.RegisterCommands<InviteTracker.Inviter>(guild);
//slotsCommands.RegisterCommands<SlotMachine.SlotMachine>(guild);
adminCommands.RegisterCommands<Admin.AdminBot>(guild)

hackerBattleBot.add_ComponentInteractionCreated(AsyncEventHandler(HackerBattle.handleButtonEvent))
hackerBattleBot.add_MessageCreated(AsyncEventHandler(HackerBattle.handleMessageCreated))
storeBot.add_ComponentInteractionCreated(AsyncEventHandler(Store.handleStoreEvents))
jpegBot.add_ComponentInteractionCreated(AsyncEventHandler(Store.handleJpegEvents))
//stealBot.add_ComponentInteractionCreated(AsyncEventHandler(Thief.handleStealButton))
inviterBot.add_GuildMemberAdded(AsyncEventHandler(InviteTracker.handleGuildMemberAdded))
inviterBot.add_ComponentInteractionCreated(AsyncEventHandler(Whitelist.handleButtonEvent))
inviterBot.add_GuildMemberUpdated(AsyncEventHandler(InviteTracker.handleMemberUpdated))
inviterBot.add_MessageCreated(AsyncEventHandler(InviteTracker.handleMessageCreated))
slotsBot.add_ComponentInteractionCreated(AsyncEventHandler(SlotMachine.handleButton))
slotsBot.add_GuildDownloadCompleted(AsyncEventHandler(SlotMachine.handleGuildDownloadCompleted))
slotsBot.add_MessageCreated(AsyncEventHandler(SlotMachine.handleMessageCreated))
adminBot.add_ComponentInteractionCreated(AsyncEventHandler(Admin.handleButtonEvent))

let asdf _ (event : DSharpPlus.EventArgs.InteractionCreateEventArgs) =
    async {
        printfn "%A" event.Interaction.Type
        match event.Interaction.Type with
        | InteractionType.AutoComplete ->
            printfn "%A" event.Interaction.Data.Options
            let builder = DSharpPlus.Entities.DiscordInteractionResponseBuilder()
            builder.AddAutoCompleteChoice(DSharpPlus.Entities.DiscordAutoCompleteChoice("Choice 1", "What does this represent?"))
            |> ignore
            do! event.Interaction.CreateResponseAsync(InteractionResponseType.AutoCompleteResult, builder)
                |> Async.AwaitTask
        | _ -> return ()
    } |> Async.StartAsTask
      :> Task
//hackerBattleBot.add_InteractionCreated(AsyncEventHandler(asdf))

jpegBot.ConnectAsync() |> Async.AwaitTask |> Async.RunSynchronously
GuildEnvironment.botClientJpeg <- Some jpegBot

storeBot.ConnectAsync() |> Async.AwaitTask |> Async.RunSynchronously
GuildEnvironment.botClientStore <- Some storeBot

adminBot.ConnectAsync() |> Async.AwaitTask |> Async.RunSynchronously

hackerBattleBot.ConnectAsync() |> Async.AwaitTask |> Async.RunSynchronously
GuildEnvironment.botClientHacker <- Some hackerBattleBot

inviterBot.ConnectAsync() |> Async.AwaitTask |> Async.RunSynchronously
GuildEnvironment.botClientRecruit <- Some inviterBot

slotsBot.ConnectAsync() |> Async.AwaitTask |> Async.RunSynchronously
GuildEnvironment.botClientSlots <- Some slotsBot


//stealBot.ConnectAsync() |> Async.AwaitTask |> Async.RunSynchronously

let rec loop areBotsRunning =
    async {
        if not (File.Exists "fsharp-bots") then
            use file = File.Create "fsharp-bots"
            file.Flush()

        let! file = File.ReadAllTextAsync("fsharp-bots") |> Async.AwaitTask

        let! ran =
            async {
                if areBotsRunning && file.StartsWith "kill" then
                    printfn "Disconnecting bots"
                    do! hackerBattleBot.DisconnectAsync() |> Async.AwaitTask
                    do! storeBot.DisconnectAsync() |> Async.AwaitTask
                    return false
                elif not areBotsRunning && not (file.StartsWith "kill") then
                    printfn "Reconnecting bots"
                    do! hackerBattleBot.ConnectAsync() |> Async.AwaitTask
                    do! storeBot.ConnectAsync() |> Async.AwaitTask
                    return true
                else
                    return areBotsRunning
            }

        do! Async.Sleep 3000
        return! loop (ran)
    }

//Async.Start (loop true)


Task.Delay(-1)
|> Async.AwaitTask
|> Async.RunSynchronously