import { getGuildSetting } from "../tools/data";
import { Badword, database, GuildSetting } from "../data";
import { Console } from "console";

const console = new Console(process.stdout);

export default async function execute(args: string[]) {
    const command = args[0];
    if (!command) return printHelp();

    switch (command.toLowerCase()) {
        case "info": {
            if (!args[1]) return printHelp();
            const settings = await getGuildSetting(args[1]);
            const wordCount = await database.getRepository(Badword).count({
                where: {
                    guildID: args[1]
                }
            });

            console.log(`Guild ${args[1]}:
    - Preserve Settings: ${settings.preserveDataOnGuildLeave ? "ENABLED" : "DISABLED"}
    - Logchannel: ${settings.notificationChannelID ? `ENABLED (${settings.notificationChannelID})` : "DISABLED"}
    - blocked Words: ${wordCount}`);
            break;
        }

        case "words": {
            if (!args[1] || !args[2]) return printWordHelp();

            const badWords = await database.getRepository(Badword).find({
                where: {
                    guildID: args[2]
                }
            });

            switch (args[1].toLowerCase()) {
                case "get": {
                    console.log(`Bad words for ${args[2]}:\n\n${badWords.map((badWord) => badWord.value).reduce((prev, next) => prev + ", " + next, "").slice(2)}`);
                    break;
                }

                case "add": {
                    if (!args[3]) {
                        printWordHelp();
                        break;
                    }

                    if (badWords.filter(w => w.value === args[3]!.toLowerCase()).length > 0) {
                        console.log("Word already exists");
                        break;
                    }

                    const badWord = new Badword();
                    badWord.guildID = args[2];
                    badWord.value = args[3].toLowerCase();

                    await database.getRepository(Badword).save(badWord);
                    console.log(`${args[3].toLowerCase()} added to guild ${args[2]}`);
                    break;
                }

                case "remove": {
                    if (!args[3]) {
                        printWordHelp();
                        break;
                    }

                    const badWord = badWords.find((w) => w.value === args[3]?.toLowerCase());

                    if (!badWord) {
                        console.log(`${args[3].toLowerCase()} is not in blocklist of guild ${args[2]}`);
                        break;
                    }

                    await database.getRepository(Badword).delete({
                        id: badWord.id
                    });

                    console.log(`${badWord.value} deleted for guild ${args[2]}`);
                    break;
                }

                case "clear": {
                    await database.getRepository(Badword).delete({
                        guildID: args[2]
                    });

                    console.log(`Deleted ${badWords.length} entries`);
                    break;
                }

                default: {
                    printHelp();
                    break;
                }
            }

            break;
        }

        case "delete": {
            if (!args[1]) return printHelp();

            await database.getRepository(GuildSetting).delete({
                id: args[1]
            });

            await database.getRepository(Badword).delete({
                guildID: args[1]
            });

            console.log(`Deleted all data for guild ${args[1]}`);
            break;
        }

        default: {
            printHelp();
            break;
        }
    }
}


function printHelp() {
    console.log(`Usage "guild":

guild info [GUILDID]
guild words [get|add|remove|clear]
guild delete [GUILDID]`);
}

function printWordHelp() {
    console.log(`Usage "guild words":

guild words get [GUILDID]
guild words add [GUILDID] [WORD]
guild words remove [GUILDID] [WORD]
guild words clear [GUILDID]`);
}