module Degenz.HackerBattle

open System
open System.Text
open System.Threading.Tasks
open DSharpPlus
open DSharpPlus.Entities
open DSharpPlus.EventArgs
open DSharpPlus.SlashCommands
open Degenz
open Degenz.Messaging
open Degenz.PlayerInteractions

let checkPlayerIsAttackingThemselves defender attacker =
    match attacker.DiscordId = defender.DiscordId with
    | true -> Error "You think you're clever? You can't hack yourself, pal."
    | false -> Ok attacker

let checkAlreadyHackedTarget defender attacker =
    defender
    |> Player.removeExpiredActions
    |> fun d -> d.Events
    |> List.tryFind (fun event ->
        match event.Type with
        | Hacking h -> h.Adversary.Id = attacker.DiscordId && h.IsInstigator = false
        | _ -> false)
    |> function
       | Some event ->
           let cooldown = TimeSpan.FromMinutes(int event.Cooldown)
           let cooldownText = getTimeText true cooldown event.Timestamp
           Error $"You can only hack the same target once every {cooldown.Hours} hours, wait {cooldownText} to attempt another hack on <@{defender.DiscordId}>."
       | None -> Ok attacker

let checkWeaponHasCooldown (weapon : Item) attacker =
    attacker.Events
    |> List.tryFind (fun a ->
        match a.Type with
        | Hacking h -> h.HackId = weapon.Id && h.IsInstigator
        | Shielding id -> id = weapon.Id
        | _ -> false)
    |> function
       | Some event ->
          let cooldown = getTimeText true (TimeSpan.FromMinutes(int event.Cooldown)) event.Timestamp
          Error $"{weapon.Name} was recently used, wait another {cooldown} to use it again."
       | None -> Ok attacker

let checkHasEmptyHacks (attacker : PlayerData) =
    match Inventory.getHacks attacker.Inventory with
    | [] -> Error $"You currently do not have any Hacks to take 💰$GBT from others. Please go to the <#{GuildEnvironment.channelTraining}> and complete the training."
    | _ -> Ok attacker

let checkPlayerOwnsWeapon (item : Item) player =
    match player.Inventory |> List.exists (fun i -> i.Id = item.Id) with
    | true -> Ok player
    | false -> Error $"You sold your {item.Name} already, you cheeky bastard..."

let checkPlayerHasShieldSlotsAvailable player =
    let updatedPlayer = player |> Player.removeExpiredActions
    let defenses = Player.getShieldEvents updatedPlayer
    match defenses |> List.length >= 3 with
    | true ->
        let event = defenses |> List.rev |> List.head // This should be the next expiring timestamp
        let cooldown = getTimeText true (TimeSpan.FromMinutes(int event.Cooldown)) event.Timestamp
        Error $"You are only allowed three shields at a time. Wait {cooldown} to add another shield"
    | false -> Ok updatedPlayer

let checkTargetHasFunds target player =
    match target.Bank <= 0<GBT> with
    | true -> Error $"Looks like the poor bastard has no 💰$GBT... pick a different victim."
    | false -> Ok player

let strengthBonus attacker defender =
    attacker - defender
    |> max 0
    |> float
    |> (*) 0.01
    |> (*) 200.0 // Bonus
    |> int

let runHackerBattle defender (hack : HackItem) =
    defender
    |> Player.removeExpiredActions
    |> fun p -> p.Events
    |> List.exists (fun event ->
        match event.Type with
        | Shielding id ->
            let item = Inventory.findItemById id Arsenal.weapons
            match item.Attributes with
            | CanClass c -> hack.Class = c
            | _ -> false
        | _ -> false)

let updateCombatants successfulHack (attacker : PlayerData) (defender : PlayerData) (hack : HackItem) prize =
    let event isDefenderEvent =
        let hackEvent = {
            HackId = hack.Id
            Adversary = if isDefenderEvent then attacker.toDiscordPlayer else defender.toDiscordPlayer
            IsInstigator = not isDefenderEvent
            Success = successfulHack
        }
        { Type = Hacking hackEvent
          Timestamp = DateTime.UtcNow
          Cooldown = if isDefenderEvent then int WeaponClass.SameTargetAttackCooldown.TotalMinutes * 1<mins> else hack.Cooldown }

    [ DbService.updatePlayerCurrency (if successfulHack then prize else -prize) attacker.DiscordId
      DbService.updatePlayerCurrency (if successfulHack then -prize else prize) defender.DiscordId
      DbService.addPlayerEvent attacker.DiscordId (event false)
      DbService.addPlayerEvent defender.DiscordId (event true) ]
    |> Async.Parallel
    |> Async.Ignore

