package de.ocame.wuerfelbot.Keeproll;


import de.ocame.wuerfelbot.Earthdawn.EarthdawnLogic;
import de.ocame.wuerfelbot.commands.ICommand;
import de.ocame.wuerfelbot.core.LoggerUtil;
import de.ocame.wuerfelbot.output.DiceOutputFormatter;
import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import net.dv8tion.jda.api.interactions.commands.OptionType;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.interactions.commands.build.Commands;

import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class KeeprollCommand implements ICommand {

    private final KeeprollLogic keeprollLogic;
    private final DiceOutputFormatter outputFormatter;

    public KeeprollCommand() {
        this.keeprollLogic = new KeeprollLogic();
        this.outputFormatter = new DiceOutputFormatter();
    }

    @Override
    public String getName() {
        return "k";
    }

    @Override
    public String getDescription() {
        return "Führt eine X keep Y-Probe mit W10 durch. X > 10 wird 2:1 auf Y Übertragen";
    }

    @Override
    public void executeSlash(SlashCommandInteractionEvent event) {

        Integer numberOfDice = event.getOption("wuerfel").getAsInt();
        Integer diceCount = event.getOption("keep").getAsInt();
        Integer target = event.getOption("ziel") != null ? event.getOption("ziel").getAsInt() : 0;
        Integer modifier = event.getOption("modifier") != null ? event.getOption("modifier").getAsInt() : 0;

        Boolean unskilled = event.getOption("unskilled") != null && event.getOption("unskilled").getAsBoolean();
        Boolean emphases = event.getOption("emphases") != null && event.getOption("emphases").getAsBoolean();
        Integer explode = event.getOption("explode") != null ? event.getOption("explode").getAsInt() : 10;
        Boolean explodedOnce = event.getOption("exploded-once") != null && event.getOption("exploded-once").getAsBoolean();

        if (numberOfDice < 1 || diceCount < 1 || target < 0 || explode < 1 || explode > 10) {
            if (numberOfDice < 1) {
                event.reply(outputFormatter.formatError("Die Anzahl der Würfel muss mindestens 1 sein.")).setEphemeral(true).queue();
            }
            if (diceCount < 1) {
                event.reply(outputFormatter.formatError("Die Anzahl der behaltende Würfelergebnisse muss mindestens 1 sein.")).setEphemeral(true).queue();
            }
            if (target < 0) {
                event.reply(outputFormatter.formatError("Ziel darf nicht negativ sein.")).setEphemeral(true).queue();
            }
            if (explode < 1 || explode > 10) {
                event.reply(outputFormatter.formatError("Würfel können nicht unter 1 oder über 10 Explodieren")).setEphemeral(true).queue();
            }
            return;
        }
        try {
            KeeprollLogic.KeeprollResult result = keeprollLogic.performKeeprollRoll(numberOfDice, diceCount, target, modifier, unskilled, emphases, explode, explodedOnce);
            EmbedBuilder response = outputFormatter.DCDefaultOutput(getEffectiveName(event) + result.getTitle(), result.getDescription(), result.isGlitch());
            event.deferReply().queue();
            event.getHook().editOriginalEmbeds(response.build()).queue();
        } catch (Exception e) {
            LoggerUtil.log("error", "KeeprollCommand", "Fehler bei Keeproll-Probe: " + e.getMessage());
            event.reply(outputFormatter.formatError("Ein Fehler ist bei der Keeproll-Probe aufgetreten.")).setEphemeral(true).queue();
        }
    }

    @Override
    public void executeText(MessageReceivedEvent event, String[] args) {
        if (args.length < 1) {
            event.getChannel().sendMessage(outputFormatter.formatError("Verwendung: `!k <stufe> [karma]`")).queue();
            return;
        }

        Integer numberOfDice = 1;
        Integer diceCount = 1;
        Integer target =  0;
        Integer modifier = 0;

        Boolean unskilled = false;
        Boolean emphases = false;
        Integer explode = 10;
        Boolean explodedOnce = false;

        boolean stufeParsed = false;

        String ContentRaw = event.getMessage().getContentRaw();

        // Prüfen ob Leerer Command gesendet wird
        String[] MsgParts = ContentRaw.replace("  ", " ").split(" ", 2);
        String msgText = MsgParts[1].trim();
        if(msgText.equalsIgnoreCase("help") || msgText.equalsIgnoreCase("hilfe")) {
            event.getChannel().sendMessage(event.getMember().getAsMention() + " "
                    + " Die Syntax lautet XkY z.b. 5k4\nEs werden X mal W10 gewürfelt und davon die höhsten Anzahl Y behalten und addiert. Wird eine 10 gewürfelt, wird der Wurf weiter gewürfelt und addiert aber nur als ein Wurf gezählt.\nWird nach dem XkY eine weiter Zahl angeben so ist dies die Schwierigkeit\n"
                    + "Wird nach dem XkY eine Zahl mit + oder - Angegeben, zählt dies als ein Modifikator für das ergebnis.\n\n"
                    + "Zudem gibt es folgente sonderzeichen, die an belibiger stelle gesetz werden können:\n"
                    + "! - auch gewüfelte 9 explodieren\n"
                    + "e - gewürfelte 1 werden neu gewürfelt\n"
                    + "# - Würfel explodierente nur einmal\n"
                    + "n - Würfel explodierente nicht\n"
            ).queue();

            return;
        }

        if(msgText.contains("!")) {
            explode = 9;
            msgText = msgText.replace("!", "");
        }
        if(msgText.contains("e")) {
            emphases = true;
            msgText = msgText.replace("e", "");
        }
        if(msgText.contains("#")) {
            explodedOnce = true;
            msgText = msgText.replace("#", "");
        }
        if(msgText.contains("n")) {
            unskilled = true;
            msgText = msgText.replace("n", "");
        }

        if(msgText.matches(".*[+-] *[0-9]+.*")) { // Modifikator gefunden
            Pattern pattern = Pattern.compile("([+-]) *([0-9]+)");
            Matcher matcher = pattern.matcher(msgText.toLowerCase());
            matcher.find();
            MatchResult elements = matcher.toMatchResult();
            modifier = Integer.parseInt(elements.group(2));
            if(elements.group(1).equals("-")) {
                modifier *= -1;
            }
            msgText = msgText.replaceFirst("[+-] *[0-9]+", "");
        }

        if(msgText.toLowerCase().matches(".*([0-9]+)k([0-9]+) +([0-9]+).*")) { // XkY Z Aufbau in der Anfrage
            Pattern pattern = Pattern.compile("([0-9]+)k([0-9]+) +([0-9]+)");
            Matcher matcher = pattern.matcher(msgText.toLowerCase());
            matcher.find();
            MatchResult elements = matcher.toMatchResult();
            numberOfDice = Integer.parseInt(elements.group(1));
            diceCount = Integer.parseInt(elements.group(2));
            target = Integer.parseInt(elements.group(3));
        }
        else if(msgText.toLowerCase().matches(".*([0-9]+)k([0-9]+).*")) { // XkY Aufbau in der Anfrage
            Pattern pattern = Pattern.compile("([0-9]+)k([0-9]+)");
            Matcher matcher = pattern.matcher(msgText.toLowerCase());
            matcher.find();
            MatchResult elements = matcher.toMatchResult();
            numberOfDice = Integer.parseInt(elements.group(1));
            diceCount = Integer.parseInt(elements.group(2));
        }

        try {
            KeeprollLogic.KeeprollResult result = keeprollLogic.performKeeprollRoll(numberOfDice, diceCount, target, modifier, unskilled, emphases, explode, explodedOnce);
            EmbedBuilder response = outputFormatter.DCDefaultOutput(getEffectiveName(event) + result.getTitle(), result.getDescription(), result.isGlitch());
            event.getChannel().sendMessageEmbeds(response.build()).queue();
        } catch (Exception e) {
            LoggerUtil.log("error", "KeepCommand", "Fehler bei Keeproll-Probe: " + e.getMessage());
            event.getChannel().sendMessage(outputFormatter.formatError("Ein Fehler ist bei der Keeproll-Probe aufgetreten.")).queue();
        }
    }

    @Override
    public CommandData getSlashCommandData() {
        return Commands.slash(getName(), getDescription())
                .addOption(OptionType.INTEGER, "wuerfel", "Die Anzahl der zu würfelende Würfeln", true)
                .addOption(OptionType.INTEGER, "keep", "Die Anzahl behaltende Würfelergebnisse", true)
                .addOption(OptionType.INTEGER, "ziel", "Ziel Wert, Zeigt optisch Ergebnis an", false)
                .addOption(OptionType.INTEGER, "modifier", "Bonus oder Abzug auf Ergebnis", false)
                .addOption(OptionType.BOOLEAN, "unskilled", "Würfel explodieren nicht", false)
                .addOption(OptionType.BOOLEAN, "emphases", "gewürfelte 1 werden neu gewürfelt", false)
                .addOption(OptionType.INTEGER, "explode", "Ab wann Explodieren Würfel, Standard ist 10", false)
                .addOption(OptionType.BOOLEAN, "exploded-once", "Würfel explodieren nur einmal", false);
    }

    private String getEffectiveName(MessageReceivedEvent event) {
        if (event.getMember() == null) {
            return "";
        }
        return event.getMember().getEffectiveName() + " ";
    }

    private String getEffectiveName(SlashCommandInteractionEvent event) {
        if (event.getMember() == null) {
            return "";
        }
        return event.getMember().getEffectiveName() + " ";
    }

    private static int parseCharacterStat(String currentElement, char targetChar) {
        int result = 0;
        Pattern pattern = Pattern.compile("((" + targetChar + "+) *(\\d*))");
        Matcher matcher = pattern.matcher(currentElement);
        if (matcher.find()) {
            if (matcher.group(2).length() == 1 && !matcher.group(3).isEmpty()) { // nur die K
                result += Integer.parseInt(matcher.group(3));
            } else {
                result += matcher.group(2).length();
            }
        }
        return result;
    }
}