const { MongoClient, ServerApiVersion } = require('mongodb');
require('dotenv').config();
const uri = process.env.URI
const cookieSchema = require("../schemas/cookieSchema")
const cooldownSchema = require("../schemas/cooldownSchema")
const delay = ms => new Promise(resolve => setTimeout(resolve, ms))
const Discord = require('discord.js')
const client = new MongoClient(uri, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
    serverApi: ServerApiVersion.v1
});
function msToTime(duration) {
    var milliseconds = parseInt((duration % 1000) / 100),
        seconds = Math.floor((duration / 1000) % 60),
        minutes = Math.floor((duration / (1000 * 60)) % 60),
        hours = Math.floor((duration / (1000 * 60 * 60)) % 24);

    hours = (hours < 10) ? "0" + hours : hours;
    minutes = (minutes < 10) ? "0" + minutes : minutes;
    seconds = (seconds < 10) ? "0" + seconds : seconds;

    return hours + ":" + minutes + ":" + seconds;
}
async function collect(interaction, user) {
    client.connect(async (err, db) => {
        var dbo = db.db('test')
        let id = `${interaction.guildId}-${interaction.user.id}-${interaction.commandName}-${interaction.options._subcommand}`
        dbo.collection('cooldowns').findOne({
            _id: id
        }, async function (err, results) {
            let now = Date.now()
            let time = now + 3600000 // plus one hour in ms
            if (results) {
                if (results.cooldown > now) {
                    time = new Date(results.cooldown).toUTCString()
                    return interaction.reply({
                        content: `The batch is still cooking, come back in **${msToTime(results.cooldown - now)}**`,
                        ephemeral: true
                    })
                }
            }
            addCooldown(interaction.user.id, interaction.guildId, interaction.commandName, interaction.options._subcommand, time)

            
            var amount = Math.floor(Math.random() * 30)
            //random amount between 1 and 29
            if (user.id == "378135175059603457") {
                //Abra Bonus
                amount = Math.ceil(amount * 1.5)
            }

            var responses = [
                `${user}, I made you **${amount}** ${amount == 1?`Cookie`: `Cookies`} 🍪 `,
                `${user}, Here's your **${amount}** ${amount == 1?`Cookie`: `Cookies`} 🍪 I ate the rest, sorry >.<`,
                `Only **${amount}** ${amount == 1?`Cookie`: `Cookies`} 🍪 for you today ${user}... Abra stole the rest :c`,
                `${user}, would you like a Glass of Milk with your **${amount}** ${amount == 1?`Cookie`: `Cookies`}? 🍪 `,
                `**${amount}** ${amount == 1?`Cookie`: `Cookies`} 🍪 Careful, ${user}! They're still warm :3`,
                `**${amount}** ${amount == 1?`Cookie`: `Cookies`} 🍪 Best Batch yet!`,
                `**${amount}** ${amount == 1?`Cookie`: `Cookies`} 🍪 These, I bequeath unto thine own self upon this day. Thou must guard them safely.`,
            ]
  
            await cookieSchema.findOneAndUpdate({
                _id: user.id
            }, {
                _id: user.id,
                user: user.username,
                $inc: { cookies: +amount }
            }, {
                upsert: true
            })

            if(amount === 0){
                interaction.reply({
                    content: `${user}, someone ate all your Cookies already D:`
                })
            } else {
                var i = Math.floor(Math.random() * responses.length)
                interaction.reply({
                    content: responses[i]
                })
            }
            // choose response
        })
    })
}
/*
function steal(interaction, user) {
    client.connect(async (err, db) => {
        if (err) throw err;
        let target = interaction.options.getUser('target')
        let dbo = db.db("test")

        if (target.id == user.id) {
            return interaction.reply({
                content: `C'mon, don't embarass yourself! We all know you couldn't do that, even if you tried.`,
                ephemeral: true,
            })
        }

        // get your amount of cookies
        let your = await dbo.collection('cookies').findOne({
            _id: user.id
        })
        // get their amount of cookies
        let their = await dbo.collection('cookies').findOne({
            _id: target.id
        })
        try {
            if (!your.cookies) {
                return interaction.reply({
                    content: `You need at least 1 Cookie to attempt a Robbery`,
                    ephemeral: true,
                })
            }
            if (!their.cookies) {
                return interaction.reply({
                    content: `Shame on you! They don't even have any Cookies D:`,
                    ephemeral: true,
                })
            }
        } catch (error) {
            return interaction.reply({
                content: `How awkward...I don't know some of you!`,
                ephemeral: true,
            })
        }
        let difficulty = []
        for (var i = 0; i < their.cookies; i++) {
            if (i < your.cookies) {
                difficulty.push(true)
            } else {
                difficulty.push(false)
            }
        }
        let result = Math.floor(Math.random() * their.cookies) + 1
        let response
        if (!difficulty[result]) {
            // author lost
            response = `You were unsuccessful at robbing **${target.username}** and lost your chance at **${result}** ${result == 1?`Cookie`: `Cookies`}! `
            if (your.cookies - result <= 0) {
                result = your.cookies
                response += `That's all your Cookies gone.`
            }
            result *= -1

        } else {
            //author won
            response = `You've successfully stolen **${result<their.cookies?result:their.cookies}** ${result == 1?`Cookie`: `Cookies`} from **${target.username}**! `
            if (their.cookies - result <= 0) {
                result = their.cookies
                response += `They're completely dry now.`
            }
        }
        interaction.reply({
            content: response
        })

        //update author's cookies
        await cookieSchema.findOneAndUpdate({
            _id: user.id
        }, {
            _id: user.id,
            user: user.username,
            $inc: { cookies: +result } //will decrease if it's +negativeInteger
        }, {
            upsert: true
        })

        await cookieSchema.findOneAndUpdate({
            _id: target.id
        }, {
            _id: target.id,
            user: target.username,
            $inc: { cookies: -result } //will decrease if it's +negativeInteger
        }, {
            upsert: true
        })
    })



}
*/
async function steal(interaction, user) {
    const target = interaction.options.getUser('target');

    if (!target || target.id === user.id) {
        return interaction.reply({
            content: `You can't steal from yourself!`,
            ephemeral: true
        });
    }

    const dbo = client.db("test");

    const [yourCookies, theirCookies] = await Promise.all([
        dbo.collection('cookies').findOne({ _id: user.id }) || { cookies: 0 },
        dbo.collection('cookies').findOne({ _id: target.id }) || { cookies: 0 }
    ]);

    if (yourCookies.cookies <= 0) {
        return interaction.reply({
            content: `You need at least 1 cookie to attempt a robbery.`,
            ephemeral: true
        });
    }

    if (theirCookies.cookies <= 0) {
        return interaction.reply({
            content: `${target.username} has no cookies to steal!`,
            ephemeral: true
        });
    }

    // Fair success chance: attackerCookies / (attackerCookies + defenderCookies)
    const successChance = yourCookies.cookies / (yourCookies.cookies + theirCookies.cookies);
    const success = Math.random() < successChance;

    // Random steal amount between 1 and 1/3 of victim's cookies
    const maxSteal = Math.max(1, Math.floor(theirCookies.cookies / 3));
    let stealAmount = Math.floor(Math.random() * maxSteal) + 1;

    let message;
    if (success) {
        stealAmount = Math.min(stealAmount, theirCookies.cookies);
        await Promise.all([
            cookieSchema.updateOne({ _id: user.id }, { $inc: { cookies: stealAmount }, $set: { user: user.username } }, { upsert: true }),
            cookieSchema.updateOne({ _id: target.id }, { $inc: { cookies: -stealAmount }, $set: { user: target.username } }, { upsert: true })
        ]);
        message = `You successfully stole **${stealAmount}** 🍪 from **${target.username}**!`;
    } else {
        // Penalty: lose up to half of attempted amount
        stealAmount = Math.min(stealAmount, yourCookies.cookies);
        await Promise.all([
            cookieSchema.updateOne({ _id: user.id }, { $inc: { cookies: -stealAmount }, $set: { user: user.username } }, { upsert: true }),
            cookieSchema.updateOne({ _id: target.id }, { $inc: { cookies: stealAmount }, $set: { user: target.username } }, { upsert: true })
        ]);
        message = `You failed to steal from **${target.username}** and lost **${stealAmount}** 🍪 as punishment!`;
    }

    return interaction.reply({ content: message });
}

