package controllers;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.net.URL;
import java.text.DecimalFormat;
import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.ResourceBundle;

import org.apache.commons.lang3.NotImplementedException;

import com.google.common.collect.Lists;

import data.GuiMysql;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.control.ComboBox;
import javafx.scene.control.DatePicker;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableView;
import javafx.scene.control.cell.MapValueFactory;
import javafx.scene.layout.AnchorPane;
import javafx.scene.text.Text;
import objects.Constants;
import objects.SoccerMatch;

@SuppressWarnings("rawtypes") public class PastResultsController implements Initializable {

	@FXML AnchorPane basePane;
	@FXML TableView<Map<String, Object>> matchTable;
	@FXML DatePicker date;
	@FXML ComboBox<String> countrySelector;
	@FXML ComboBox<String> leagueSelector;

	@FXML TableColumn<Map, String> gameDateColumn = new TableColumn<>("Gamedate");
	@FXML TableColumn<Map, String> homeTeamColumn = new TableColumn<>("Home Team");
	@FXML TableColumn<Map, String> awayTeamColumn = new TableColumn<>("Away Team");
	@FXML TableColumn<Map, Float> odds1Column = new TableColumn<>("odds 1");
	@FXML TableColumn<Map, Float> oddsXColumn = new TableColumn<>("odds X");
	@FXML TableColumn<Map, Float> odds2Column = new TableColumn<>("odds 2");
	@FXML TableColumn<Map, Float> goalsHomeColumn = new TableColumn<>("Goals home");
	@FXML TableColumn<Map, Float> goalsAwayColumn = new TableColumn<>("Goals away");
	@FXML TableColumn<Map, Float> goalDiff = new TableColumn<>("Difference");
	@FXML TableColumn<Map, Float> avgScoreHomeColumn = new TableColumn<>("Avg score home");
	@FXML TableColumn<Map, Float> avgConcededHomeColumn = new TableColumn<>("Avg conceded home");
	@FXML TableColumn<Map, Float> avgScoreAwayColumn = new TableColumn<>("Avg score away");
	@FXML TableColumn<Map, Float> avgConcededAwayColumn = new TableColumn<>("Avg conceded away");

	@FXML TableColumn<Map, String> avgHomeScoredSeason = new TableColumn<>("AvgHomeScoredThisSeason");
	@FXML TableColumn<Map, String> avgHomeConcededSeason = new TableColumn<>("AvgHomeConcededThisSeason");

	@FXML TableColumn<Map, String> avgAwayScoredSeason = new TableColumn<>("AvgAwayScoredThisSeason");
	@FXML TableColumn<Map, String> avgAwayConcededSeason = new TableColumn<>("AvgAwayConcededThisSeason");

	@FXML TableColumn<Map, String> sumScoringColumn = new TableColumn<>("Sum scoring");
	@FXML TableColumn<Map, String> drawColumn = new TableColumn<>("draw");
	@FXML TableColumn<Map, String> awayWinColumn = new TableColumn<>(Constants.AWAY_WIN);

	@FXML Text homeTeamPastResultsText;
	@FXML Text awayTeamPastResultsText;
	@FXML Text previousMeetingsText;

	ObservableList<String> sports = FXCollections.observableArrayList();
	ObservableList<String> countries = FXCollections.observableArrayList();
	ObservableList<String> leagues = FXCollections.observableArrayList();

	private final ArrayList<SimpleEntry<Integer, String>> sportsList = Lists.newArrayList();
	private final ArrayList<SimpleEntry<Integer, String>> countriesList = Lists.newArrayList();
	private final ArrayList<SimpleEntry<Integer, String>> leaguesList = Lists.newArrayList();

	GuiMysql db = GuiMysql.getInstance();

