Feat/filters and onslaught

src/main/java/com/synops/replayreader/common/comparator/SortingComparators.java

@@ -39,6 +39,8 @@ public void initMap() {
         new SortingHolder(new PlayerListComparatorInt(replayService::getAvgBlocked)));
     this.map.put(PlayerSort.XP.getResourceBundleName(),
         new SortingHolder(new PlayerListComparatorInt(replayService::getAvgXp)));
+    this.map.put(PlayerSort.PRESTIGE_POINTS.getResourceBundleName(),
+        new SortingHolder(new PlayerListComparatorInt(replayService::getComp7PrestigePoints)));
   }
 
   public Comparator<String> getComparator(String sort) {

src/main/java/com/synops/replayreader/common/util/Constants.java

@@ -4,6 +4,7 @@ public class Constants {
   public static final String APP_NAME = "Replay Reader";
   public static final String CLAN_ALL = "<all>";
   public static final String CLAN_LESS = "<clanless>";
+  public static final String MAP_ALL = "<all>";
   public static final String OVERALL = "<overall>";
   public static final int JSON_DEPTH = 3;
 }

src/main/java/com/synops/replayreader/maps/comparator/MapListComparator.java

@@ -0,0 +1,31 @@
+package com.synops.replayreader.maps.comparator;
+
+import static com.synops.replayreader.common.util.Constants.MAP_ALL;
+
+import java.util.Comparator;
+import java.util.function.Function;
+import org.springframework.stereotype.Component;
+
+@Component
+public class MapListComparator implements Comparator<String> {
+
+  private Function<String, Integer> function;
+
+  public MapListComparator() {
+  }
+
+  public void configure(Function<String, Integer> function) {
+    this.function = function;
+  }
+
+  @Override
+  public int compare(String map1, String map2) {
+    int valueMap1 = function.apply(map1);
+    int valueMap2 = function.apply(map2);
+    if (MAP_ALL.equals(map1)) {
+      valueMap1 = Integer.MAX_VALUE;
+    }
+
+    return Integer.compare(valueMap2, valueMap1);
+  }
+}

src/main/java/com/synops/replayreader/maps/util/MapStringConverter.java

@@ -0,0 +1,55 @@
+package com.synops.replayreader.maps.util;
+
+import static com.synops.replayreader.common.util.Constants.MAP_ALL;
+
+import com.synops.replayreader.common.i18n.I18nUtils;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+import java.util.function.Function;
+import javafx.util.StringConverter;
+import org.springframework.stereotype.Component;
+
+@Component
+public class MapStringConverter extends StringConverter<String> {
+
+  private final ResourceBundle resourceBundle = I18nUtils.getBundle();
+  private Function<String, Integer> function;
+  private int totalGamesCount;
+
+  public MapStringConverter() {
+  }
+
+  public void configure(Function<String, Integer> function, int totalGamesCount) {
+    this.function = function;
+    this.totalGamesCount = totalGamesCount;
+  }
+
+  @Override
+  public String toString(String mapString) {
+    if (mapString == null) {
+      return null;
+    }
+
+    if (MAP_ALL.equals(mapString)) {
+      return String.format("%s (%d)", mapString, totalGamesCount);
+    }
+
+    int gamesCount = function.apply(mapString);
+    String mapName = getMapName(mapString);
+
+    return String.format("%s (%d)", mapName, gamesCount);
+  }
+
+  @Override
+  public String fromString(String mapString) {
+    return mapString;
+  }
+
+  private String getMapName(String map) {
+    try {
+      return resourceBundle.getString(map);
+    } catch (MissingResourceException exception) {
+      return map;
+    }
+  }
+}

src/main/java/com/synops/replayreader/player/model/PlayerSort.java

@@ -8,7 +8,8 @@ public enum PlayerSort {
       "penrate", "textPenRate", "main.toolbar.sort.pen-rate"), TEAMDMG("team dmg", "textTeamDmg",
       "main.toolbar.sort.team-damage"), ASSIST("assist", "textAssist",
       "main.toolbar.sort.assist"), BLOCKED("dmg blocked", "textBlocked",
-      "main.toolbar.sort.damage-blocked"), XP("xp", "textXP", "main.toolbar.sort.damage-xp");
+      "main.toolbar.sort.damage-blocked"), XP("xp", "textXP", "main.toolbar.sort.damage-xp"), PRESTIGE_POINTS(
+      "prestige points", "textPrestigePoints", "main.toolbar.sort.prestige-points");
 
   private final String text;
   private final String elementId;

