module Degenz.Store

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

let getItemEmbeds owned (items : Inventory) =
    items
    |> List.countBy (fun item -> item.Id)
    |> List.map (fun (id,count) -> items |> List.find (fun i -> i.Id = id) , count )
    |> List.map (fun (item,count) ->
        let embed = DiscordEmbedBuilder()
        item.Attributes 
        |> List.iter (function
            | Buyable price -> embed.AddField("Price 💰", (if price = 0<GBT> then "Free" else $"{price} $GBT"), true) |> ignore
            | Attackable power ->
                let title = match item.Type with ItemType.Hack -> "$GBT Reward" | _ -> "Power"
                embed.AddField($"{title}  |", string power, true) |> ignore
            | RateLimitable time ->
                let title = match item.Type with ItemType.Hack -> "Cooldown" | ItemType.Shield -> "Active For" | _ -> "Expires"
                let ts = TimeSpan.FromMinutes(int time)
                let timeStr = if ts.Hours = 0 then $"{ts.Minutes} mins" else $"{ts.Hours} hours" 
                embed.AddField($"{title}  |", timeStr, true) |> ignore
            | Stackable max ->
                if owned then
                    embed.AddField($"Total Owned  |", $"{count}", true) |> ignore
                else
                    embed.AddField($"Max Allowed  |", $"{max}", true) |> ignore
            | Modifiable effects ->
                let fx =
                    effects
                    |> List.map (fun f ->
                        match f.Effect with
                        | Min i -> $"{f.TargetStat} Min + {i}"
                        | Max i -> $"{f.TargetStat} Max + {i}"
                        | Add i ->
                            let str = if i > 0 then "Boost" else "Penalty"
                            $"{f.TargetStat} {str} + {i}"
                        | RateMultiplier i -> $"{f.TargetStat} Multiplier - i")
                    |> String.concat "\n"
                embed.AddField($"Effect - Amount    ", $"{fx}", true) |> ignore
            | _ -> ())
        embed
          .WithColor(WeaponClass.getClassEmbedColor item)
          .WithTitle($"{item.Name}")
          |> ignore
        match Embeds.getItemIcon item.Id with
        | Some url -> embed.WithThumbnail(url)
        | None -> embed)
    |> List.map (fun e -> e.Build())
    |> Seq.ofList

let getBuyItemsEmbed (playerInventory : Inventory) (storeInventory : Inventory) =
    let embeds = getItemEmbeds false storeInventory
    let buttons =
        storeInventory
        |> List.map (fun item ->
            if playerInventory |> List.exists (fun i -> i.Id = item.Id)
                then DiscordButtonComponent(WeaponClass.getClassButtonColor item, $"Buy-{item.Id}", $"Own {item.Name}", true)
                else DiscordButtonComponent(WeaponClass.getClassButtonColor item, $"Buy-{item.Id}", $"Buy {item.Name}")
            :> DiscordComponent)

    DiscordFollowupMessageBuilder()
        .AddEmbeds(embeds)
        .AddComponents(buttons)
        .AsEphemeral(true)

let getSellEmbed (items : Inventory) =
    let embeds , buttons =
        items
        |> List.choose (fun item ->
            match item.Attributes with
            | CanSell price ->
                let builder =
                    DiscordEmbedBuilder()
                       .AddField("Sell For 💰", $"{price} $GBT", true)
                       .WithTitle($"{item.Name}")
                       .WithColor(WeaponClass.getClassEmbedColor item)
                       .Build()
                let button = DiscordButtonComponent(WeaponClass.getClassButtonColor item, $"Sell-{item.Id}", $"Sell {item.Name}") :> DiscordComponent
                Some ( builder , button )
            | _ -> None)
        |> List.unzip

    // TODO: We should alert the user that they have no sellable items
    DiscordFollowupMessageBuilder()
        .AddEmbeds(embeds)
        .AddComponents(buttons)
        .AsEphemeral(true)

let checkHasSufficientFunds (item : Item) player =
    match item.Attributes with
    | CanBuy price -> 
        if player.Bank - price >= 0<GBT>
           then Ok player
           else Error $"You do not have sufficient funds to buy this item! Current balance: {player.Bank} GBT"
    | _ -> Error $"{item.Name} item cannot be bought"

let checkDoesntExceedStackCap (item : Item) player =
    let itemCount =
        player.Inventory
        |> List.countBy (fun i -> i.Id)
        |> List.tryFind (fst >> ((=) item.Id))
        |> Option.map snd
    match item.Attributes , itemCount with
    | CanStack max , Some count ->
        if count >= max
            then Error $"You own the maximum allowed amount {item.Name}!"
            else Ok player
    | _ , Some _ -> Error $"You already own this item"
    | _ -> Ok player

