martin
/
schachliga-deluxe


								package app.views.match.components;


								import app.data.bean.CalculatedMatch;

								import app.data.entity.Game;

								import app.data.entity.Match;

								import app.data.service.ChessComService;

								import app.data.service.MatchService;

								import app.gameimage.GameImageService;

								import app.navigation.match.MatchNavigation;

								import app.utils.ComponentUtils;

								import app.utils.StringUtils;

								import app.views.navigation.interfaces.ContentConfigurable;

								import com.vaadin.flow.component.button.Button;

								import com.vaadin.flow.component.button.ButtonVariant;

								import com.vaadin.flow.component.html.Div;

								import com.vaadin.flow.component.html.Label;

								import com.vaadin.flow.component.icon.Icon;

								import com.vaadin.flow.component.icon.VaadinIcon;

								import com.vaadin.flow.component.orderedlayout.FlexComponent;

								import com.vaadin.flow.component.orderedlayout.FlexLayout;

								import com.vaadin.flow.component.orderedlayout.HorizontalLayout;

								import com.vaadin.flow.component.orderedlayout.VerticalLayout;

								import org.springframework.beans.factory.annotation.Autowired;


								import java.util.NoSuchElementException;


								public class MatchComponent extends Div implements ContentConfigurable {


								    private final MatchNavigation matchNavigation;

								    private final MatchService matchService;

								    private final GameImageService gameImageService;


								    private final VerticalLayout headerLayout = new VerticalLayout();

								    private final HorizontalLayout headerPlayersLayout = new HorizontalLayout();

								    private final Label headerResultLabel = new Label();


								    private final FlexLayout gamesLayout = new FlexLayout();

								    private final VerticalLayout noGamesLayout = new VerticalLayout();


								    private final FlexLayout editLayout = new FlexLayout();

								    private final EditMatchCard editMatchCard;


								    private Match match;

								    private CalculatedMatch calculatedMatch;


								    public MatchComponent(MatchNavigation matchNavigation,

								                          @Autowired ChessComService chessComService,

								                          @Autowired GameImageService gameImageService) {

								        this.matchNavigation = matchNavigation;

								        this.matchService = matchNavigation.getMatchService();

								        this.gameImageService = gameImageService;


								        this.editMatchCard = new EditMatchCard(matchNavigation, chessComService, gameImageService);


								        defineLayout();

								    }


								    ////////////

								    // LAYOUT //

								    ////////////


								    private void defineLayout() {

								        add(headerLayout);


								        defineHeaderLayout();

								        defineGamesLayout();

								        defineNoGamesLayout();

								        defineEditLayout();

								    }


								    private void defineHeaderLayout() {

								        headerLayout.add(headerPlayersLayout, headerResultLabel);


								        headerPlayersLayout.addClassName("match-header-players");


								        headerResultLabel.addClassName("match-header-result");

								        headerResultLabel.addClassName("bold-header");

								    }


								    private void defineGamesLayout() {

								        gamesLayout.setFlexWrap(FlexLayout.FlexWrap.WRAP);

								        gamesLayout.setJustifyContentMode(FlexComponent.JustifyContentMode.CENTER);

								    }


								    private void defineNoGamesLayout() {

								        noGamesLayout.add(createNoGamesLabel(), createAddGamesButton());

								        noGamesLayout.setAlignItems(FlexComponent.Alignment.CENTER);

								    }


								    private Label createNoGamesLabel() {

								        return new Label("No games for this match in the database.");

								    }


								    private Button createAddGamesButton() {

								        Button button = new Button("Add games", new Icon(VaadinIcon.PLUS));

								        button.addThemeVariants(ButtonVariant.LUMO_PRIMARY);

								        button.addClickListener(event -> {

								            matchNavigation.setEditFlag(true);

								            remove(noGamesLayout);

								        });

								        return button;

								    }


								    private void defineEditLayout() {

								        editLayout.setJustifyContentMode(FlexComponent.JustifyContentMode.CENTER);

								        editLayout.add(editMatchCard);

								    }


								    /////////////

								    // CONTENT //

								    /////////////


								    @Override

								    public void configureContent() {

								        try {

								            match = matchNavigation.getSelectedMatch().orElseThrow();

								            calculatedMatch = matchService.getCalculatedMatch(match);

								            configureHeaderContent();

								            configureMainContent();

								        } catch (NoSuchElementException e) {

								            gamesLayout.removeAll();

								            add(matchNavigation.getValidationLabel());

								        }

								    }


								    private void configureHeaderContent() {

								        configureHeaderPlayersLayout();

								        configureHeaderResultLabel();

								    }


								    private void configureHeaderPlayersLayout() {

								        HorizontalLayout player1 = ComponentUtils.getPlayerLabel(calculatedMatch.getPlayer1());

								        HorizontalLayout player2 = ComponentUtils.getPlayerLabel(calculatedMatch.getPlayer2());

								        Label vs = new Label("vs.");


								        headerPlayersLayout.removeAll();

								        headerPlayersLayout.add(player1, vs, player2);

								    }


								    private void configureHeaderResultLabel() {

								        if (match.getGames().isEmpty() || matchNavigation.editFlag()) {

								            headerLayout.remove(headerResultLabel);

								        } else {

								            headerLayout.add(headerResultLabel);

								            headerResultLabel.setText(String.format("%s",

								                    StringUtils.getResultString("-", calculatedMatch.getScore1(), calculatedMatch.getScore2())));

								        }

								    }


								    private void configureMainContent() {

								        if (matchNavigation.editFlag()) {

								            remove(gamesLayout);

								            add(editLayout);

								            editMatchCard.configureContent(match);

								            return;

								        }

								        remove(editLayout);

								        configureGamesContent();

								    }


								    private void configureGamesContent() {

								        if (match.getGames().isEmpty()) {

								            remove(gamesLayout);

								            add(noGamesLayout);

								            return;

								        }


								        remove(noGamesLayout);

								        add(gamesLayout);


								        gamesLayout.removeAll();

								        for (Game game : match.getGames()) {

								            gamesLayout.add(new GameCard(game, gameImageService));

								        }

								    }

								}