let hackerResult successfulHack (ctx : IDiscordContext) attacker defender (hack : HackItem) =
    async {
        let prizeAmount , bonus =
            if successfulHack then
                let bonus = strengthBonus attacker.Stats.Strength.Amount defender.Stats.Strength.Amount |> gbt
                let basePrize = gbt hack.Power
                (if basePrize + bonus < defender.Bank then basePrize + bonus else defender.Bank) , bonus
            else
                if hack.Power < int attacker.Bank
                    then gbt hack.Power , 0<GBT>
                    else attacker.Bank  , 0<GBT>

        do! updateCombatants successfulHack attacker defender hack prizeAmount

        let! defenderMember = ctx.GetGuild().GetMemberAsync(defender.DiscordId) |> Async.AwaitTask
        let embed = Embeds.responseSuccessfulHack2 successfulHack attacker defender (ctx.GetDiscordMember()) defenderMember prizeAmount bonus hack
        do! ctx.GetChannel().SendMessageAsync(embed)
            |> Async.AwaitTask
            |> Async.Ignore

        let builder = DiscordMessageBuilder().WithAllowedMention(UserMention(defender.DiscordId))
        if successfulHack then
            builder.Content <- $"**{ctx.GetDiscordMember().Username}** successfully hacked **{defender.Name}** and took {prizeAmount} $GBT! - <@!{defender.DiscordId}>"
        else
            builder.Content <- $"Hacking attempt failed! **{defender.Name}** defended hack from **{ctx.GetDiscordMember().Username}** and took {prizeAmount} 💰$GBT from them! <@!{defender.DiscordId}>"
        let channel = ctx.GetGuild().GetChannel(GuildEnvironment.channelEventsHackerBattle)
        do! channel.SendMessageAsync(builder)
            |> Async.AwaitTask
            |> Async.Ignore
    }

let hack (target : DiscordUser) (ctx : IDiscordContext) =
    executePlayerActionWithTarget target ctx (fun attacker defender -> async {
      do! attacker
          |> Player.removeExpiredActions
          |> checkAlreadyHackedTarget defender
          >>= checkTargetHasFunds defender
          >>= checkHasEmptyHacks
          >>= checkPlayerIsAttackingThemselves defender
          |> function
             | Ok atkr -> async {
                 let bonus = strengthBonus attacker.Stats.Strength.Amount defender.Stats.Strength.Amount
                 let embed = Embeds.pickHack "Attack" atkr defender bonus false
                 do! ctx.FollowUp(embed) |> Async.AwaitTask
                 // TODO: Add a call when it's an error with the error type, must include an error code
                 do! Analytics.hackCommand (ctx.GetDiscordMember())
              }
             | Error msg -> sendFollowUpMessage ctx msg
    })

let handleAttack (ctx : IDiscordContext) =
    executePlayerActionNoMsg ctx (fun attacker -> async {
        let tokens = ctx.GetInteractionId().Split("-")
        let hackId = tokens.[1]
        let item = Arsenal.weapons |> Inventory.findItemById hackId
        let hackItem =  (Inventory.getHackItem item).Value
        let resultId , targetId = UInt64.TryParse tokens.[2]
        let! resultTarget = DbService.tryFindPlayer targetId

        match resultTarget , resultId with
        | Some defender , true ->
            do! attacker
                |> Player.removeExpiredActions
                |> checkAlreadyHackedTarget defender
                >>= checkPlayerOwnsWeapon item
                >>= checkTargetHasFunds defender
                >>= checkWeaponHasCooldown item
                |> function
                   | Ok attacker -> async {
                       let result = runHackerBattle defender hackItem
                       do! hackerResult (not result) ctx attacker defender hackItem
                       do! Analytics.hackedTarget (ctx.GetDiscordMember()) hackItem.Name (not result)
                    }
                   | Error msg -> Messaging.sendFollowUpMessage ctx msg
        | _ -> do! Messaging.sendFollowUpMessage ctx "Error occurred processing attack"
    })

let defend (ctx : IDiscordContext) =
    executePlayerAction ctx (fun player -> async {
        if player.Inventory |> Inventory.getShields |> List.length > 0 then
            let p = Player.removeExpiredActions player
            let embed = Embeds.pickDefense "Defend" p false
            do! ctx.FollowUp embed |> Async.AwaitTask
            do! Analytics.shieldCommand (ctx.GetDiscordMember())
        else
            let msg = $"You currently do not have any Shields to protect yourself from hacks. Please go to the <#{GuildEnvironment.channelTraining}> and purchase one."
            do! Messaging.sendFollowUpMessage ctx msg
    })

