module Degenz.HackerBattle

open System
open System.Threading.Tasks
open DSharpPlus
open DSharpPlus.Entities
open DSharpPlus.EventArgs
open DSharpPlus.SlashCommands
open Degenz
open Degenz.Shared

let getTimeTillCooldownFinishes (timespan : TimeSpan) timestamp =
    let timeRemaining = timespan - (DateTime.UtcNow - timestamp)
    if timeRemaining.Hours > 0 then
        $"{timeRemaining.Hours} hours"
    elif timeRemaining.Minutes > 0 then
        $"{timeRemaining.Minutes} minutes"
    else
        $"{timeRemaining.Seconds} seconds"

let checkForExistingHack defenderId attacker =
    let updatedAttacks =
        attacker.Attacks
        |> removeExpiredActions (TimeSpan.FromHours(24)) (fun atk -> atk.Timestamp)
    updatedAttacks
    |> Array.tryFind (fun a -> a.Target.Id = defenderId)
    |> function
       | Some attack ->
           let cooldown = getTimeTillCooldownFinishes (TimeSpan.FromHours(24)) attack.Timestamp
           Error $"You can only hack the same target once every 24 hours, wait {cooldown} to attempt another hack on {attack.Target.Name}."
       | None ->
           Ok attacker

let checkIfHackHasCooldown hack attacker =
    let mostRecentHackAttack =
        attacker.Attacks
        |> Array.tryFind (fun a -> a.HackType = hack)
        |> function
           | Some a -> a.Timestamp
           | None -> DateTime.MinValue
    if DateTime.UtcNow - mostRecentHackAttack > TimeSpan.FromMinutes(5) then
        Ok attacker
    else
       let cooldown = getTimeTillCooldownFinishes (TimeSpan.FromMinutes(5)) mostRecentHackAttack
       Error $"{hack} is currently on cooldown, wait {cooldown} to use it again."

let checkIfInventoryIsEmpty attacker =
    match attacker.Weapons with
    | [||] -> Error $"You currently do not have any Hacks to use against others. Please go to the store and purchase one."
    | _ -> Ok attacker

let calculateDamage (hack: int) (shield: int) =
    let hackClass = getClass hack
    let protectionClass = getClass shield

    match hackClass, protectionClass with
    | h, p when h = p -> Weak
    | _ -> Strong

let runHackerBattle defender hack =
    defender.Defenses
    |> removeExpiredActions (TimeSpan.FromHours(6)) (fun (pro : Defense) -> pro.Timestamp)
    |> Seq.toArray
    |> Array.map (fun dfn -> int dfn.DefenseType)
    |> Array.map (calculateDamage (int hack))
    |> Array.contains Weak

let updateCombatants attacker defender hack prize =
   let updatePlayer amount attack p =
       { p with Attacks = Array.append [| attack |] p.Attacks ; Bank = Math.Max(p.Bank + amount, 0) }
   let attack = { HackType = enum<Hack>(int hack) ; Timestamp = DateTime.UtcNow ; Target = { Id = defender.DiscordId ; Name = defender.Name } }

   [ DbService.updatePlayer <| updatePlayer prize attack attacker
     DbService.updatePlayer <| modifyPlayerBank defender -prize ]
   |> Async.Parallel
   |> Async.Ignore

let successfulHack (event : ComponentInteractionCreateEventArgs) attacker defender hack =
    async {
        let prize = 3

        do! updateCombatants attacker defender hack prize

        let embed = DiscordEmbedBuilder()
        embed.ImageUrl <- Embeds.getHackGif hack
        let builder = DiscordInteractionResponseBuilder()
        builder.IsEphemeral <- true
        builder.AddEmbed embed |> ignore
        builder.Content <- $"Successfully hacked {defender.Name} using {hack}! You just won {prize} GoodBoyTokenz!"
        do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
            |> Async.AwaitTask

        let builder = Embeds.eventSuccessfulHack event defender.DiscordId prize
        let channel = event.Guild.GetChannel(GuildEnvironment.channelEventsHackerBattle)
        do! channel.SendMessageAsync(builder)
            |> Async.AwaitTask
            |> Async.Ignore
    }