	@Override public void initialize(URL arg0, ResourceBundle arg1) {
		gameDateColumn.setCellValueFactory(new MapValueFactory<>("gameDate"));
		homeTeamColumn.setCellValueFactory(new MapValueFactory<>("homeTeam"));
		awayTeamColumn.setCellValueFactory(new MapValueFactory<>("awayTeam"));
		odds1Column.setCellValueFactory(new MapValueFactory<>("odds1"));
		oddsXColumn.setCellValueFactory(new MapValueFactory<>("oddsX"));
		odds2Column.setCellValueFactory(new MapValueFactory<>("odds2"));
		goalsHomeColumn.setCellValueFactory(new MapValueFactory<>("goalsHome"));
		goalsAwayColumn.setCellValueFactory(new MapValueFactory<>("goalsAway"));
		goalDiff.setCellValueFactory(new MapValueFactory<>("goalDiff"));
		avgScoreHomeColumn.setCellValueFactory(new MapValueFactory<>("avgScoreHome"));
		avgConcededHomeColumn.setCellValueFactory(new MapValueFactory<>("avgConcededHome"));
		avgScoreAwayColumn.setCellValueFactory(new MapValueFactory<>("avgScoreAway"));
		avgConcededAwayColumn.setCellValueFactory(new MapValueFactory<>("avgConcededAway"));

		avgHomeScoredSeason.setCellValueFactory(new MapValueFactory<>("avgScoredHomeSeason"));
		avgHomeConcededSeason.setCellValueFactory(new MapValueFactory<>("avgConcededHomeSeason"));
		avgAwayScoredSeason.setCellValueFactory(new MapValueFactory<>("avgScoredAwaySeason"));
		avgAwayConcededSeason.setCellValueFactory(new MapValueFactory<>("avgConcededAwaySeason"));

		sumScoringColumn.setCellValueFactory(new MapValueFactory<>("sumScoring"));
		drawColumn.setCellValueFactory(new MapValueFactory<>("draw"));
		awayWinColumn.setCellValueFactory(new MapValueFactory<>(Constants.AWAY_WIN));

		basePane.setPrefWidth(0.0);
		basePane.setPrefHeight(0.0);

		date.valueProperty().addListener((ov, oldValue, newValue) -> {
			clear();
			getCountriesAtDate();
		});

		sportsList.addAll(GuiMysql.getInstance().getSports());
		sports.add(MainController.SPORT);
		for (final SimpleEntry<Integer, String> entry : sportsList) {
			if (entry.getValue().equals("soccer")) { // Anv�nder just nu bara Soccer
				sports.add(entry.getValue());
			}
		}

		countrySelector.setItems(countries);
		leagueSelector.setItems(leagues);

		matchTable.getSelectionModel().selectedItemProperty().addListener((obs, oldSelection, newSelection) -> {
			updateMatchStats(newSelection);
		});
	}

	private void updateMatchStats(Map<String, Object> newSelection) {
		if (newSelection != null) {
			Map<String, String> previousMatches = db.getPreviousMatches(5, newSelection.get("homeTeam").toString(),
					newSelection.get("awayTeam").toString(), date.getValue().toString(), getCountryIdFromSelector(), getLeagueIdFromSelector());
			homeTeamPastResultsText.setText(previousMatches.get("PrevHomeTeam"));
			awayTeamPastResultsText.setText(previousMatches.get("PrevAwayTeam"));
			previousMeetingsText.setText(previousMatches.get("PrevCombined"));
		}
	}

	private void clear() {
		matchTable.getItems().clear();
		countriesList.clear();
		leaguesList.clear();
		countries.clear();
		leagues.clear();
	}

	private void getCountriesAtDate() {
		countriesList.clear();
		countriesList.addAll(GuiMysql.getInstance().getCountriesBySport(db.getSportId(MainController.SPORT), date.getValue().toString()));

		countriesList.forEach(c -> countries.add(c.getValue()));
	}

	private void getLeaguesAtDate(int countryId) {
		leaguesList.clear();
		leaguesList.addAll(db.getLeaguesByDate(db.getSportId("soccer"), countryId, date.getValue().toString()));

		leaguesList.forEach(l -> leagues.add(l.getValue()));
	}

	@FXML private void getResults() {
		throw new NotImplementedException();
	}

	@FXML private void countrySelected(ActionEvent event) {
		if (getCountryIdFromSelector() != null) {
			getLeaguesAtDate(getCountryIdFromSelector());
			leagueSelector.setDisable(false);
		}
	}

	private Integer getCountryIdFromSelector() {
		Optional<SimpleEntry<Integer, String>> o = countriesList.stream().filter(p -> p.getValue().equals(countrySelector.getValue())).findFirst();
		return o.isPresent() ? o.get().getKey() : null;
	}

	private Integer getLeagueIdFromSelector() {
		Optional<SimpleEntry<Integer, String>> o = leaguesList.stream().filter(p -> p.getValue().equals(leagueSelector.getValue())).findFirst();
		return o.isPresent() ? o.get().getKey() : null;
	}

