Call all days again

Odds/src/main/Main.java

@@ -50,13 +50,13 @@ public class Main {
         final OddsPortal op = new OddsPortal();
 
         System.out.println("Getting One days ago matches");
-        //op.getMatches(LocalDateTime.now().plusDays(-1));
+        op.getMatches(LocalDateTime.now().plusDays(-1));
         System.out.println("Getting Todays matches");
         op.getMatches(LocalDateTime.now().plusDays(0));
         System.out.println("Getting Tomorrows matches");
-        //op.getMatches(LocalDateTime.now().plusDays(1));
+        op.getMatches(LocalDateTime.now().plusDays(1));
         System.out.println("Getting Next days matches");
-        //op.getMatches(LocalDateTime.now().plusDays(2));
+        op.getMatches(LocalDateTime.now().plusDays(2));
     }
 
 }

OddsJavaFx/src/components/FloatStatRow.java

@@ -0,0 +1,41 @@
+package components;
+
+import javafx.scene.control.Label;
+import javafx.scene.layout.VBox;
+
+public class NumberStatRow extends VBox {
+    String text;
+    int value;
+
+    Label textLabel;
+    Label valueLabel;
+
+    public NumberStatRow(String text, int value) {
+        this.text = text;
+        this.value = value;
+
+        textLabel.setText(text);
+        valueLabel.setText(String.valueOf(value));
+        this.getChildren().add(textLabel);
+        this.getChildren().add(valueLabel);
+    }
+
+    public void increaseValue() {
+        value++;
+        updateValueLabel();
+    }
+
+    public void decreaseValue() {
+        value--;
+        updateValueLabel();
+    }
+
+    private void updateValueLabel() {
+        valueLabel.setText(String.valueOf(value));
+    }
+
+
+    public int getValue() {
+        return value;
+    }
+}

OddsJavaFx/src/components/IntTableStatRow.java

@@ -0,0 +1,51 @@
+package components;
+
+import javafx.scene.control.Label;
+import javafx.scene.layout.HBox;
+
+public class FloatStatRow extends HBox {
+    String text;
+    float value;
+
+    Label textLabel = new Label();
+    Label valueLabel = new Label();
+
+    public FloatStatRow(String text, float value) {
+        this.text = text;
+        this.value = value;
+
+        textLabel.setText(text);
+        valueLabel.setText(String.valueOf(value));
+        this.getChildren().add(textLabel);
+        this.getChildren().add(valueLabel);
+    }
+
+    public void increaseValue() {
+        value++;
+        updateValueLabel();
+    }
+
+    public void decreaseValue() {
+        value--;
+        updateValueLabel();
+    }
+
+    public void increaseValue(float valueToAdd) {
+        value += valueToAdd;
+        updateValueLabel();
+    }
+
+    public void decreaseValue(float valueToSubtract) {
+        value -= valueToSubtract;
+        updateValueLabel();
+    }
+
+    private void updateValueLabel() {
+        valueLabel.setText(String.valueOf(value));
+    }
+
+
+    public float getValue() {
+        return value;
+    }
+}

OddsJavaFx/src/components/MatchSummaryPanelRow.java

@@ -0,0 +1,2 @@
+package components;public class MatchSummaryPanelRow {
+}

OddsJavaFx/src/components/NumberStatRow.java

@@ -0,0 +1,2 @@
+package components;public class NumberStatRow {
+}

OddsJavaFx/src/controllers/MatchStatisticsController.java