let checkSoldItemAlready (item : Item) player =
    if player.Inventory |> List.exists (fun i -> item.Id = i.Id)
        then Ok player
        else Error $"{item.Name} not found in your inventory! Looks like you sold it already."

let checkHasItemsInArsenal itemType items player =
    if List.isEmpty items |> not
        then Ok player
        else Error $"You currently have no {itemType} in your arsenal to sell!"

let buy itemType (ctx : IDiscordContext) =
    executePlayerAction ctx (fun player -> async {
        let playerItems = Inventory.getItemsByType itemType player.Inventory
        try
        let! armoryItems = DbService.getStoreItems (ctx.GetChannel().Id)
        if armoryItems.Length > 0 then
            let itemStore = getBuyItemsEmbed playerItems armoryItems
            do! ctx.FollowUp itemStore |> Async.AwaitTask
            do! Analytics.buyWeaponCommand (ctx.GetDiscordMember()) itemType
        else
            do! Messaging.sendFollowUpMessage ctx "This channel doesn't have anything to sell"
        with ex -> printfn $"{ex.Message}"
    })

let sell itemType getItems (ctx : IDiscordContext) =
    executePlayerAction ctx (fun player -> async {
        let items = getItems player.Inventory
        match checkHasItemsInArsenal itemType items player with
        | Ok _ -> let itemStore = getSellEmbed items
                  do! ctx.FollowUp(itemStore) |> Async.AwaitTask
        | Error e -> do! sendFollowUpMessage ctx e
        do! Analytics.sellWeaponCommand (ctx.GetDiscordMember()) itemType
    })

// TODO: When you buy a shield, prompt the user to activate it
let handleBuyItem (ctx : IDiscordContext) itemId =
    executePlayerAction ctx (fun player -> async {
        let! storeInventory = DbService.getStoreItems (ctx.GetChannel().Id)
        let item = storeInventory |> Inventory.findItemById itemId
        do! player
            |> checkHasSufficientFunds item
            >>= checkDoesntExceedStackCap item
            |> handleResultWithResponse ctx (fun player -> async {
                let price = match item.Attributes with CanBuy price -> price | _ -> 0<GBT>
                do! DbService.updatePlayerCurrency -price player |> Async.Ignore
                do! DbService.addToPlayerInventory player.DiscordId item |> Async.Ignore
                do! sendFollowUpMessage ctx $"Successfully purchased {item.Name}! You now have {player.Bank - price} 💰$GBT remaining"
                do! Analytics.buyWeaponButton (ctx.GetDiscordMember()) item.Name price
            })
    })

let handleSell (ctx : IDiscordContext) itemId =
    executePlayerAction ctx (fun player -> async {
        let item = Armory.weapons |> Inventory.findItemById itemId
        do!
        player
        |> checkSoldItemAlready item
        |> handleResultWithResponse ctx (fun player -> async {
            match item.Attributes with
            | CanSell price ->
                let updatedPlayer = {
                    player with
                        Bank = player.Bank + price
                        Inventory = player.Inventory |> List.filter (fun i -> i.Id <> itemId)
                }
                do!
                [ DbService.updatePlayer updatedPlayer |> Async.Ignore
                  DbService.removeShieldEvent updatedPlayer.DiscordId itemId |> Async.Ignore
                  sendFollowUpMessage ctx $"Sold {item.Name} for {price}! Current Balance: {updatedPlayer.Bank}"
                  Analytics.sellWeaponButton (ctx.GetDiscordMember()) item price ]
                |> Async.Parallel
                |> Async.Ignore
            | _ -> ()
        })
    })

let consume (ctx : IDiscordContext) = PlayerInteractions.executePlayerAction ctx (fun player -> async {
    match player.Inventory |> Inventory.getFoods with
    | [] -> do! Messaging.sendFollowUpMessage ctx "You do not have any items to consume"
    | items -> 
        let embeds = getItemEmbeds true items
        let builder = DiscordFollowupMessageBuilder().AddEmbeds(embeds).AsEphemeral(true)
        do! ctx.FollowUp builder |> Async.AwaitTask
})

let showInventoryEmbed (ctx : IDiscordContext) = PlayerInteractions.executePlayerAction ctx (fun player -> async {
    let embeds = getItemEmbeds true player.Inventory
    let builder = DiscordFollowupMessageBuilder().AddEmbeds(embeds).AsEphemeral(true)
    do! ctx.FollowUp builder |> Async.AwaitTask
})