	@FXML private void leagueSelected(ActionEvent event) {
		if (getCountryIdFromSelector() != null) {
			List<SoccerMatch> matchesList = db.getMatches(db.getSportId(MainController.SOCCER), getCountryIdFromSelector(),
					db.getLeagueId(db.getSportId(MainController.SOCCER), getCountryIdFromSelector(), leagueSelector.getValue()),
					date.getValue().toString(), "ASC", true);

			ObservableList<Map<String, Object>> matches = FXCollections.<Map<String, Object>>observableArrayList();

			for (final SoccerMatch soccerMatch : matchesList) {

				final Map<String, Object> match = new HashMap<>();
				match.put("homeTeam", soccerMatch.getHomeTeam().getTeamName());
				match.put("awayTeam", soccerMatch.getAwayTeam().getTeamName());
				match.put("odds1", soccerMatch.getOdds1());
				match.put("oddsX", soccerMatch.getOddsX());
				match.put("odds2", soccerMatch.getOdds2());

				final List<Float> avgHomeTeamGoals = calculateAvgHomeScore(soccerMatch.getHomeTeam().getTeamId());
				final List<Float> avgAwayTeamGoals = calculateAvgAwayScore(soccerMatch.getAwayTeam().getTeamId());

				final List<Float> avgHomeTeamGoalsThisSeason = calculateAvgHomeScoreThisSeason(soccerMatch.getHomeTeam().getTeamId(),
						soccerMatch.getHomeTeam().getCountryId(), soccerMatch.getHomeTeam().getTeamLeagueId());
				final List<Float> avgAwayTeamGoalsThisSeason = calculateAvgAwayScoreThisSeason(soccerMatch.getAwayTeam().getTeamId(),
						soccerMatch.getAwayTeam().getCountryId(), soccerMatch.getAwayTeam().getTeamLeagueId());

				match.put("gameDate", soccerMatch.getGameDate().toString());
				match.put("avgScoreHome", avgHomeTeamGoals.get(0));
				match.put("avgConcededHome", avgHomeTeamGoals.get(1));
				match.put("avgScoreAway", avgAwayTeamGoals.get(0));
				match.put("avgConcededAway", avgAwayTeamGoals.get(1));

				match.put("avgScoredHomeSeason", avgHomeTeamGoalsThisSeason.get(0));
				match.put("avgConcededHomeSeason", avgHomeTeamGoalsThisSeason.get(1));

				match.put("avgScoredAwaySeason", avgAwayTeamGoalsThisSeason.get(0));
				match.put("avgConcededAwaySeason", avgAwayTeamGoalsThisSeason.get(1));

				match.put("sumScoring", avgHomeTeamGoalsThisSeason.get(0) * avgAwayTeamGoalsThisSeason.get(1)
						+ avgAwayTeamGoalsThisSeason.get(0) * avgHomeTeamGoalsThisSeason.get(1));

				match.put("goalsHome",
						GuiMysql.getInstance().round(BigDecimal.valueOf(avgHomeTeamGoalsThisSeason.get(0) + avgAwayTeamGoalsThisSeason.get(1)),
								GuiMysql.getInstance().getIncrement(), RoundingMode.HALF_UP));
				match.put("goalsAway",
						GuiMysql.getInstance().round(BigDecimal.valueOf(avgAwayTeamGoalsThisSeason.get(0) + avgHomeTeamGoalsThisSeason.get(1)),
								GuiMysql.getInstance().getIncrement(), RoundingMode.HALF_UP));

				match.put("goalDiff",
						GuiMysql.getInstance()
								.round(BigDecimal.valueOf((avgHomeTeamGoalsThisSeason.get(0) * avgAwayTeamGoalsThisSeason.get(1))
										+ (avgAwayTeamGoalsThisSeason.get(0) * avgHomeTeamGoalsThisSeason.get(1))),
										GuiMysql.getInstance().getIncrement(), RoundingMode.HALF_UP));
				match.put("country", soccerMatch.getHomeTeam().getCountryName());
				match.put(Constants.LEAGUE, soccerMatch.getHomeTeam().getTeamLeague());

				final DecimalFormat df = new DecimalFormat("#.##");
				df.setRoundingMode(RoundingMode.CEILING);

//			final League leagueInfo = GuiMysql.getInstance().getLeagueInfo(soccerMatch.getHomeTeam().getTeamLeague());

				matches.add(match);
			}
			matchTable.getItems().addAll(matches);
		}
	}

	private List<Float> calculateAvgHomeScore(int teamId) {
		return GuiMysql.getInstance().getAvgHomeScore(teamId);
	}

	private List<Float> calculateAvgAwayScore(int teamId) {
		return GuiMysql.getInstance().getAvgAwayScore(teamId);
	}

	private List<Float> calculateAvgHomeScoreThisSeason(int teamId, int countryId, int leagueId) {
		return GuiMysql.getInstance().getAvgHomeScoreThisSeason(teamId, countryId, leagueId, date.getValue().toString());
	}

	private List<Float> calculateAvgAwayScoreThisSeason(int teamId, int countryId, int leagueId) {
		return GuiMysql.getInstance().getAvgAwayScoreThisSeason(teamId, countryId, leagueId, date.getValue().toString());
	}

	@FXML private void updateStatsTable() {
		StatisticsTabController.getInstance().setOverUnderTable(getLeagueIdFromSelector(), date.getValue().toString());
	}

	@FXML private void updateStandingsTable() {
		String seasonFromDate = GuiMysql.getInstance().getSeasonFromDate(getCountryIdFromSelector(), getLeagueIdFromSelector(),
				date.getValue().toString());
		MatchStatTabController.getInstance().setLeagueStandingsTable(getLeagueIdFromSelector(), seasonFromDate, getCountryIdFromSelector(),
				date.getValue().toString());
	}
}