@@ -0,0 +1,122 @@
+package controllers;
+
+import java.net.URL;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.ResourceBundle;
+
+import com.google.common.collect.Maps;
+
+import data.GuiMysql;
+import javafx.fxml.FXML;
+import javafx.fxml.Initializable;
+import javafx.scene.control.SelectionMode;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableView;
+import javafx.scene.control.TableView.TableViewSelectionModel;
+import javafx.scene.control.cell.MapValueFactory;
+import objects.TeamStanding;
+
+@SuppressWarnings("rawtypes") public class MatchStatTabController implements Initializable {
+
+	private static final String GOALS_CONCEDED = "goalsConceded";
+
+	private static final String GOALS_SCORED = "goalsScored";
+
+	private static final String POINTS_STRING = "points";
+
+	private static final String GAMES_PLAYED = "gamesPlayed";
+
+	private static MatchStatTabController instance;
+
+	@FXML TableView<Map<String, Object>> matchStatTable;
+
+	@FXML TableColumn<Map, String> team = new TableColumn<>("team");
+	@FXML TableColumn<Map, Integer> gamesPlayed = new TableColumn<>(GAMES_PLAYED);
+	@FXML TableColumn<Map, Integer> win = new TableColumn<>("win");
+	@FXML TableColumn<Map, Integer> draw = new TableColumn<>("draw");
+	@FXML TableColumn<Map, Integer> loss = new TableColumn<>("loss");
+	@FXML TableColumn<Map, Integer> points = new TableColumn<>(POINTS_STRING);
+	@FXML TableColumn<Map, Float> goalsScored = new TableColumn<>(GOALS_SCORED);
+	@FXML TableColumn<Map, Float> goalsConceded = new TableColumn<>(GOALS_CONCEDED);
+	@FXML TableColumn<Map, Float> diff = new TableColumn<>("diff");
+
+	public static MatchStatTabController getInstance() {
+		if (instance == null) {
+			synchronized (MatchStatTabController.class) {
+				if (instance == null) {
+					instance = new MatchStatTabController();
+				}
+			}
+		}
+		return instance;
+	}
+
+	@Override public void initialize(URL arg0, ResourceBundle arg1) {
+		team.setCellValueFactory(new MapValueFactory<>("team"));
+		gamesPlayed.setCellValueFactory(new MapValueFactory<>(GAMES_PLAYED));
+		win.setCellValueFactory(new MapValueFactory<>("win"));
+		draw.setCellValueFactory(new MapValueFactory<>("draw"));
+		loss.setCellValueFactory(new MapValueFactory<>("loss"));
+		points.setCellValueFactory(new MapValueFactory<>(POINTS_STRING));
+		goalsScored.setCellValueFactory(new MapValueFactory<>(GOALS_SCORED));
+		goalsConceded.setCellValueFactory(new MapValueFactory<>(GOALS_CONCEDED));
+		diff.setCellValueFactory(new MapValueFactory<>("diff"));
+
+		instance = this;
+	}
+
+	public void setLeagueStandingsTable(int leagueId, String season, int countryId, String date) {
+		final List<TeamStanding> res = GuiMysql.getInstance().getLeagueTable(leagueId, season, countryId, date);
+		matchStatTable.getItems().clear();
+		for (final TeamStanding ts : res) {
+			final Map<String, Object> line = Maps.newHashMap();
+			final int numGamesPlayed = ts.getWins() + ts.getDraws() + ts.getLosses();
+			line.put("team", ts.getTeamName());
+			line.put(GAMES_PLAYED, numGamesPlayed);
+			line.put("win", ts.getWins());
+			line.put("draw", ts.getDraws());
+			line.put("loss", ts.getLosses());
+			line.put(POINTS_STRING, ts.getPoints());
+			line.put(GOALS_SCORED, ts.getGoalsScored() / numGamesPlayed);
+			line.put(GOALS_CONCEDED, ts.getGoalsConceded() / numGamesPlayed);
+
+			matchStatTable.getItems().add(line);
+		}
+	}
+
+	public void setTeamSelected(String teamName, boolean homeTeam) {
+		TableViewSelectionModel<Map<String, Object>> selectionModel = matchStatTable.getSelectionModel();
+		java.util.Optional<Map<String, Object>> optional = matchStatTable.getItems().stream().filter(p -> p.get("team").equals(teamName)).findFirst();
+		if (optional.isPresent()) {
+			selectionModel.setSelectionMode(SelectionMode.MULTIPLE);
+			int indexOf = matchStatTable.getItems().indexOf(optional.get());
+			selectionModel.select(indexOf);
+		}
+	}
+
+	public void clearSelection() {
+		TableViewSelectionModel<Map<String, Object>> selectionModel = matchStatTable.getSelectionModel();
+		selectionModel.clearSelection();
+	}
+
+	public int getTeamPositionDiff(String homeTeamName, String awayTeamName) {
+		int result = 0;
+		Optional<Map<String, Object>> homeTeamOptional = matchStatTable.getItems().stream().filter(p -> p.get("team").equals(homeTeamName))
+				.findFirst();
+		Optional<Map<String, Object>> awayTeamOptional = matchStatTable.getItems().stream().filter(p -> p.get("team").equals(awayTeamName))
+				.findFirst();
+
+		if (homeTeamOptional.isPresent() && awayTeamOptional.isPresent()) {
+			Map<String, Object> homeTeam = homeTeamOptional.get();
+			Map<String, Object> awayTeam = awayTeamOptional.get();
+
+			int homeTeamPos = matchStatTable.getItems().indexOf(homeTeam);
+			int awayTeamPos = matchStatTable.getItems().indexOf(awayTeam);
+			result = Math.abs(homeTeamPos - awayTeamPos);
+		}
+
+		return result;
+	}
+}

OddsJavaFx/src/controllers/StrategyTesterController.java