let handleDefense (ctx : IDiscordContext) =
    executePlayerAction ctx (fun player -> async {
        let tokens = ctx.GetInteractionId().Split("-")
        let shieldId = tokens.[1]
        let item = Arsenal.weapons |> Inventory.findItemById shieldId
        let shieldItem = (Inventory.getShieldItem item).Value

        do! player
            |> checkPlayerOwnsWeapon item
            >>= checkPlayerHasShieldSlotsAvailable
            >>= checkWeaponHasCooldown item
            |> handleResultWithResponse ctx (fun p -> async {
                let embed = Embeds.responseCreatedShield shieldItem
                do! ctx.FollowUp embed |> Async.AwaitTask
                let defense = {
                    Type = Shielding shieldId
                    Cooldown = shieldItem.Cooldown
                    Timestamp = DateTime.UtcNow
                }
                do! DbService.addPlayerEvent p.DiscordId defense |> Async.Ignore
                let builder = DiscordMessageBuilder()
                builder.WithContent($"**{ctx.GetDiscordMember().Username}** has protected their system!") |> ignore
                let channel = ctx.GetGuild().GetChannel(GuildEnvironment.channelEventsHackerBattle)
                do! channel.SendMessageAsync(builder)
                    |> Async.AwaitTask
                    |> Async.Ignore
                do! Analytics.shieldActivated (ctx.GetDiscordMember()) shieldItem.Name
            })
    })

let scan (ctx : IDiscordContext) =
    executePlayerAction ctx (fun player -> async {
        let! targets = DbService.getRandomHackablePlayers (ctx.GetDiscordMember().Id)
        let targets =
            let hackedIds =
                player
                |> Player.removeExpiredActions
                |> fun p -> p.Events
                |> List.choose (fun e -> match e.Type with | Hacking hack -> Some hack.Adversary.Id | _ -> None)
            targets
            |> List.filter (fun t -> hackedIds |> List.exists (fun hid -> hid = t.Id) |> not)
            |> List.truncate 5
        let sb = StringBuilder()
        let mutable count = 0
        for t in targets do
            count <- count + 1
            let result , user = ctx.GetGuild().Members.TryGetValue(t.Id)
            if result then
                sb.AppendLine($"{count}.) **{user.Username}**") |> ignore
            else
                printfn $"Could not find user {t.Id}"
                sb.AppendLine($"{count}.) **{t.Name}**") |> ignore
        let msg =
            if targets.Length > 0 then
                $"**Targets Connected to the Network:**\n\n These are 5 targets you can attempt to hack right now... let's hope they're not shielded!\n\n{sb}"
            else
                $"There don't seem to be any targets available right now"
        let embed =
            DiscordEmbedBuilder()
                .WithColor(DiscordColor.Green)
                .WithDescription(msg)
        let builder =
            DiscordFollowupMessageBuilder()
                .AddEmbed(embed)
                .AsEphemeral(true)
        do! ctx.FollowUp(builder) |> Async.AwaitTask
    })

let arsenal (ctx : IDiscordContext) =
    executePlayerAction ctx (fun player -> async {
        let updatedPlayer = Player.removeExpiredActions player
        let builder = DiscordFollowupMessageBuilder()
        let embed = DiscordEmbedBuilder()
        embed.AddField("Arsenal", Arsenal.statusFormat updatedPlayer) |> ignore
        builder.AddEmbed(embed) |> ignore
        builder.IsEphemeral <- true
        do! ctx.FollowUp(builder) |> Async.AwaitTask
        do! Analytics.arsenalCommand (ctx.GetDiscordMember())
    })

let handleButtonEvent _ (event : ComponentInteractionCreateEventArgs) =
    let eventCtx = DiscordEventContext event :> IDiscordContext
    match event.Id with
    | id when id.StartsWith("Attack")  -> handleAttack eventCtx
    | id when id.StartsWith("Defend")  -> handleDefense eventCtx
    | id when id.StartsWith("Trainer") -> Trainer.handleButtonEvent eventCtx
    | id when id.StartsWith("Steal")   -> Thief.handleSteal eventCtx
    | id when id.StartsWith("RPS")     -> RockPaperScissors.handleRPS eventCtx
    | _ ->
        task {
            let builder = DiscordInteractionResponseBuilder()
            builder.IsEphemeral <- true
            builder.Content <- $"Incorrect Action identifier {eventCtx.GetInteractionId()}"
            do! eventCtx.Respond(InteractionResponseType.ChannelMessageWithSource, builder) |> Async.AwaitTask
        }

