remove stats system

improve operations and make them extendable more easily and let other plugins add operations, like requirements 
move requirements/operations out of ranks class as they will be used in prestiges

src/main/java/sh/okx/rankup/requirements/DeductibleRequirement.java

@@ -0,0 +1,24 @@
+package sh.okx.rankup.requirements;
+
+import org.bukkit.entity.Player;
+import sh.okx.rankup.Rankup;
+
+public abstract class DeductibleRequirement extends Requirement {
+  public DeductibleRequirement(Rankup plugin, String name) {
+    super(plugin, name);
+  }
+
+  protected DeductibleRequirement(Requirement clone) {
+    super(clone);
+  }
+
+  /**
+   * Apply the effect of this requirement to the player.
+   * For money, this could be taking money away from the player.
+   * You can assume that <code>Requirement#check(Player)</code> has been called,
+   * and has returned true immediately prior to this.
+   *
+   * @param player the player to take from
+   */
+  public abstract void apply(Player player);
+}

src/main/java/sh/okx/rankup/requirements/Operation.java

@@ -0,0 +1,7 @@
+package sh.okx.rankup.requirements;
+
+import java.util.List;
+
+public abstract class Operation {
+  public abstract boolean check(List<Boolean> booleans);
+}

src/main/java/sh/okx/rankup/requirements/OperationRegistry.java

@@ -0,0 +1,15 @@
+package sh.okx.rankup.requirements;
+
+import java.util.Map;
+
+public class OperationRegistry {
+  private Map<String, Operation> operations;
+
+  public void addOperation(String name, Operation operation) {
+    operations.put(name.toLowerCase(), operation);
+  }
+
+  public Operation getOperation(String name) {
+    return operations.get(name.toLowerCase());
+  }
+}

src/main/java/sh/okx/rankup/requirements/ReducerOperation.java

@@ -0,0 +1,12 @@
+package sh.okx.rankup.requirements;
+
+import java.util.List;
+
+public abstract class ReducerOperation extends Operation {
+  public abstract boolean check(boolean a, boolean b);
+
+  @Override
+  public boolean check(List<Boolean> booleans) {
+    return booleans.stream().reduce(this::check).orElse(true);
+  }
+}

src/main/java/sh/okx/rankup/requirements/Requirement.java

@@ -0,0 +1,63 @@
+package sh.okx.rankup.requirements;
+
+import lombok.Getter;
+import org.bukkit.entity.Player;
+import sh.okx.rankup.Rankup;
+
+public abstract class Requirement implements Cloneable {
+  protected Rankup plugin;
+  @Getter
+  protected String name;
+  private String value;
+
+  public Requirement(Rankup plugin, String name) {
+    this.plugin = plugin;
+    this.name = name;
+  }
+
+  protected Requirement(Requirement clone) {
+    if (clone != null) {
+      this.plugin = clone.plugin;
+      this.name = clone.name;
+      this.value = clone.value;
+    }
+  }
+
+  public void setValue(String value) {
+    this.value = value;
+  }
+
+  public String getValueString() {
+    return value;
+  }
+
+  public double getValueDouble() {
+    return Double.parseDouble(value);
+  }
+
+  public int getValueInt() {
+    return Integer.parseInt(value);
+  }
+
+
+  /**
+   * Check if a player meets this requirement
+   *
+   * @param player the player to check
+   * @return true if they meet the requirement, false otherwise
+   */
+  public abstract boolean check(Player player);
+
+  /**
+   * Get the remaining amount needed for <code>Requirement#check(Player)</code> to yield true.
+   * This is not required and is only used in placeholders.
+   *
+   * @param player the player to find the remaining amount of
+   * @return the remaining amount needed. Should be non-negative.
+   */
+  public double getRemaining(Player player) {
+    return getValueDouble();
+  }
+
+  public abstract Requirement clone();
+}

src/main/java/sh/okx/rankup/requirements/RequirementRegistry.java

@@ -0,0 +1,23 @@
+package sh.okx.rankup.requirements;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class RequirementRegistry {
+  private Set<Requirement> requirements = new HashSet<>();
+
+  public void addRequirement(Requirement requirement) {
+    requirements.add(requirement);
+  }
+
+  public Requirement newRequirement(String name, String value) {
+    for (Requirement requirement : requirements) {
+      if (requirement.getName().equalsIgnoreCase(name)) {
+        Requirement newRequirement = requirement.clone();
+        newRequirement.setValue(value);
+        return newRequirement;
+      }
+    }
+    return null;
+  }
+}

src/main/java/sh/okx/rankup/requirements/operation/AllOperation.java

@@ -0,0 +1,10 @@
+package sh.okx.rankup.requirements.operation;
+
+import sh.okx.rankup.requirements.ReducerOperation;
+
+public class AllOperation extends ReducerOperation {
+  @Override
+  public boolean check(boolean a, boolean b) {
+    return a && b;
+  }
+}

src/main/java/sh/okx/rankup/requirements/operation/AnyOperation.java

@@ -0,0 +1,10 @@
+package sh.okx.rankup.requirements.operation;
+
+import sh.okx.rankup.requirements.ReducerOperation;
+
+public class AnyOperation extends ReducerOperation {
+  @Override
+  public boolean check(boolean a, boolean b) {
+    return a || b;
+  }
+}

src/main/java/sh/okx/rankup/requirements/operation/NoneOperation.java

@@ -0,0 +1,10 @@
+package sh.okx.rankup.requirements.operation;
+
+import sh.okx.rankup.requirements.ReducerOperation;
+
+public class NoneOperation extends ReducerOperation {
+  @Override
+  public boolean check(boolean a, boolean b) {
+    return !a && !b;
+  }
+}

