module DegenzGame.Commands

open System
open System.Threading.Tasks
open DSharpPlus
open DSharpPlus.Entities
open DSharpPlus.EventArgs
open DSharpPlus.SlashCommands
open DegenzGame.Types
open DegenzGame.Functions
open MongoDB.Driver

[<Literal>]
// Degenz Server
//let battleChannel = 930363007781978142uL
// My server
let battleChannel = 927449884204867664uL

let mongo = MongoClient("mongodb://localhost:27017")
let db = mongo.GetDatabase("degenz-game")
let players = db.GetCollection<Player>("players")

let tryFindPlayer (id : uint64) : Async<Player option> =
    async {
        let filter = Builders<Player>.Filter.Eq((fun p -> p.DiscordId), id)
        let! player = players.FindAsync<Player>(filter) |> Async.AwaitTask
        return match player.ToEnumerable() |> Seq.toList with
               | []  -> None
               | p::_ -> Some p
    }

let addHackerRole (ctx : InteractionContext) =
    async {
        let! player = tryFindPlayer ctx.Member.Id
        let! newPlayer =
            match player with
            | Some _ -> async.Return false
            | None ->
                async {
                    let p = (newPlayer ctx.Member.Username ctx.Member.Id)
                    do! players.InsertOneAsync p |> Async.AwaitTask

                    for role in ctx.Guild.Roles do
                        if role.Value.Name = "Hacker" then
                            do! ctx.Member.GrantRoleAsync(role.Value)
                                |> Async.AwaitTask

                    return true
                }

        if newPlayer then
            do! ctx.CreateResponseAsync("You are now an elite haxxor", true)
                |> Async.AwaitTask
        else
            do! ctx.CreateResponseAsync("Already registered as an elite haxxor", true)
                |> Async.AwaitTask

    } |> Async.StartAsTask
    :> Task

let removeHackerRole (ctx : InteractionContext) =
    async {
        for role in ctx.Member.Roles do
            if role.Name = "Hacker" then
                do! ctx.Member.RevokeRoleAsync(role)
                    |> Async.AwaitTask
        // TODO: Check the result of this delete operation
        let! _ = players.DeleteOneAsync (fun p -> p.DiscordId = ctx.Member.Id) |> Async.AwaitTask
        do! ctx.CreateResponseAsync("You are now lame", true)
            |> Async.AwaitTask
    } |> Async.StartAsTask
    :> Task

let attack (ctx : InteractionContext) (target : DiscordUser) =
    async {
        // TODO: We need to check if the player has any active embed hacks going, if not they can cheat
        let! attacker = tryFindPlayer ctx.Member.Id
        let! defender = tryFindPlayer target.Id
        match attacker , defender with
        | Some attacker , Some defender ->
            let updatedAttacks = removeExpiredActions (TimeSpan.FromMinutes(5)) (fun (atk : Attack) -> atk.Timestamp) attacker.Attacks
            let filter = Builders<Player>.Filter.Eq((fun p -> p.DiscordId), attacker.DiscordId)
            let update = Builders<Player>.Update.Set((fun p -> p.Attacks), updatedAttacks)
            let! _ = players.UpdateOneAsync(filter, update) |> Async.AwaitTask
            if updatedAttacks.Length < 2 then
                let builder = DiscordInteractionResponseBuilder()
                builder.AddEmbed (constructEmbed "Pick the hack you wish to use.") |> ignore

                let defenderInfo = $"{defender.DiscordId}-{target.Username}"
                constructButtons "Attack" defenderInfo attacker.Weapons
                |> Seq.cast<DiscordComponent>
                |> builder.AddComponents
                |> ignore

                builder.AsEphemeral true |> ignore

                do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask

            else
                let builder = DiscordInteractionResponseBuilder()
                let timestamp = updatedAttacks |> Array.rev |> Array.head |> fun a -> a.Timestamp // This should be the next expiring timestamp
                let timeRemaining = TimeSpan.FromMinutes(15) - (DateTime.UtcNow - timestamp)
                builder.Content <- $"No more hacks available, please wait {timeRemaining.Minutes} minutes and {timeRemaining.Seconds} seconds to attempt another hack"

                builder.AsEphemeral true |> ignore

                do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask

        | None , _ -> do! notYetAHackerMsg ctx
        | _ , None -> do! createSimpleResponseAsync "Your target is not connected to the network, they must join first by using the /redpill command" ctx
    } |> Async.StartAsTask
    :> Task

