module Degenz.Store

open System
open System.Threading.Tasks
open DSharpPlus.Entities
open DSharpPlus
open DSharpPlus.EventArgs
open DSharpPlus.SlashCommands
open Degenz
open Degenz.Embeds
open Degenz.Messaging

let viewStore (ctx : InteractionContext) =
    async {
        do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, Embeds.storeListing Armoury.battleItems)
            |> Async.AwaitTask
    } |> Async.StartAsTask
      :> Task

let buyItem (ctx : InteractionContext) itemType =
    Game.executePlayerAction ctx (fun player -> async {
        let embed = DiscordEmbedBuilder()

//        embed.Fields

        do! ctx.CreateResponseAsync(embed, true)
            |> Async.AwaitTask
    })

let sell (ctx : InteractionContext) =
    Game.executePlayerAction ctx (fun player -> async {
        let hasInventoryToSell = Array.length player.Arsenal > 0
        if hasInventoryToSell then
            let builder = DiscordInteractionResponseBuilder()
            builder.AddEmbed (constructEmbed "Pick the item you wish to sell.") |> ignore

            Array.chunkBySize 5 player.Arsenal
            |> Array.iter
                (fun wps ->
                    wps
                    |> Array.map (fun w -> DiscordButtonComponent(ButtonStyle.Primary, $"{w.Type}-{w.Id}", $"{w.Name}"))
                    |> Seq.cast<DiscordComponent>
                    |> builder.AddComponents
                    |> ignore)
            builder.AsEphemeral true |> ignore

            do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                |> Async.AwaitTask
        else
            do! sendSimpleResponse ctx "You currently have no inventory to sell"
    })

let sellItem (event : ComponentInteractionCreateEventArgs) player itemId =
    async {
        let item = Armoury.battleItems |> Array.find (fun i -> i.Id = itemId)
        let updatedPlayer = { player with Bank = player.Bank + item.Cost ; Arsenal = player.Arsenal |> Array.filter (fun w -> w.Id <> itemId)}
        do! DbService.updatePlayer updatedPlayer
        let builder = DiscordInteractionResponseBuilder()
        builder.IsEphemeral <- true
        builder.Content <- $"Sold {item.Type} {item.Name} for {item.Cost}! Current Balance: {updatedPlayer.Bank}"
        do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
            |> Async.AwaitTask
    }

let handleBuyItem (ctx : InteractionContext) itemId =
    Game.executePlayerAction ctx (fun player -> async {
        let item = Armoury.battleItems |> Array.find (fun w -> w.Id = itemId)
        let newBalance = player.Bank - item.Cost
        if newBalance >= 0<GBT> then
            let playerHasItem = player.Arsenal |> Array.exists (fun w -> item.Id = w.Id)
            if not playerHasItem then
                let p = { player with Bank = newBalance ; Arsenal = Array.append [| item |] player.Arsenal }
                do! DbService.updatePlayer p
                do! sendSimpleResponse ctx $"Successfully purchased {item.Name}! You now have {newBalance} remaining"
            else
                do! sendSimpleResponse ctx $"You already own this item!"
        else
            do! sendSimpleResponse ctx $"You do not have sufficient funds to buy this item! Current balance: {player.Bank} GBT"
    })

let handleSellButtonEvents (_ : DiscordClient) (event : ComponentInteractionCreateEventArgs) =
    async {
        let! playerResult = DbService.tryFindPlayer event.User.Id
        match playerResult with
        | Some player ->
            let itemId = int <| event.Id.Split("-").[1]
            do! sellItem event player itemId
        | None ->
            let builder = DiscordInteractionResponseBuilder()
            builder.IsEphemeral <- true
            builder.Content <- "An error occurred and the user doesn't not exist"
            do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
                |> Async.AwaitTask
    } |> Async.StartAsTask
    :> Task

type Store() =
    inherit ApplicationCommandModule ()
//    [<SlashCommand("view-store", "View items available for purchase")>]

//    member _.ViewStore (ctx : InteractionContext) = viewStore ctx

    [<SlashCommand("buy-hack", "Purchase a hack attack you can use to earn GoodBoyTokenz")>]
    member _.BuyHack (ctx : InteractionContext) = buyItem ctx Hack

    [<SlashCommand("buy-shield", "Purchase a hack shield so you can protect your GoodBoyTokenz")>]
    member this.BuyShield (ctx : InteractionContext) = buyItem ctx Shield

    [<SlashCommand("sell", "Sell an item in your inventory for GoodBoyTokenz")>]
    member this.SellItem (ctx : InteractionContext) = sell ctx