let failedHack (event : ComponentInteractionCreateEventArgs) attacker defender hack =
    async {
        let builder = DiscordInteractionResponseBuilder()
        let prize = 2
        builder.IsEphemeral <- true
        builder.Content <- $"Hack failed! {defender.Name} was able to mount a successful defense! You lost {prize} GoodBoyTokenz!"
        do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
            |> Async.AwaitTask

        do! updateCombatants attacker defender hack -prize

        let builder = DiscordMessageBuilder()
        builder.WithContent($"Hacking attempt failed! <@{defender.DiscordId}> defended hack from {event.User.Username} and took {prize} from them! ") |> ignore
        let channel = (event.Guild.GetChannel(GuildEnvironment.channelEventsHackerBattle))
        do! channel.SendMessageAsync(builder)
            |> Async.AwaitTask
            |> Async.Ignore
    }

let attack (ctx : InteractionContext) (target : DiscordUser) =
    async {
        let! attacker = DbService.tryFindPlayer ctx.Member.Id
        let! defender = DbService.tryFindPlayer target.Id
        match attacker , defender with
        | Some attacker , Some defender ->
            let hackAttempt =
                checkForExistingHack defender.DiscordId attacker
                |> Result.bind checkIfInventoryIsEmpty
            match hackAttempt with
            | Ok _ ->
                let embed = Embeds.pickHack "Attack" attacker defender
                do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, embed)
                    |> Async.AwaitTask
            | Error msg ->
                let builder =
                    DiscordInteractionResponseBuilder()
                        .WithContent(msg)
                        .AsEphemeral(true)
                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 handleAttack (event : ComponentInteractionCreateEventArgs) =
    async {
        let split = event.Id.Split("-")
        let hack = Enum.Parse(typedefof<Hack>, split.[1]) :?> Hack
        let ( resultId , targetId ) = UInt64.TryParse split.[2]
        let! resultPlayer = DbService.tryFindPlayer event.User.Id
        let! resultTarget = DbService.tryFindPlayer targetId

        // TODO: Do not let player hack themselves
        match resultPlayer , resultTarget , true , resultId with
        | Some attacker , Some defender , true , true ->
            do! checkForExistingHack defender.DiscordId attacker
                |> Result.bind (checkIfHackHasCooldown hack)
                |> function
                   | Ok _ ->
                       runHackerBattle defender hack
                       |> function
                          | false -> successfulHack event attacker defender hack
                          | true -> failedHack event attacker defender hack
                   | Error msg ->
                       let builder =
                           DiscordInteractionResponseBuilder()
                               .WithContent(msg)
                               .AsEphemeral(true)
                       event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                       |> Async.AwaitTask
        | _ ->
            let builder = DiscordInteractionResponseBuilder()
            builder.IsEphemeral <- true
            builder.Content <- "Error occurred processing attack"
            do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask
    }

let defend (ctx : InteractionContext) =
    async {
        let! player = DbService.tryFindPlayer ctx.Member.Id
        match player with
        | Some player ->
            if player.Shields.Length > 0 then
                let embed = Embeds.pickDefense "Defend" player
                do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, embed)
                    |> Async.AwaitTask
            else
                let builder = DiscordInteractionResponseBuilder()
                builder.Content <- $"You currently do not have any Shields to protect your system. Please go to the store and purchase one."
                builder.AsEphemeral true |> ignore
                do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask
        | None -> do! notYetAHackerMsg ctx
    } |> Async.StartAsTask
    :> Task