let defend (ctx : InteractionContext) =
    async {
        let! player = tryFindPlayer ctx.Member.Id
        match player with
        | Some player ->
            let updatedDefenses = removeExpiredActions (TimeSpan.FromMinutes(60)) (fun (pro : Defense) -> pro.Timestamp) player.Defenses
            let filter = Builders<Player>.Filter.Eq((fun p -> p.DiscordId), player.DiscordId)
            let update = Builders<Player>.Update.Set((fun p -> p.Defenses), updatedDefenses)
            let! _ = players.UpdateOneAsync(filter, update) |> Async.AwaitTask
            if updatedDefenses.Length < 2 then
                let builder = DiscordInteractionResponseBuilder()
                builder.AddEmbed (constructEmbed "Pick a defense to mount for a duration of time") |> ignore

                constructButtons "Defend" (string player.DiscordId) player.Shields
                |> Seq.cast<DiscordComponent>
                |> builder.AddComponents
                |> ignore

                builder.AsEphemeral true |> ignore

                do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask
            else
                let builder = DiscordInteractionResponseBuilder()
                let timestamp = updatedDefenses |> Array.rev |> Array.head |> fun a -> a.Timestamp // This should be the next expiring timestamp
                let timeRemaining = TimeSpan.FromMinutes(15) - (DateTime.UtcNow - timestamp)
                builder.Content <- $"Cannot add new defense, please wait {timeRemaining.Minutes} minutes and {timeRemaining.Seconds} seconds to add another defense"

                builder.AsEphemeral true |> ignore

                do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask
        | None -> do! notYetAHackerMsg ctx
    } |> Async.StartAsTask
    :> Task

let status (ctx : InteractionContext) =
    async {
        let! player = tryFindPlayer ctx.Member.Id
        match player with
        | Some p ->
            let builder = DiscordInteractionResponseBuilder()
            builder.IsEphemeral <- true
            builder.Content <- Functions.statusFormat p
            do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                |> Async.AwaitTask
        | None -> do! notYetAHackerMsg ctx
    } |> Async.StartAsTask
    :> Task

let leaderboard (ctx : InteractionContext) =
    async {
        let builder = DiscordInteractionResponseBuilder()
        builder.IsEphemeral <- true

        let! leaders = players.Find(fun _ -> true).SortBy(fun p -> p.Bank).Limit(10).ToListAsync() |> Async.AwaitTask
        let content =
            leaders.ToArray()
            |> Array.mapi (fun i p -> $"{i + 1}.   {p.Bank}   {p.Name}")
            |> String.concat "\n"
        builder.Content <- if not <| String.IsNullOrEmpty content then content else "There are no active hackers"
        do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
            |> Async.AwaitTask
    } |> Async.StartAsTask
    :> Task