@@ -0,0 +1,377 @@
+package controllers;
+
+import data.GuiMysql;
+import data.MatchStatSql;
+import javafx.fxml.FXML;
+import javafx.fxml.Initializable;
+import javafx.scene.control.DatePicker;
+import javafx.scene.control.Label;
+import javafx.scene.control.ListView;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.VBox;
+import objects.OddsStat;
+import objects.SoccerMatch;
+import objects.Team;
+
+import java.net.URL;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.ResourceBundle;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class MatchStatisticsController implements Initializable {
+
+    private static MatchStatisticsController instance;
+    @FXML
+    public DatePicker datePicker;
+    @FXML
+    public ListView<SoccerMatch> MatchesListView;
+
+    private SoccerMatch selectedMatch = null;
+    public Pane MatchPanel;
+    Map<Integer, List<SoccerMatch>> allMatches = new HashMap<>();
+    int currentLeagueId = -1;
+
+    private MatchStatSql database = new MatchStatSql();
+
+    public static MatchStatisticsController getInstance() {
+        if (instance == null) {
+            synchronized (MatchStatisticsController.class) {
+                if (instance == null) {
+                    instance = new MatchStatisticsController();
+                }
+            }
+        }
+        return instance;
+    }
+
+    @Override
+    public void initialize(URL arg0, ResourceBundle arg1) {
+        instance = this;
+
+        MatchesListView.getSelectionModel().selectedItemProperty().addListener((ov, oldValue, newValue) -> {
+            if (newValue != null && !newValue.equals(oldValue)) {
+                ClearSelectedSoccerMatch();
+                UpdateSelectedSoccerMatch(newValue);
+            }
+        });
+
+        datePicker.valueProperty().addListener((ov, oldValue, newValue) -> {
+            if (oldValue != null && !newValue.isEqual(oldValue)) {
+                populateGamesList(newValue);
+            } else if (oldValue == null && newValue != null) {
+                populateGamesList(newValue);
+            }
+        });
+    }
+
+    private void populateGamesList(LocalDate date) {
+        List<SoccerMatch> matches = GuiMysql.getInstance().getPrioMatchesByDate(date.toString());
+
+        MatchesListView.getItems().clear();
+        for (SoccerMatch match : matches) {
+            MatchesListView.getItems().add(match);
+        }
+    }
+
+    private void UpdateSelectedSoccerMatch(SoccerMatch soccerMatch) {
+        selectedMatch = soccerMatch;
+
+        buildSoccerMatchAnalysisPanel(selectedMatch);
+    }
+
+    private void buildSoccerMatchAnalysisPanel(SoccerMatch match) {
+        VBox baseBox = new VBox();
+        int limitNumerOfGames = 10;
+        //baseBox.setBackground(new Background(new BackgroundFill(Color.LIGHTGRAY, CornerRadii.EMPTY, Insets.EMPTY)));
+        HBox topRow = new HBox(10d);
+        HBox bottomRow = new HBox(10d);
+        baseBox.getChildren().add(topRow);
+        baseBox.getChildren().add(bottomRow);
+
+        MatchPanel.getChildren().add(baseBox);
+
+        VBox scoringTotalBoxHome = new VBox();
+        topRow.getChildren().add(scoringTotalBoxHome);
+        scoringTotalBoxHome.getChildren().add(new Label("Result Home - Away goals"));
+        VBox scoringTotalBoxAway = new VBox();
+        topRow.getChildren().add(scoringTotalBoxAway);
+        scoringTotalBoxAway.getChildren().add(new Label("Result Away - Home goals"));
+        VBox resultBoxTotalScore = new VBox();
+        Label resultingLabel = new Label("Result Compare Value");
+        resultBoxTotalScore.getChildren().add(resultingLabel);
+        topRow.getChildren().add(resultBoxTotalScore);
+
+        for (int i = 1; i <= limitNumerOfGames; i++) {
+            HBox box = new HBox(5d);
+            box.getChildren().add(new Label(String.valueOf(i)));
+            int totalGoalResultHome = database.totalGoalResult(match.getHomeTeam().getTeamId(), match.getGameDate().format(DateTimeFormatter.ISO_LOCAL_DATE), true, i);
+            box.getChildren().add(new Label(String.valueOf(totalGoalResultHome)));
+            scoringTotalBoxHome.getChildren().add(box);
+
+            HBox boxAway = new HBox(5d);
+            boxAway.getChildren().add(new Label(String.valueOf(i)));
+            int totalGoalResultAway = database.totalGoalResult(match.getAwayTeam().getTeamId(), match.getGameDate().format(DateTimeFormatter.ISO_LOCAL_DATE), false, i);
+            boxAway.getChildren().add(new Label(String.valueOf(totalGoalResultAway)));
+            scoringTotalBoxAway.getChildren().add(boxAway);
+
+            OddsStat totalGoalStat = statTotalGoalResult((totalGoalResultHome - totalGoalResultAway), match.getHomeTeam().getTeamLeagueId(), i, match.getGameDate());
+            resultBoxTotalScore.getChildren().add(new Label(String.valueOf(totalGoalResultHome - totalGoalResultAway) +
+                    totalGoalStat.toString() + " (" + totalGoalStat.getAvgGoalsScores() + ")"));
+        }
+
+        VBox goalsScoredHomeAndAwayHome = new VBox();
+        topRow.getChildren().add(goalsScoredHomeAndAwayHome);
+        goalsScoredHomeAndAwayHome.getChildren().add(new Label("Goals Scored Total Home"));
+        VBox goalsScoredHomeAndAwayAway = new VBox();
+        topRow.getChildren().add(goalsScoredHomeAndAwayAway);
+        goalsScoredHomeAndAwayAway.getChildren().add(new Label("Goals Scored Total Away"));
+
+        VBox resultHomeAway = new VBox();
+        resultHomeAway.getChildren().add(new Label("HomeVsAway Compare value"));
+
+        topRow.getChildren().add(resultHomeAway);
+        for (int i = 1; i <= limitNumerOfGames; i++) {
+            HBox box = new HBox(5d);
+            box.getChildren().add(new Label(String.valueOf(i)));
+            float totalGoalResultHomeANDAwayHome = database.totalGoalResultHomeANDAway(match.getHomeTeam().getTeamId(), match.getGameDate().format(DateTimeFormatter.ISO_LOCAL_DATE), i);
+            box.getChildren().add(new Label(String.valueOf(totalGoalResultHomeANDAwayHome)));
+            goalsScoredHomeAndAwayHome.getChildren().add(box);
+
+            HBox boxAway = new HBox(5d);
+            boxAway.getChildren().add(new Label(String.valueOf(i)));
+            float totalGoalResultHomeANDAwayAway = database.totalGoalResultHomeANDAway(match.getAwayTeam().getTeamId(), match.getGameDate().format(DateTimeFormatter.ISO_LOCAL_DATE), i);
+            boxAway.getChildren().add(new Label(String.valueOf(totalGoalResultHomeANDAwayAway)));
+            goalsScoredHomeAndAwayAway.getChildren().add(boxAway);
+
+            resultHomeAway.getChildren().add(new Label(String.format("%.2f",
+                    totalGoalResultHomeANDAwayHome - totalGoalResultHomeANDAwayAway) + " " +
+                    statSplitGoalResultHomeAndAway(Math.round(totalGoalResultHomeANDAwayHome - totalGoalResultHomeANDAwayAway),
+                            match.getHomeTeam().getTeamLeagueId(), i, match.getGameDate()).toString()));
+        }
+
+        VBox goalsScoredLastXGamesHome = new VBox();
+        bottomRow.getChildren().add(goalsScoredLastXGamesHome);
+        goalsScoredLastXGamesHome.getChildren().add(new Label("Goals Scored Home"));
+        VBox goalsScoredLastXGamesAway = new VBox();
+        bottomRow.getChildren().add(goalsScoredLastXGamesAway);
+        goalsScoredLastXGamesAway.getChildren().add(new Label("Goals Scored Away"));
+
+        VBox goalsScoredLastXGamesCV = new VBox();
+        goalsScoredLastXGamesCV.getChildren().add(new Label("Goals Scored Compare value"));
+
+        bottomRow.getChildren().add(goalsScoredLastXGamesCV);
+        for (int i = 1; i <= limitNumerOfGames; i++) {
+            HBox box = new HBox(5d);
+            box.getChildren().add(new Label(String.valueOf(i)));
+            float goalsScoredLastXGamesHomeValue = database.goalsScoredLastXGames(match.getHomeTeam().getTeamId(), true, match.getGameDate().format(DateTimeFormatter.ISO_LOCAL_DATE), i);
+            box.getChildren().add(new Label(String.valueOf(goalsScoredLastXGamesHomeValue)));
+            goalsScoredLastXGamesHome.getChildren().add(box);
+
+            HBox boxAway = new HBox(5d);
+            boxAway.getChildren().add(new Label(String.valueOf(i)));
+            float goalsScoredLastXGamesAwayValue = database.goalsScoredLastXGames(match.getAwayTeam().getTeamId(), false, match.getGameDate().format(DateTimeFormatter.ISO_LOCAL_DATE), i);
+            boxAway.getChildren().add(new Label(String.valueOf(goalsScoredLastXGamesAwayValue)));
+            goalsScoredLastXGamesAway.getChildren().add(boxAway);
+
+            OddsStat oddsStat = statGoalsScoredLastXGames((goalsScoredLastXGamesHomeValue - goalsScoredLastXGamesAwayValue), match.getHomeTeam().getTeamLeagueId(), i, match.getGameDate());
+            goalsScoredLastXGamesCV.getChildren().add(new Label(String.format("%.2f",
+                    goalsScoredLastXGamesHomeValue - goalsScoredLastXGamesAwayValue) + oddsStat.toString()
+                    + " (" + oddsStat.getAvgGoalsScores() + ")"
+            ));
+        }
+
+
+        VBox goalsScoreLastXGamesHomeANDAwayHome = new VBox();
+        bottomRow.getChildren().add(goalsScoreLastXGamesHomeANDAwayHome);
+        goalsScoreLastXGamesHomeANDAwayHome.getChildren().add(new Label("Goals Scored Home/Away Home"));
+        VBox goalsScoreLastXGamesHomeANDAwayAway = new VBox();
+        bottomRow.getChildren().add(goalsScoreLastXGamesHomeANDAwayAway);
+        goalsScoreLastXGamesHomeANDAwayAway.getChildren().add(new Label("Goals Scored Home/Away Away"));
+
+        VBox goalsScoreLastXGamesHomeANDAwayCV = new VBox();
+        goalsScoreLastXGamesHomeANDAwayCV.getChildren().add(new Label("Goals Scored Home/Away Compare value"));
+
+        bottomRow.getChildren().add(goalsScoreLastXGamesHomeANDAwayCV);
+        for (int i = 1; i <= limitNumerOfGames; i++) {
+            HBox box = new HBox(5d);
+            box.getChildren().add(new Label(String.valueOf(i)));
+            float goalsScoreLastXGamesHomeANDAwayHomeValue = database.goalsScoreLastXGamesHomeANDAway(match.getHomeTeam().getTeamId(), match.getGameDate().format(DateTimeFormatter.ISO_LOCAL_DATE), i);
+            box.getChildren().add(new Label(String.valueOf(goalsScoreLastXGamesHomeANDAwayHomeValue)));
+            goalsScoreLastXGamesHomeANDAwayHome.getChildren().add(box);
+
+            HBox boxAway = new HBox(5d);
+            boxAway.getChildren().add(new Label(String.valueOf(i)));
+            float goalsScoreLastXGamesHomeANDAwayAwayValue = database.goalsScoreLastXGamesHomeANDAway(match.getAwayTeam().getTeamId(), match.getGameDate().format(DateTimeFormatter.ISO_LOCAL_DATE), i);
+            boxAway.getChildren().add(new Label(String.valueOf(goalsScoreLastXGamesHomeANDAwayAwayValue)));
+            goalsScoreLastXGamesHomeANDAwayAway.getChildren().add(boxAway);
+
+            OddsStat statGoalsScoredLastXGamesHomeAndAway = statGoalsScoredLastXGamesHomeAndAway((goalsScoreLastXGamesHomeANDAwayHomeValue - goalsScoreLastXGamesHomeANDAwayAwayValue), match.getHomeTeam().getTeamLeagueId(), i, match.getGameDate());
+            goalsScoreLastXGamesHomeANDAwayCV.getChildren().add(new Label(String.format("%.2f",
+                    goalsScoreLastXGamesHomeANDAwayHomeValue - goalsScoreLastXGamesHomeANDAwayAwayValue) + " " + statGoalsScoredLastXGamesHomeAndAway.toString() + "(" + statGoalsScoredLastXGamesHomeAndAway.getAvgGoalsScores() + ")"));
+        }
+    }
+
+
+    private List<SoccerMatch> getAllMatchesFromLeauge(int leagueId) {
+        if (allMatches.get(leagueId) == null || allMatches.get(leagueId).isEmpty()) {
+            allMatches.put(leagueId, database.getAllMatchesForLeague(leagueId));
+        }
+        return allMatches.get(leagueId);
+    }
+
+    private int getTotalGoalResultsHomeAndAway(int teamId, int leagueId, int limit, String currentDate) {
+        List<SoccerMatch> matches = getAllMatchesFromLeauge(leagueId);
+
+        List<SoccerMatch> matchesBefore = matches.stream().filter(m -> m.getGameDate().isBefore(LocalDateTime.parse(currentDate))).collect(Collectors.toList());
+
+        List<SoccerMatch> teamMatches = matchesBefore.stream().filter(m -> m.getHomeTeam().getTeamId() == teamId || m.getAwayTeam().getTeamId() == teamId).limit(limit).collect(Collectors.toList());
+
+        return calculateTotalGoalResultHomeAndAway(teamId, teamMatches);
+    }
+
+    private static int calculateTotalGoalResultHomeAndAway(int teamId, List<SoccerMatch> teamMatches) {
+        int result = 0;
+        for (SoccerMatch tm : teamMatches) {
+            if (tm.getHomeTeam().getTeamId() == teamId) {
+                result += tm.getHomeScore() - tm.getAwayScore();
+            } else if (tm.getAwayTeam().getTeamId() == teamId) {
+                result += tm.getAwayScore() - tm.getHomeScore();
+            }
+        }
+        return result;
+    }
+
+    private OddsStat statSplitGoalResultHomeAndAway(int value, int league, int limit, LocalDateTime currentDate) {
+        OddsStat stat = new OddsStat();
+
+        for (SoccerMatch sm : getAllMatchesFromLeauge(league)) {
+            List<SoccerMatch> homeTeamMatches = filterSoccerMatchesByTeam(league, currentDate, sm.getHomeTeam(), limit);
+            List<SoccerMatch> awayTeamMatches = filterSoccerMatchesByTeam(league, currentDate, sm.getAwayTeam(), limit);
+
+            int homeTeamValue = calculateTotalGoalResultHomeAndAway(sm.getHomeTeam().getTeamId(), homeTeamMatches);
+            int awayTeamValue = calculateTotalGoalResultHomeAndAway(sm.getAwayTeam().getTeamId(), awayTeamMatches);
+
+            if (homeTeamValue - awayTeamValue == value) {
+                if (sm.getHomeScore() > sm.getAwayScore()) {
+                    stat.addHomeWin();
+                } else if (sm.getHomeScore() == sm.getAwayScore()) {
+                    stat.addDraw();
+                } else if (sm.getAwayScore() > sm.getHomeScore()) {
+                    stat.addAwayWin();
+                }
+            }
+        }
+        return stat;
+    }
+
+    private OddsStat statGoalsScoredLastXGames(float value, int leagueId, int limit, LocalDateTime currentDate) {
+        OddsStat stat = new OddsStat();
+        for (SoccerMatch sm : getAllMatchesFromLeauge(leagueId)) {
+            List<SoccerMatch> homeTeamMatches = filterSoccerMatchesByTeamHomeOrAway(leagueId, currentDate, sm.getHomeTeam(), limit, true);
+            List<SoccerMatch> awayTeamMatches = filterSoccerMatchesByTeamHomeOrAway(leagueId, currentDate, sm.getAwayTeam(), limit, false);
+
+            int goalsScoredHome = homeTeamMatches.stream().mapToInt(SoccerMatch::getHomeScore).sum();
+            int goalsScoredAway = awayTeamMatches.stream().mapToInt(SoccerMatch::getAwayScore).sum();
+
+            if (((float) goalsScoredHome - (float) goalsScoredAway) == value) {
+                if (sm.getHomeScore() > sm.getAwayScore()) {
+                    stat.addHomeWin();
+                } else if (sm.getHomeScore() == sm.getAwayScore()) {
+                    stat.addDraw();
+                } else if (sm.getAwayScore() > sm.getHomeScore()) {
+                    stat.addAwayWin();
+                }
+                stat.addGoalsScored(sm.getHomeScore() + sm.getAwayScore());
+            }
+        }
+        return stat;
+    }
+
+    private OddsStat statGoalsScoredLastXGamesHomeAndAway(float value, int leagueId, int limit, LocalDateTime currentDate) {
+        OddsStat stat = new OddsStat();
+        for (SoccerMatch sm : getAllMatchesFromLeauge(leagueId)) {
+            List<SoccerMatch> homeTeamMatches = filterSoccerMatchesByTeam(leagueId, currentDate, sm.getHomeTeam(), limit);
+            List<SoccerMatch> awayTeamMatches = filterSoccerMatchesByTeam(leagueId, currentDate, sm.getAwayTeam(), limit);
+
+            int homeTeamRes = calculateScoreLastXGamesHomeAndAway(homeTeamMatches, sm.getHomeTeam().getTeamId());
+            int awayTeamRes = calculateScoreLastXGamesHomeAndAway(awayTeamMatches, sm.getAwayTeam().getTeamId());
+            if (((float) homeTeamRes - (float) awayTeamRes) == value) {
+                if (sm.getHomeScore() > sm.getAwayScore()) {
+                    stat.addHomeWin();
+                } else if (sm.getHomeScore() == sm.getAwayScore()) {
+                    stat.addDraw();
+                } else if (sm.getAwayScore() > sm.getHomeScore()) {
+                    stat.addAwayWin();
+                }
+                stat.addGoalsScored(sm.getHomeScore() + sm.getAwayScore());
+            }
+        }
+        return stat;
+    }
+
+    private int calculateScoreLastXGamesHomeAndAway(List<SoccerMatch> teamMatches, int teamId) {
+        int res = 0;
+        for (SoccerMatch sm : teamMatches) {
+            if (sm.getHomeTeam().getTeamId() == teamId) {
+                res += sm.getHomeScore();
+            } else if (sm.getAwayTeam().getTeamId() == teamId) {
+                res += sm.getAwayScore();
+            }
+        }
+
+        return res;
+    }
+
+
+    private OddsStat statTotalGoalResult(int value, int leagueId, int limit, LocalDateTime currentDate) {
+        OddsStat stat = new OddsStat();
+        for (SoccerMatch sm : getAllMatchesFromLeauge(leagueId)) {
+            List<SoccerMatch> homeTeamMatches = filterSoccerMatchesByTeamHomeOrAway(leagueId, currentDate, sm.getHomeTeam(), limit, true);
+            List<SoccerMatch> awayTeamMatches = filterSoccerMatchesByTeamHomeOrAway(leagueId, currentDate, sm.getAwayTeam(), limit, false);
+
+            int homeValue = homeTeamMatches.stream().mapToInt(match -> match.getHomeScore() - match.getAwayScore()).sum();
+            int awayValue = awayTeamMatches.stream().mapToInt(match -> match.getAwayScore() - match.getHomeScore()).sum();
+
+            if ((homeValue - awayValue) == value) {
+                if (sm.getHomeScore() > sm.getAwayScore()) {
+                    stat.addHomeWin();
+                } else if (sm.getHomeScore() == sm.getAwayScore()) {
+                    stat.addDraw();
+                } else if (sm.getAwayScore() > sm.getHomeScore()) {
+                    stat.addAwayWin();
+                }
+                stat.addGoalsScored(sm.getHomeScore() + sm.getAwayScore());
+            }
+        }
+        return stat;
+    }
+
+    private List<SoccerMatch> filterSoccerMatchesByTeamHomeOrAway(int league, LocalDateTime currentDate, Team sm, int limit, boolean homeTeam) {
+        Stream<SoccerMatch> stream = getAllMatchesFromLeauge(league).stream().filter(f -> f.getGameDate().isBefore(currentDate));
+        if (homeTeam) {
+            stream = stream.filter(f -> f.getHomeTeam().getTeamId() == sm.getTeamId());
+        } else {
+            stream = stream.filter(f -> f.getAwayTeam().getTeamId() == sm.getTeamId());
+        }
+        return stream.limit(limit).toList();
+    }
+
+    private List<SoccerMatch> filterSoccerMatchesByTeam(int league, LocalDateTime currentDate, Team sm, int limit) {
+        return getAllMatchesFromLeauge(league).stream()
+                .filter(f -> f.getGameDate().isBefore(currentDate) &&
+                        (f.getHomeTeam().getTeamId() == sm.getTeamId() ||
+                                f.getAwayTeam().getTeamId() == sm.getTeamId()))
+                .limit(limit).toList();
+    }
+
+    private void ClearSelectedSoccerMatch() {
+        MatchPanel.getChildren().clear();
+    }
+}