src/main/java/sh/okx/rankup/requirements/operation/OneOperation.java

@@ -0,0 +1,10 @@
+package sh.okx.rankup.requirements.operation;
+
+import sh.okx.rankup.requirements.ReducerOperation;
+
+public class OneOperation extends ReducerOperation {
+  @Override
+  public boolean check(boolean a, boolean b) {
+    return (a && !b) || (b && !a);
+  }
+}

src/main/java/sh/okx/rankup/requirements/requirement/GroupRequirement.java

@@ -0,0 +1,34 @@
+package sh.okx.rankup.requirements.requirement;
+
+import org.bukkit.entity.Player;
+import sh.okx.rankup.Rankup;
+import sh.okx.rankup.requirements.Requirement;
+
+public class GroupRequirement extends Requirement {
+  public GroupRequirement(Rankup plugin, String name) {
+    super(plugin, name);
+  }
+
+  protected GroupRequirement(Requirement clone) {
+    super(clone);
+  }
+
+  @Override
+  public boolean check(Player player) {
+    OUTER:
+    for (String requiredGroup : getValueString().split(" ")) {
+      for (String group : plugin.getPermissions().getPlayerGroups(player)) {
+        if (group.equalsIgnoreCase(requiredGroup)) {
+          continue OUTER;
+        }
+      }
+      return false;
+    }
+    return true;
+  }
+
+  @Override
+  public Requirement clone() {
+    return new GroupRequirement(this);
+  }
+}

src/main/java/sh/okx/rankup/requirements/requirement/MoneyRequirement.java

@@ -0,0 +1,40 @@
+package sh.okx.rankup.requirements.requirement;
+
+import net.milkbowl.vault.economy.Economy;
+import org.bukkit.entity.Player;
+import sh.okx.rankup.Rankup;
+import sh.okx.rankup.requirements.DeductibleRequirement;
+import sh.okx.rankup.requirements.Requirement;
+
+public class MoneyRequirement extends DeductibleRequirement {
+  public MoneyRequirement(Rankup plugin, String name) {
+    super(plugin, name);
+  }
+
+  protected MoneyRequirement(Requirement clone) {
+    super(clone);
+  }
+
+  @Override
+  public boolean check(Player player) {
+    Economy economy = plugin.getEconomy();
+    double balance = economy.getBalance(player);
+    return balance >= getValueDouble();
+  }
+
+  @Override
+  public void apply(Player player) {
+    Economy economy = plugin.getEconomy();
+    economy.withdrawPlayer(player, getValueDouble());
+  }
+
+  @Override
+  public double getRemaining(Player player) {
+    return Math.max(0, getValueDouble() - plugin.getEconomy().getBalance(player));
+  }
+
+  @Override
+  public Requirement clone() {
+    return new MoneyRequirement(this);
+  }
+}

src/main/java/sh/okx/rankup/requirements/requirement/PlaytimeMinutesRequirement.java

@@ -0,0 +1,41 @@
+package sh.okx.rankup.requirements.requirement;
+
+import org.bukkit.Statistic;
+import org.bukkit.entity.Player;
+import sh.okx.rankup.Rankup;
+import sh.okx.rankup.requirements.Requirement;
+
+public class PlaytimeMinutesRequirement extends Requirement {
+  private static final int TICKS_PER_MINUTE = 20 * 60;
+  private Statistic playOneTick;
+
+  public PlaytimeMinutesRequirement(Rankup plugin, String name) {
+    super(plugin, name);
+    try {
+      playOneTick = Statistic.valueOf("PLAY_ONE_MINUTE");
+    } catch (IllegalArgumentException e) {
+      // statistic was changed in 1.13.
+      playOneTick = Statistic.valueOf("PLAY_ONE_TICK");
+    }
+  }
+
+  protected PlaytimeMinutesRequirement(PlaytimeMinutesRequirement clone) {
+    super(clone);
+    this.playOneTick = clone.playOneTick;
+  }
+
+  @Override
+  public boolean check(Player player) {
+    return player.getStatistic(playOneTick) * TICKS_PER_MINUTE >= getValueDouble();
+  }
+
+  @Override
+  public double getRemaining(Player player) {
+    return Math.max(0, getValueDouble() - (player.getStatistic(playOneTick) * TICKS_PER_MINUTE));
+  }
+
+  @Override
+  public Requirement clone() {
+    return new PlaytimeMinutesRequirement(this);
+  }
+}

src/main/java/sh/okx/rankup/requirements/requirement/XpLevelRequirement.java

@@ -0,0 +1,36 @@
+package sh.okx.rankup.requirements.requirement;
+
+import org.bukkit.entity.Player;
+import sh.okx.rankup.Rankup;
+import sh.okx.rankup.requirements.DeductibleRequirement;
+import sh.okx.rankup.requirements.Requirement;
+
+public class XpLevelRequirement extends DeductibleRequirement {
+  public XpLevelRequirement(Rankup plugin, String name) {
+    super(plugin, name);
+  }
+
+  protected XpLevelRequirement(Requirement clone) {
+    super(clone);
+  }
+
+  @Override
+  public boolean check(Player player) {
+    return player.getLevel() >= getValueInt();
+  }
+
+  @Override
+  public void apply(Player player) {
+    player.setLevel(player.getLevel() - getValueInt());
+  }
+
+  @Override
+  public double getRemaining(Player player) {
+    return Math.max(0, getValueInt() - player.getLevel());
+  }
+
+  @Override
+  public Requirement clone() {
+    return new XpLevelRequirement(this);
+  }
+}