function check(interaction, user) {

    client.connect(async function (err, db) {
        let target = interaction.options.getUser('target')

        if (!target) {
            target = user
        }
        let response = `**${target.username}** has `
        let dbo = db.db("test")
        dbo.collection("cookies").findOne({
            _id: target.id
        }, function (err, results) {
            let cookies
            if (!results) {
                cookies = 0
                response += `**${cookies}** Cookies! 😔`
            } else {
                cookies = results.cookies
                response += `**${cookies}** Cookies! 😲`
            }
            interaction.reply({
                content: response
            })
        })
    })
}
async function give(interaction, user) {
    client.connect(async function (err, db) {
        let target = interaction.options.getUser('target')
        let amount = interaction.options.getInteger('amount')
        let dbo = db.db('test')

        //check if you have enough cookies
        let your = await dbo.collection('cookies').findOne({
            _id: user.id
        })

        if (target.id == user.id) {
            return interaction.reply({
                content: 'You cannot give yourself Cookies ._."'
            })
        }
        if (your.cookies < amount) {
            return interaction.reply({
                content: `We don't run a charity here, get more Cookies!`
            })
        }
        if (amount < 1) {
            return interaction.reply({
                content: `**${user}** shared *checks notes* **${amount}** Cookie(s) with ${target}....wait a minute!!`,
            })
        }

        //update user's cookies
        await cookieSchema.findOneAndUpdate({
            _id: user.id
        }, {
            _id: user.id,
            user: user.username,
            $inc: { cookies: -amount }
        }, {
            upsert: true
        })

        //update target's cookies
        await cookieSchema.findOneAndUpdate({
            _id: target.id
        }, {
            _id: target.id,
            user: target.username,
            $inc: { cookies: +amount }
        }, {
            upsert: true
        })
        await delay(200)
        interaction.reply({
            content: `**${user}** shared **${amount}** Cookie(s) with ${target}`
        })

    })
}
async function addCooldown(userId, guildId, command, subcommand, ms) {
    let id = `${guildId}-${userId}-${command}-${subcommand}`
    await cooldownSchema.findOneAndUpdate({
        _id: id
    }, {
        _id: id,
        command: command,
        subcommand: subcommand,
        cooldown: ms
    }, {
        upsert: true
    })
}
async function leader(interaction) {
    const results = await cookieSchema.find().sort({
        cookies: -1
    }).limit(10)
    let cookieSorted = ''
    let i = 0
    results.forEach((result) => {
        cookieSorted += `[${i + 1}] <@${result._id}> (${result.cookies})\n`
        i++;
    })

    var embed = new Discord.MessageEmbed()
        .setColor(0x0099FF)
        .setThumbnail(interaction.guild.iconURL())
        .setTimestamp()
        .addFields({ name: `-Cookie Leaderboard-`, value: cookieSorted })

    interaction.reply({
        embeds: [embed]
    })
}
module.exports = {
    slash: true,
    description: 'collect a cookie',
    category: 'Misc',
    options: [
        //collect
        {
            name: "collect",
            description: "want some?",
            type: 1 // SubCommand Type
        },
        //steal
        {
            name: "steal",
            description: "try your luck at a lala robbery!",
            type: 1, // SubCommand Type
            options: [
                {
                    name: "target",
                    description: "someone",
                    required: true,
                    type: 6 // User Type
                }
            ]
        },
        //check
        {
            name: "check",
            description: "check your cookie stash",
            required: false,
            type: 1, // SubCommand Type
            options: [
                {
                    name: "target",
                    description: "someone",
                    type: 6 // User Type
                }
            ]
        },
        //give
        {
            name: "give",
            description: "share your cookies with someone",
            required: false,
            type: 1, // SubCommand Type
            options: [
                {
                    name: "target",
                    description: "someone",
                    required: true,
                    type: 6 // User Type
                }, {
                    name: "amount",
                    description: "cookies",
                    required: true,
                    type: 4 // Integer Type
                }
            ]
        },
        //leader
        {
            name: "leader",
            description: "show Top 10 Cookie Clickers",
            type: 1, // SubCommand Type
        },
    ],
    callback: ({ interaction, user }) => {
        switch (interaction.options._subcommand) {
            case "collect":
                collect(interaction, user)
                break;
            case "steal":
                steal(interaction, user)
                break;
            case "check":
                check(interaction, user)
                break;
            case "give":
                give(interaction, user)
                break;
            case "leader":
                leader(interaction)
                break;
            default:
                break;
        }
    }
}