let showStats (ctx : IDiscordContext) = PlayerInteractions.executePlayerAction ctx (fun player -> async {
    let embed = DiscordEmbedBuilder()
    PlayerStats.stats
    |> List.iter (fun statConfig ->
        let playerStat = PlayerStats.getPlayerStat statConfig player
        let min =
            match statConfig.BaseRange.Min = playerStat.ModRange.Min with
            | true -> $"{statConfig.BaseRange.Min}"
            | false -> $"{statConfig.BaseRange.Min} (+{playerStat.ModRange.Min}) "
        let max =
            match statConfig.BaseRange.Max = playerStat.ModRange.Max with
            | true -> $"{statConfig.BaseRange.Max}"
            | false -> $"{statConfig.BaseRange.Max} (+{playerStat.ModRange.Max}) "
        let field = $"{min} |---------------| {max}"
        embed.AddField(string statConfig.Id , field) |> ignore)
    let builder =
      DiscordFollowupMessageBuilder()
        .AddEmbed(embed)
        .AsEphemeral(true)
    do! ctx.FollowUp builder |> Async.AwaitTask
})

let handleStoreEvents (_ : DiscordClient) (event : ComponentInteractionCreateEventArgs) =
    let ctx = DiscordEventContext event :> IDiscordContext
    let id = ctx.GetInteractionId()
    let itemId = int <| id.Split("-").[1]
    match id with
    | id when id.StartsWith("Buy") -> handleBuyItem ctx itemId
    | id when id.StartsWith("Sell") -> handleSell ctx itemId
    | _ ->
        task {
            let builder = DiscordInteractionResponseBuilder()
            builder.IsEphemeral <- true
            builder.Content <- $"Incorrect Action identifier {id}"
            do! ctx.Respond(InteractionResponseType.ChannelMessageWithSource, builder) |> Async.AwaitTask
        }
        
type Store() =
    inherit ApplicationCommandModule ()

    let enforceChannel (ctx : IDiscordContext) (storeFn : IDiscordContext -> Task) =
        match ctx.GetChannel().Id with
        | id when id = GuildEnvironment.channelArmory -> storeFn ctx
        | _ ->
            task {
                let msg = $"You must go to <#{GuildEnvironment.channelArmory}> channel to buy or sell weapons"
                do! Messaging.sendSimpleResponse ctx msg
            }

//    let checkChannel (ctx : IDiscordContext) (storeFn : IDiscordContext -> Task) =
    let checkChannel (ctx : IDiscordContext) =
        match ctx.GetChannel().Id with
        | id when id = GuildEnvironment.channelBackAlley -> buy ItemType.Hack ctx
        | id when id = GuildEnvironment.channelArmory -> buy ItemType.Shield ctx
        | id when id = GuildEnvironment.channelMarket -> buy ItemType.Food ctx
        | id when id = GuildEnvironment.channelAccessoryShop -> buy ItemType.Accessory ctx
        | _ ->
            task {
                let msg = $"This channel doesn't have any items to sell. Try <#{GuildEnvironment.channelArmory}>"
                do! Messaging.sendSimpleResponse ctx msg
            }

    [<SlashCommand("buy-item", "Purchase an item")>]
    member _.BuyItem (ctx : InteractionContext) = checkChannel (DiscordInteractionContext ctx)

    [<SlashCommand("buy-hack", "Purchase a hack so you can take money from other Degenz")>]
    member _.BuyHack (ctx : InteractionContext) =
        enforceChannel (DiscordInteractionContext(ctx)) (buy ItemType.Hack)

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

    [<SlashCommand("sell-hack", "Sell a hack for GoodBoyTokenz")>]
    member this.SellHack (ctx : InteractionContext) = enforceChannel (DiscordInteractionContext(ctx)) (sell "Hacks" (Inventory.getItemsByType ItemType.Hack))

    [<SlashCommand("sell-shield", "Sell a shield for GoodBoyTokenz")>]
    member this.SellShield (ctx : InteractionContext) = enforceChannel (DiscordInteractionContext(ctx)) (sell "Shields" (Inventory.getItemsByType ItemType.Shield))

    [<SlashCommand("consume", "Consume a food item")>]
    member this.Consume (ctx : InteractionContext) = consume (DiscordInteractionContext ctx)

    [<SlashCommand("inventory", "Check your inventory")>]
    member this.Inventory (ctx : InteractionContext) =
        showInventoryEmbed (DiscordInteractionContext ctx)

    [<SlashCommand("stats", "Check your stats")>]
    member this.Stats (ctx : InteractionContext) =
        showStats (DiscordInteractionContext ctx)