let handleAttack (event : ComponentInteractionCreateEventArgs) =
    let updatePlayer amount attack p =
        { p with Attacks = Array.append [| attack |] p.Attacks ; Bank = MathF.Max(p.Bank + amount, 0f) }
    async {
        let split = event.Id.Split("-")
        let  ( resultHack , weapon ) = Weapon.TryParse(split.[1])
        let ( resultId , targetId ) = UInt64.TryParse split.[2]
        let! resultPlayer = tryFindPlayer event.User.Id
        let! resultTarget = tryFindPlayer targetId
        match resultPlayer , resultTarget , resultHack , resultId with
        | Some player , Some target , true , true ->
           let wasSuccessfulHack =
                target.Defenses
                |> Seq.toArray
                |> Array.map (fun dfn -> int dfn.DefenseType)
                |> Array.map (calculateDamage weapon)
                |> Array.contains Weak
           match wasSuccessfulHack with
           | false ->
                let prize = 0.1726f
                let attack = { HackType = enum<Weapon>(weapon) ; Timestamp = DateTime.UtcNow ; Target = { Id = targetId ; Name = split.[3] } }
                let filter = Builders<Player>.Filter.Eq((fun p -> p.DiscordId), player.DiscordId)
                let! _ = players.ReplaceOneAsync(filter, updatePlayer prize attack player) |> Async.AwaitTask

                let builder = DiscordInteractionResponseBuilder()
                builder.IsEphemeral <- true
                builder.Content <- $"Successfully hacked {split.[3]} using {weapon}! You just won {prize} genz!"
                do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
                    |> Async.AwaitTask

                let builder = DiscordMessageBuilder()
                builder.WithContent($"{event.User.Username} successfully hacked <@{targetId}>!") |> ignore
                let channel = (event.Guild.GetChannel(battleChannel))
                do! channel.SendMessageAsync(builder)
                    |> Async.AwaitTask
                    |> Async.Ignore
           | true ->
                let builder = DiscordInteractionResponseBuilder()
                let loss = -0.0623f
                builder.IsEphemeral <- true
                builder.Content <- $"Hack failed! {split.[3]} was able to mount a successful defense! You lost {loss} genz!"
                do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
                    |> Async.AwaitTask

                let attack = { HackType = enum<Weapon>(weapon) ; Timestamp = DateTime.UtcNow ; Target = { Id = targetId ; Name = split.[3] } }
                let filter = Builders<Player>.Filter.Eq((fun p -> p.DiscordId), player.DiscordId)
                let! _ = players.ReplaceOneAsync(filter, updatePlayer loss attack player) |> Async.AwaitTask

                let builder = DiscordMessageBuilder()
                builder.WithContent($"{event.User.Username} failed to hack <@{targetId}>!") |> ignore
                let channel = (event.Guild.GetChannel(battleChannel))
                do! channel.SendMessageAsync(builder)
                    |> Async.AwaitTask
                    |> Async.Ignore
        | _ ->
            let builder = DiscordInteractionResponseBuilder()
            builder.IsEphemeral <- true
            builder.Content <- "Error occurred processing attack"
            do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask
    }

let handleDefense (event : ComponentInteractionCreateEventArgs) =
    async {
        let split = event.Id.Split("-")
        let ( shieldResult , shield ) = Shield.TryParse(split.[1])
        let! playerResult = tryFindPlayer event.User.Id
        match playerResult , shieldResult with
        | Some player , true ->
            let builder = DiscordInteractionResponseBuilder()
            builder.IsEphemeral <- true
            builder.Content <- $"Mounted a {shield} defense for 1 hour"
            do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
                |> Async.AwaitTask

            let defense = { DefenseType = shield ; Timestamp = DateTime.UtcNow }
            let filter = Builders<Player>.Filter.Eq((fun p -> p.DiscordId), player.DiscordId)
            let update = Builders<Player>.Update.Set((fun p -> p.Defenses), Array.append [| defense |] player.Defenses )
            let! _ = players.UpdateOneAsync(filter, update) |> Async.AwaitTask

            let builder = DiscordMessageBuilder()
            builder.WithContent($"{event.User.Username} has protected their system!") |> ignore
            let channel = event.Guild.Channels.Values |> Seq.find (fun c -> c.Name = "battle-1")
            do! channel.SendMessageAsync(builder)
                |> Async.AwaitTask
                |> Async.Ignore
        | _ ->
            let builder = DiscordInteractionResponseBuilder()
            builder.IsEphemeral <- true
            builder.Content <- "Error parsing Button Id"
            do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask
    }

let handleButtonEvent (client : DiscordClient) (event : ComponentInteractionCreateEventArgs) =
    async {
        return! match event.Id with
                | id when id.StartsWith("Attack") -> handleAttack event
                | id when id.StartsWith("Defend") -> handleDefense event
                | _ ->
                    async {
                        let builder = DiscordInteractionResponseBuilder()
                        builder.IsEphemeral <- true
                        builder.Content <- $"Incorrect Action identifier {event.Id}"
                        do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                                |> Async.AwaitTask
                    }
    } |> Async.StartAsTask
    :> Task