OddsJavaFx/src/controllers/strategytest/FibonacciStrategy.java

@@ -0,0 +1,2 @@
+package controllers.strategytest;public class FibonacciStrategy {
+}

OddsJavaFx/src/controllers/strategytest/OneThreeTwoSixStrategy.java

@@ -0,0 +1,2 @@
+package controllers.strategytest;public class OneThreeTwoSixStrategy {
+}

OddsJavaFx/src/controllers/strategytest/OneXStrategy.java

@@ -0,0 +1,102 @@
+package controllers.strategytest;
+
+
+import components.FloatStatRow;
+import components.NumberStatRow;
+import objects.SoccerMatch;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * <p>1X on home outsiders strategy</p>
+ * <p>A betting strategy that has been successful in the past is the bet on the “double chance” 1X if an outsider plays against a favorite at home.
+ * In this case, the “1X” bet brings respectable odds and very interesting profit opportunities.</p>
+ *
+ * <p>Home win or draw betting strategy</p>
+ *
+ * <p>You don’t even have to choose and analyze games that contain absolute extremes and obvious class differences with this strategy.
+ * So, you don’t necessarily have to bet against Barcelona, Bayern or Juventus as an away team.
+ * Here, we would probably move away from the value bets.
+ * Even if we opt for teams that are not big outsiders, but are still outsiders according to the odds, we find highly interesting odds between 1.60 and 2.50.</p>
+ *
+ * <p>As with all bets, it is important to analyze in advance and not blindly going for any team.
+ * You should of course take statistics into account, advance information about injuries and suspensions, as well as the current shape of the teams.
+ * The home advantage of the outsider, for whom games in front of their own audience against a “bigger one” also represent a special motivation,
+ * should not be underestimated as it brings another small advantage for the home team.
+ * Especially when the respective favorite has recently shown itself shaky against “smaller ones”,
+ * you can definitely find value in such an outsider bet with double chances.</p>
+ *
+ * <p>If you also accept lower odds, you can of course also use this 1X strategy for games that have balanced odds.</p>
+ */
+public class OneXStatPanel extends javafx.scene.layout.VBox {
+    private final List<SoccerMatch> matches = new ArrayList<>();
+    private NumberStatRow matchesPlayedStatRow;
+    private NumberStatRow matchesWonStatRow;
+    private NumberStatRow matchesLostStatRow;
+    private FloatStatRow wonLossBank;
+    private FloatStatRow betAmount;
+    public OneXStatPanel() {
+        super();
+        buildSettingsGuiPanel();
+        buildStatGuiPanel();
+
+        System.out.println(this.getWidth() + " " + this.getHeight());
+        this.setStyle("-fx-background-color: orange");
+    }
+
+    public OneXStatPanel(List<SoccerMatch> matches) {
+        super();
+        buildSettingsGuiPanel();
+        buildStatGuiPanel();
+
+        setMatches(matches);
+    }
+
+    public void setMatches(List<SoccerMatch> matches) {
+        this.matches.clear();
+        this.matches.addAll(matches);
+    }
+
+    public void runTest() {
+        for (SoccerMatch match : matches) {
+            float OneXOdds = calculate1XOdds(match);
+            if ( OneXOdds > 1.60 && OneXOdds < 2.50) {
+                // bet on home win or draw
+
+            }
+        }
+    }
+
+    private void buildSettingsGuiPanel() {
+        betAmount = new FloatStatRow("Bet Amount", 10f);
+
+        this.getChildren().add(betAmount);
+    }
+
+    private void buildStatGuiPanel() {
+        matchesPlayedStatRow = new NumberStatRow("Number of matches played", 0);
+        matchesWonStatRow = new NumberStatRow("Number of matches won", 0);
+        matchesLostStatRow = new NumberStatRow("Number of matches lost", 0);
+
+        wonLossBank = new FloatStatRow("Amount won or lost", 0f);
+
+        this.getChildren().add(matchesPlayedStatRow);
+        this.getChildren().add(matchesWonStatRow);
+        this.getChildren().add(matchesLostStatRow);
+        this.getChildren().add(wonLossBank);
+    }
+
+    private float calculate1XOdds(SoccerMatch match) {
+        return match.getOddsX() * match.getOdds1() / (match.getOddsX() + match.getOdds1());
+    }
+
+    private float calculateX2Odds(SoccerMatch match) {
+        return match.getOddsX() * match.getOdds2() / (match.getOddsX() + match.getOdds2());
+    }
+
+    private float calculate12Odds(SoccerMatch match) {
+        return match.getOdds1() * match.getOdds2() / (match.getOdds1() + match.getOdds2());
+    }
+
+}

