package com.dorilahav.elusive.configuration;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
import org.bukkit.command.CommandSender;

import java.beans.ConstructorProperties;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.regex.Pattern;

public class Message {

    private final String
            content;

    private final boolean
            error;

    private final List<String>
            availableVariables;

    @JsonCreator
    @ConstructorProperties({ "content", "error", "availableVariables" })
    public Message(String content, boolean error, List<String> availableVariables) {
        this.content = content;
        this.error = error;
        this.availableVariables = availableVariables;
    }

    @JsonIgnore
    public Message(String content, boolean error, String... availableVariables) {
        this.content = content;
        this.error = error;
        this.availableVariables = Arrays.asList(availableVariables);
    }


    // Parses the content that was specified in the object with the entered variables and processes color changes on the content.
    public String parse(Object... variables) {
        return parseColors(parseVariables(content, variables), (error ? Config.MESSAGE_ERROR_COLOR : Config.MESSAGE_MAIN_COLOR), Config.MESSAGE_ARGUMENTS_COLOR);
    }

    // Parses the content that was specified in the object with the entered variables.
    public String parseVariables(String content, Object... variables) {
        String output = content;

        for (int i = 0; i < availableVariables.size(); i++) {

            if (i >= variables.length)
                break;

            String name = availableVariables.get(i);
            Object value = variables[i];

            output = parseVariable(output, name, value);
        }

        return output;
    }

    // Parses the content with one specific variable with the specified name and value.
    public String parseVariable(String content, String name, Object value) {
        String output = content;

        if (output.toLowerCase().contains("%" + name.toLowerCase() + "%"))
            output = output.replaceAll("(?i)" + Pattern.quote("%" + name + "%"), value.toString());

        if (!subArguments.containsKey(value.getClass()))
            return output;

        for (SubArgument subArgument : subArguments.get(value.getClass()))
            if (output.toLowerCase().contains("%" + name.toLowerCase() + ":" + subArgument.getName().toLowerCase() + "%"))
                output = output.replaceAll("(?i)" + Pattern.quote("%" + name + ":" + subArgument.getName() + "%"), subArgument.process.apply(value).toString());

        return output;
    }

    // Replaces the content with the specified colors whenever there is a {} with a text between it.
    public String parseColors(String content, String bodyColor, String argumentsColor) {
        String output = content;

        output = bodyColor + output;
        output = output.replaceAll("\\{(.+)}", argumentsColor + "$1" + bodyColor);

        return output;
    }

    // Sends the message to the specified sender and uses the specified variables as the variables to parse.
    public void send(CommandSender sender, Object... variables) {
        sender.sendMessage(parse(variables));
    }

    // This variable contains all the sub arguments that has been registered!
    @JsonIgnore
    private static final Map<Class<?>, Set<SubArgument<?>>>
            subArguments = new ConcurrentHashMap<>();

    public static void registerSubArgument(SubArgument<?> subArgument) {
        if (!subArguments.containsKey(subArgument.getType()))
            subArguments.put(subArgument.getType(), ConcurrentHashMap.newKeySet());

        subArguments.get(subArgument.getType()).add(subArgument);
    }

    public static <T> void registerSubArgument(Class<T> type, String name, Function<T, Object> process) {
        registerSubArgument(new SubArgument<>(type, name, process));
    }

    // Create sub variables to get values out of an argument.
    @AllArgsConstructor
    public static class SubArgument<T> {

        @Getter(value = AccessLevel.PROTECTED)
        private final Class<T>
                type;

        @Getter(value = AccessLevel.PROTECTED)
        private final String
                name;

        @Getter(value = AccessLevel.PROTECTED)
        private final Function<T, Object>
                process;

    }

}