let handleMessageCreated _ (event : MessageCreateEventArgs) =
    task {
        if event.Channel.Id = GuildEnvironment.channelTraining && event.Author.Id <> GuildEnvironment.botIdHackerBattle then
            do! Async.Sleep 1000
            do! event.Message.DeleteAsync()
    } :> Task

let BeginnerProtectionHours = 24
let ShieldEvents () = [
    { Timestamp = System.DateTime.UtcNow
      Cooldown =  BeginnerProtectionHours * 60<mins>
      Type = Shielding (string ItemId.FIREWALL) }
    { Timestamp = System.DateTime.UtcNow
      Cooldown =  BeginnerProtectionHours * 60<mins>
      Type = Shielding (string ItemId.ENCRYPTION) }
    { Timestamp = System.DateTime.UtcNow
      Cooldown =  BeginnerProtectionHours * 60<mins>
      Type = Shielding (string ItemId.CYPHER) }
]

let handleMemberUpdated _ (event : GuildMemberUpdateEventArgs) =
    let addedRole (rolesBefore : DiscordRole seq) (rolesAfter : DiscordRole seq) =
        rolesAfter |> Seq.filter ((fun role -> rolesBefore |> Seq.exists (fun r -> role.Id = r.Id)) >> not)
    task {
        let symmetricDifference = addedRole event.RolesBefore event.RolesAfter |> Seq.toList
        match symmetricDifference with
        | [] -> ()
        | role::_ ->
            if role.Name = "Pregen" then
                do! ShieldEvents ()
                    |> List.map (DbService.addPlayerEvent event.Member.Id)
                    |> Async.Parallel
                    |> Async.Ignore
        return ()
    } :> Task

type HackerGame() =
    inherit ApplicationCommandModule ()

    let enforceChannels (ctx : IDiscordContext) (trainerFn : IDiscordContext -> Task) (battleFn : IDiscordContext -> Task) =
        match ctx.GetChannel().Id with
        | id when id = GuildEnvironment.channelTraining ->
            let hasTraineeRole = Seq.exists (fun (r : DiscordRole) -> r.Id = GuildEnvironment.roleTrainee) (ctx.GetDiscordMember().Roles)
            if hasTraineeRole then
                trainerFn ctx
            else
                task {
                    let msg = $"You're currently not in training, either go to <#{GuildEnvironment.channelBattle}> to hack for real, "
                             + "or restart training by clicking on the Pinned embed's button up top."
                    do! Messaging.sendSimpleResponse ctx msg
                }
        | id when id = GuildEnvironment.channelBattle ->
            battleFn ctx
        | _ ->
            task {
                let msg = $"You must go to <#{GuildEnvironment.channelBattle}> channel to hack, shield, or check your arsenal"
                do! Messaging.sendSimpleResponse ctx msg
            }

    [<SlashCommand("arsenal", "Get the Hacks and Shields you own, and which ones are active")>]
    member this.Arsenal (ctx : InteractionContext) =
        enforceChannels (DiscordInteractionContext ctx) (Trainer.handleArsenal) arsenal

    [<SlashCommand("hack", "Send a hack attack to another player")>]
    member this.AttackCommand (ctx : InteractionContext, [<Option("target", "The player you want to hack")>] target : DiscordUser) =
        enforceChannels (DiscordInteractionContext ctx) (Trainer.hack target) (hack target)

    [<SlashCommand("shield", "Create a passive shield that will protect you for a certain time")>]
    member this.ShieldCommand (ctx : InteractionContext) =
        enforceChannels (DiscordInteractionContext ctx) Trainer.defend defend

    [<SlashCommand("scan", "Find 5 targets connected to the network we can try to hack")>]
    member this.ScanCommand (ctx : InteractionContext) =
        enforceChannels (DiscordInteractionContext ctx) scan scan

//    [<SlashCommand("test-autocomplete", "Create a passive defense that will last 24 hours")>]
    member this.TestAutoComplete (ctx : InteractionContext) =
        async {
            let builder = DiscordInteractionResponseBuilder()
            builder.IsEphemeral <- true
            do! ctx.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                |> Async.AwaitTask
        } |> Async.StartAsTask
          :> Task