OddsJavaFx/src/data/MatchStatSql.java

@@ -0,0 +1,2 @@
+package data;public class MatchStatSql {
+}

OddsJavaFx/src/fxml/MatchStatistics.fxml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import java.lang.*?>
+<?import java.util.*?>
+<?import javafx.scene.*?>
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.*?>
+
+<AnchorPane xmlns="http://javafx.com/javafx"
+            xmlns:fx="http://javafx.com/fxml"
+            fx:controller="$CONTROLLER_NAME$"
+            prefHeight="400.0" prefWidth="600.0" >
+
+</AnchorPane>

OddsJavaFx/src/fxml/StrategyTester.fxml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.control.DatePicker?>
+<?import javafx.scene.control.ListView?>
+<?import javafx.scene.layout.AnchorPane?>
+<?import javafx.scene.layout.BorderPane?>
+<?import javafx.scene.layout.HBox?>
+<?import javafx.scene.layout.Pane?>
+<?import javafx.scene.layout.VBox?>
+
+<AnchorPane xmlns="http://javafx.com/javafx/21" xmlns:fx="http://javafx.com/fxml/1" fx:controller="controllers.MatchStatisticsController">
+    <BorderPane layoutX="110.0" layoutY="93.0" prefHeight="546.0" prefWidth="893.0" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
+      <left>
+         <VBox minWidth="200.0" BorderPane.alignment="CENTER">
+            <children>
+               <HBox>
+                  <children>
+                     <DatePicker fx:id="datePicker" promptText="DATE" />
+                  </children>
+               </HBox>
+               <ListView fx:id="MatchesListView" VBox.vgrow="ALWAYS" />
+            </children>
+         </VBox>
+      </left>
+      <center>
+         <Pane fx:id="MatchPanel" BorderPane.alignment="CENTER" />
+      </center></BorderPane>
+</AnchorPane>