src/main/java/com/synops/replayreader/replay/dto/StatsVehiclesPOJO.java

@@ -13,6 +13,7 @@ public class StatsVehiclesPOJO {
   public int damageAssistedTrack;
   public int damageBlockedByArmor;
   public int damageReceivedFromInvisibles;
+  public int equipmentDamageDealt;
   public int spotted;
   public int capturePoints;
   public int flagCapture;
@@ -25,6 +26,8 @@ public class StatsVehiclesPOJO {
   public int mileage;
   public String killerID;
   public int health;
+  public int healthRepair;
+  public int alliedHealthRepair;
   public String team;
   public int lifeTime;
   public int directHits;
@@ -34,4 +37,5 @@ public class StatsVehiclesPOJO {
   public int damageAssistedStun;
   public int stunNum;
   public int tkills;
+  public int comp7PrestigePoints;
 }

src/main/java/com/synops/replayreader/replay/model/ReplayCollection.java

@@ -7,6 +7,8 @@
 public interface ReplayCollection {
   Set<String> getUniquePlayers();
 
+  Set<String> getUniquePlayersIgnoringMapFilter();
+
   List<String> getUniquePlayersClan(String clanAbbrev);
 
   List<String> getVehiclesForPlayer(String player);
@@ -15,7 +17,7 @@ public interface ReplayCollection {
 
   Player getPlayerInfo(String player);
 
-  void updateReplayFilter(ReplayFilter replayFilter);
+  void setMapFilter(String map);
 
   int getNumberOfClanPlayers(String clan);
 
@@ -25,7 +27,9 @@ public interface ReplayCollection {
 
   List<String> getMaps(String player, String vehicle);
 
-  int getNumberOfMapsPlayed(String player, String vehicle, String map);
+  int getNumberOfGamesOnMap(String map);
+
+  int getTotalGames();
 
   double getWinRate(String player, String vehicle);
 
@@ -43,6 +47,10 @@ public interface ReplayCollection {
 
   int getAvgBlocked(String player, String vehicle);
 
+  int getAvgHealthRepair(String player, String vehicle);
+
+  int getAvgAlliedHealthRepair(String player, String vehicle);
+
   int getAvgLifeTime(String player, String vehicle);
 
   int getAvgHitsReceived(String player, String vehicle);
@@ -51,6 +59,8 @@ public interface ReplayCollection {
 
   int getAvgDamageReceivedFromInvisibles(String player, String vehicle);
 
+  int getAvgEquipmentDamageDealt(String player, String vehicle);
+
   double getAvgShots(String player, String vehicle);
 
   int getAvgTDamageDealt(String player, String vehicle);
@@ -72,4 +82,6 @@ public interface ReplayCollection {
   double getAvgXPRank(String player, String vehicle);
 
   double getAvgDamageRank(String player, String vehicle);
+
+  int getComp7PrestigePoints(String player, String vehicle);
 }

src/main/java/com/synops/replayreader/replay/model/ReplayCollectionImpl.java

@@ -37,11 +37,14 @@ public List<Replay> load(@NonNull Triple<String, String, ReplayFilter> key) {
         String player = key.getLeft();
         String vehicle = key.getMiddle();
         ReplayFilter filter = key.getRight();
-        return ReplayCollectionImpl.this.replays.parallelStream().filter(
-                (r) -> BattleType.ANY.equals(filter.getBattleType()) || filter.getBattleType().getId()
-                    .equals(r.getBattleType())).filter((r) -> r.existPlayer(player)).filter(
-                (r) -> StringUtils.isEmpty(vehicle) || vehicle.equals(
-                    r.getPlayerVehicleMappingByPlayerName(player).getVehicleType()))
+        return ReplayCollectionImpl.this.replays.parallelStream()
+            .filter((r) -> BattleType.ANY.equals(filter.getBattleType())
+                || filter.getBattleType().getId().equals(r.getBattleType()))
+            .filter((r) -> StringUtils.isEmpty(filter.getMap())
+                || filter.getMap().equals(r.getMapName()))
+            .filter((r) -> r.existPlayer(player))
+            .filter((r) -> StringUtils.isEmpty(vehicle)
+                || vehicle.equals(r.getPlayerVehicleMappingByPlayerName(player).getVehicleType()))
             .collect(Collectors.toList());
       }
     });
@@ -65,14 +68,31 @@ private List<Replay> filteredReplays(String player, String vehicle) {
     }
   }
 
+  private List<Replay> getFilteredReplaysByMap() {
+    if (StringUtils.isEmpty(replayFilter.getMap())) {
+      return replays;
+    }
+    return replays.parallelStream()
+        .filter((r) -> replayFilter.getMap().equals(r.getMapName()))
+        .collect(Collectors.toList());
+  }
+
   public Set<String> getUniquePlayers() {
-    return replays.parallelStream().flatMap((r) -> r.getPlayers().stream()).map(Player::getName)
+    return getFilteredReplaysByMap().parallelStream()
+        .flatMap((r) -> r.getPlayers().stream()).map(Player::getName)
+        .collect(Collectors.toSet());
+  }
+
+  public Set<String> getUniquePlayersIgnoringMapFilter() {
+    return replays.parallelStream()
+        .flatMap((r) -> r.getPlayers().stream()).map(Player::getName)
         .collect(Collectors.toSet());
   }
 
   public Set<String> getUniqueClans() {
     Set<String> result = Collections.synchronizedSet(new HashSet<>());
-    result.addAll(replays.parallelStream().map(Replay::getPlayers).flatMap(Collection::stream)
+    result.addAll(getFilteredReplaysByMap().parallelStream()
+        .map(Replay::getPlayers).flatMap(Collection::stream)
         .map(Player::getClanAbbrev).collect(Collectors.toSet()));
     return result;
   }
@@ -82,8 +102,9 @@ public int getNumberOfClanPlayers(String clan) {
   }
 
   public List<String> getUniquePlayersClan(String clanAbbrev) {
-    Set<String> playerNames = replays.parallelStream().map(Replay::getPlayers)
-        .flatMap(Collection::stream).filter(p -> clanAbbrev.equals(p.getClanAbbrev()))
+    Set<String> playerNames = getFilteredReplaysByMap().parallelStream()
+        .map(Replay::getPlayers).flatMap(Collection::stream)
+        .filter(p -> clanAbbrev.equals(p.getClanAbbrev()))
         .map(Player::getName).collect(Collectors.toSet());
 
     return new ArrayList<>(Collections.synchronizedSet(playerNames));
@@ -94,7 +115,8 @@ public int getNumberOfGames(String player, String vehicle) {
   }
 
   public List<String> getVehiclesForPlayer(String player) {
-    var vehicleGroups = replays.parallelStream().filter(r -> r.existPlayer(player))
+    var vehicleGroups = getFilteredReplaysByMap().parallelStream()
+        .filter(r -> r.existPlayer(player))
         .map(replay -> replay.getPlayerVehicleMappingByPlayerName(player).getVehicleType())
         .collect(Collectors.groupingByConcurrent(vehicleType -> vehicleType));
 
@@ -117,11 +139,15 @@ public List<String> getMaps(String player, String vehicle) {
         .collect(Collectors.toList());
   }
 
-  public int getNumberOfMapsPlayed(String player, String vehicle, String map) {
-    return (int) filteredReplays(player, vehicle).parallelStream()
+  public int getNumberOfGamesOnMap(String map) {
+    return (int) replays.parallelStream()
         .filter((r) -> map.equals(r.getMapName())).count();
   }
 
+  public int getTotalGames() {
+    return replays.size();
+  }
+
   public double getWinRate(String player, String vehicle) {
     List<Replay> filteredReplays = filteredReplays(player, vehicle);
     long wins = filteredReplays.parallelStream().filter(
@@ -181,6 +207,16 @@ public int getAvgBlocked(String player, String vehicle) {
         (r) -> (double) r.getPlayerStatsByPlayerName(player).getDamageBlockedByArmor())).intValue();
   }
 
+  public int getAvgHealthRepair(String player, String vehicle) {
+    return filteredReplays(player, vehicle).parallelStream().collect(Collectors.averagingInt(
+            (r) -> r.getPlayerStatsByPlayerName(player).getHealthRepair())).intValue();
+  }
+
+  public int getAvgAlliedHealthRepair(String player, String vehicle) {
+    return filteredReplays(player, vehicle).parallelStream().collect(Collectors.averagingInt(
+            (r) -> r.getPlayerStatsByPlayerName(player).getAlliedHealthRepair())).intValue();
+  }
+
   public int getAvgLifeTime(String player, String vehicle) {
     return filteredReplays(player, vehicle).parallelStream().collect(Collectors.averagingDouble(
         (r) -> (double) r.getPlayerStatsByPlayerName(player).getLifeTime())).intValue();
@@ -202,6 +238,11 @@ public int getAvgDamageReceivedFromInvisibles(String player, String vehicle) {
         .intValue();
   }
 
+  public int getAvgEquipmentDamageDealt(String player, String vehicle) {
+    return filteredReplays(player, vehicle).parallelStream().collect(Collectors.averagingDouble(
+            (r) -> (double) r.getPlayerStatsByPlayerName(player).getEquipmentDamageDealt())).intValue();
+  }
+
   public double getAvgShots(String player, String vehicle) {
     return filteredReplays(player, vehicle).parallelStream().collect(Collectors.averagingDouble(
         (r) -> (double) r.getPlayerStatsByPlayerName(player).getShots()));
@@ -253,8 +294,8 @@ public int getAvgCapReset(String player, String vehicle) {
         (r) -> r.getPlayerStatsByPlayerName(player).getDroppedCapturePoints())).intValue();
   }
 
-  public void updateReplayFilter(ReplayFilter replayFilter) {
-    this.replayFilter = Objects.requireNonNullElseGet(replayFilter, ReplayFilter::createDefault);
+  public void setMapFilter(String map) {
+    this.replayFilter.setMap(map);
   }
 
   private void debugGetAllVehicles() {
@@ -331,4 +372,9 @@ public double getAvgDamageRank(String player, String vehicle) {
 
     return (double) sumRank / (double) filteredReplays.size();
   }
+
+  public int getComp7PrestigePoints(String player, String vehicle) {
+    return filteredReplays(player, vehicle).parallelStream().collect(Collectors.averagingDouble(
+            (r) -> r.getPlayerStatsByPlayerName(player).getComp7PrestigePoints())).intValue();
+  }
 }

src/main/java/com/synops/replayreader/replay/model/ReplayFilter.java

@@ -6,9 +6,11 @@
 public class ReplayFilter {
 
   private BattleType battleType;
+  private String map;
 
   private ReplayFilter() {
     this.battleType = BattleType.ANY;
+    this.map = null;
   }
 
   public static ReplayFilter createDefault() {
@@ -24,6 +26,15 @@ public ReplayFilter setBattleType(BattleType battleType) {
     return this;
   }
 
+  public String getMap() {
+    return this.map;
+  }
+
+  public ReplayFilter setMap(String map) {
+    this.map = map;
+    return this;
+  }
+
   public boolean equals(Object obj) {
     return EqualsBuilder.reflectionEquals(this, obj, false);
   }

src/main/java/com/synops/replayreader/replay/service/ReplayModelBuilder.java

@@ -144,8 +144,11 @@ private List<VehicleStats> createVehicleStats() {
       vehicleStats.setDamageDealt(vehiclePOJO.damageDealt);
       vehicleStats.setDamageReceived(vehiclePOJO.damageReceived);
       vehicleStats.setDamageReceivedFromInvisibles(vehiclePOJO.damageReceivedFromInvisibles);
+      vehicleStats.setEquipmentDamageDealt(vehiclePOJO.equipmentDamageDealt);
       vehicleStats.setDirectHitsReceived(vehiclePOJO.directHitsReceived);
       vehicleStats.setHealth(vehiclePOJO.health);
+      vehicleStats.setHealthRepair(vehiclePOJO.healthRepair);
+      vehicleStats.setAlliedHealthRepair(vehiclePOJO.alliedHealthRepair);
       vehicleStats.setKillerID(vehiclePOJO.killerID);
       vehicleStats.setKills(vehiclePOJO.kills);
       vehicleStats.setLifeTime(vehiclePOJO.lifeTime);
@@ -166,6 +169,7 @@ private List<VehicleStats> createVehicleStats() {
       vehicleStats.setDamageAssistedStun(vehiclePOJO.damageAssistedStun);
       vehicleStats.setTKills(vehiclePOJO.tkills);
       vehicleStats.setStunNum(vehiclePOJO.stunNum);
+      vehicleStats.setComp7PrestigePoints(vehiclePOJO.comp7PrestigePoints);
       result.add(vehicleStats);
     }