let handleDefense (event : ComponentInteractionCreateEventArgs) =
    async {
        let split = event.Id.Split("-")
        let ( shieldResult , shield ) = Shield.TryParse(split.[1])
        let! playerResult = DbService.tryFindPlayer event.User.Id
        match playerResult , shieldResult with
        | Some player , true ->
            // TODO: All of this is wrong
            let updatedDefenses = removeExpiredActions (TimeSpan.FromHours(6)) (fun (pro : Defense) -> pro.Timestamp) player.Defenses
            let alreadyUsedShield = updatedDefenses |> Array.exists (fun d -> d.DefenseType = shield)

            match alreadyUsedShield , updatedDefenses.Length < 2 with
            | false , true ->
                let builder = DiscordInteractionResponseBuilder()
                let embed = DiscordEmbedBuilder()
                embed.ImageUrl <- Embeds.getShieldGif shield
                builder.IsEphemeral <- true
                builder.AddEmbed embed |> ignore
                builder.Content <- $"Mounted a {shield} defense for 6 hours"
                do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask
                let defense = { DefenseType = shield ; Timestamp = DateTime.UtcNow }
                do! DbService.updatePlayer <| { player with Defenses = Array.append [| defense |] player.Defenses  }
                let builder = DiscordMessageBuilder()
                builder.WithContent($"{event.User.Username} has protected their system!") |> ignore
                let channel = event.Guild.GetChannel(GuildEnvironment.channelEventsHackerBattle)
                do! channel.SendMessageAsync(builder)
                    |> Async.AwaitTask
                    |> Async.Ignore
            | _ , false ->
                let builder = DiscordInteractionResponseBuilder()
                builder.IsEphemeral <- true
                let timestamp = updatedDefenses |> Array.rev |> Array.head |> fun a -> a.Timestamp // This should be the next expiring timestamp
                let cooldown = getTimeTillCooldownFinishes (TimeSpan.FromHours(6)) timestamp
                builder.Content <- $"You are only allowed two shields at a time. Wait {cooldown} minutes to add another shield"
                do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask
                do! DbService.updatePlayer <| { player with Defenses = updatedDefenses }
            | true , _ ->
                let builder = DiscordInteractionResponseBuilder()
                builder.IsEphemeral <- true
                let timestamp = updatedDefenses |> Array.find (fun d -> d.DefenseType = shield) |> fun a -> a.Timestamp
                let cooldown = getTimeTillCooldownFinishes (TimeSpan.FromHours(6)) timestamp
                builder.Content <- $"{shield} shield is already in use. Wait {cooldown} minutes to use this shield again"
                do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask
                do! DbService.updatePlayer <| { player with Defenses = updatedDefenses }

        | _ ->
            let builder = DiscordInteractionResponseBuilder()
            builder.IsEphemeral <- true
            builder.Content <- "Error parsing Button Id"
            do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask
    }

let handleButtonEvent (_ : DiscordClient) (event : ComponentInteractionCreateEventArgs) =
    let task =
        match event.Id with
        | id when id.StartsWith("Attack")  -> handleAttack event
        | id when id.StartsWith("Defend")  -> handleDefense event
        | id when id.StartsWith("Trainer") -> Trainer.handleButtonEvent 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 {
        return! task
    } |> Async.StartAsTask
    :> Task

type HackerGame() =
    inherit ApplicationCommandModule ()

    [<SlashCommand("hack", "Send a hack attack to another player")>]
    member this.AttackCommand (ctx : InteractionContext, [<Option("target", "The player you want to hack")>] target : DiscordUser) =
        let hasTraineeRole = Seq.exists (fun (r : DiscordRole) -> r.Id = GuildEnvironment.roleTrainee) ctx.Member.Roles
        if ctx.Channel.Id = GuildEnvironment.channelTraining && hasTraineeRole then
            Trainer.attack ctx target
        else
            attack ctx target

    [<SlashCommand("defend", "Create a passive defense that will last 24 hours")>]
    member this.DefendCommand (ctx : InteractionContext) =
        let hasTraineeRole = Seq.exists (fun (r : DiscordRole) -> r.Id = GuildEnvironment.roleTrainee) ctx.Member.Roles
        if ctx.Channel.Id = GuildEnvironment.channelTraining && hasTraineeRole then
            Trainer.defend ctx
        else
            defend ctx