OddsJavaFx/src/fxml/UpcommingMatches.fxml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.control.Tab?>
+<?import javafx.scene.control.TabPane?>
+<?import javafx.scene.layout.AnchorPane?>
+
+
+<AnchorPane stylesheets="@css/StrategyStyles.css" xmlns="http://javafx.com/javafx/21" xmlns:fx="http://javafx.com/fxml/1" fx:controller="controllers.StrategyTesterController">
+   <children>
+      <TabPane tabClosingPolicy="UNAVAILABLE">
+        <tabs>
+          <Tab text="Todays Matches">
+            <content>
+              <AnchorPane minHeight="0.0" minWidth="0.0" prefHeight="180.0" prefWidth="200.0" />
+            </content>
+          </Tab>
+          <Tab text="Tommorrows Matches">
+            <content>
+              <AnchorPane minHeight="0.0" minWidth="0.0" prefHeight="180.0" prefWidth="200.0" />
+            </content>
+          </Tab>
+        </tabs>
+      </TabPane>
+   </children>
+</AnchorPane>

OddsJavaFx/src/fxml/css/StrategyStyles.css

@@ -0,0 +1,4 @@
+VBox {
+    -fx-border-color: BLACK;
+    -fx-border-width: 1px;
+}

OddsJavaFx/src/interfaces/strategytest/BettingStrategyInterface.java

@@ -0,0 +1,2 @@
+package interfaces.strategytest;public interface bettingStrategyInterface {
+}

OddsJavaFx/src/objects/MatchViewDTO.java

@@ -0,0 +1,2 @@
+package objects;public class MatchViewDTO {
+}

OddsJavaFx/src/objects/OddsStat.java

@@ -0,0 +1,2 @@
+package objects;public class OddsStatt {
+}

OddsJavaFx/src/tests/AnalysisBettDrawTester.java → OddsJavaFx/src/tests/AnalysisBettDrawTest.java

@@ -1,14 +1,5 @@
 package tests;
 
-import java.time.LocalDate;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.stream.Collectors;
-
 import data.TestDatabase;
 import objects.League;
 import objects.SoccerMatch;
@@ -17,6 +8,11 @@ import objects.bets.AsianHandicap;
 import objects.bets.Bet;
 import tests.objects.LeagueDTO;
 
+import java.time.LocalDate;
+import java.util.*;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+
 public class AnalysisBettDrawTester extends TestClass {
 
     public class DifferenceAsianBetDTO extends AsianHandicap {
@@ -139,9 +135,9 @@ public class AnalysisBettDrawTester extends TestClass {
             int awayTotalGoals = analysis.scoringTotal(leagueInfo.getDrawTotalGoals(), false);
             int totalGoalsDecider = homeTotalGoals - awayTotalGoals;
 
-            int homeTotalGoalsHomeAway = analysis.goalsScoredHomeAndAway(true, leagueInfo.getDrawDiffHomeAway());
-            int awayTotalGoalsHomeAway = analysis.goalsScoredHomeAndAway(false, leagueInfo.getDrawDiffHomeAway());
-            int totalGoalsHomeAwayDecider = homeTotalGoalsHomeAway - awayTotalGoalsHomeAway;
+            float homeTotalGoalsHomeAway = analysis.goalsScoredHomeAndAway(true, leagueInfo.getDrawDiffHomeAway());
+            float awayTotalGoalsHomeAway = analysis.goalsScoredHomeAndAway(false, leagueInfo.getDrawDiffHomeAway());
+            float totalGoalsHomeAwayDecider = homeTotalGoalsHomeAway - awayTotalGoalsHomeAway;
 
             int homeFormHomeAndAway = analysis.winLossRatioHomeAndAway(true,
                     leagueInfo.getDrawWinningFormHomeAway());

OddsJavaFx/src/tests/XBestRatedGamesBettingTest.java

@@ -0,0 +1,23 @@
+package tests;
+
+import data.GuiMysql;
+import objects.SoccerMatch;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class XBestRatedGamesBetting extends TestClass {
+    GuiMysql db = GuiMysql.getInstance();
+    List<SoccerMatch> matches = new ArrayList<>();
+
+    @Override
+    public void runTest() {
+        matches.addAll(db.getPrioMatches());
+
+        List<SoccerMatch> todaysMatches = matches.stream()
+                .filter(m -> matches.get(0).getGameDate()
+                        .isEqual(m.getGameDate()))
+                .collect(Collectors.toList());
+    }
+}

OddsJavaFx/src/tests/objects/GamePercentages.java

@@ -0,0 +1,2 @@
+package tests.objects;public class GamePercentages {
+}

OddsJavaFx/src/tests/objects/XBestGamesDTO.java

@@ -0,0 +1,2 @@
+package tests.objects;public class XBestGamesDTO {
+}

OddsJavaFx/src/tests/objects/XBestGamesWinPercentageStatistics.java

@@ -0,0 +1,2 @@
+package tests.objects;public class XBestGamesWinPercentageStatistics {
+}

OddsJavaFx/src/tests/objects/XGamesPercentages.java

@@ -0,0 +1,2 @@
+package tests.objects;public class XGamesPercentages {
+}