Assembly64.java

package ui.assembly64;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import javafx.animation.PauseTransition;
import javafx.animation.SequentialTransition;
import javafx.application.Platform;
import javafx.beans.property.ObjectProperty;
import javafx.collections.FXCollections;
import javafx.collections.ListChangeListener.Change;
import javafx.collections.ObservableList;
import javafx.collections.transformation.SortedList;
import javafx.fxml.FXML;
import javafx.scene.control.*;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.input.KeyCode;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.util.Duration;
import libsidplay.sidtune.SidTuneError;
import server.restful.common.parameter.requestpath.impl.FileRequestPathServletParametersImpl;
import sidplay.Player;
import ui.common.*;
import ui.common.converter.EnumToStringConverter;
import ui.common.converter.IntegerToStringConverter;
import ui.common.filefilter.DiskFileFilter;
import ui.common.filefilter.TapeFileFilter;
import ui.directory.Directory;
import ui.entities.config.Assembly64Column;
import ui.entities.config.Assembly64ColumnType;

import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.time.LocalDate;
import java.time.Year;
import java.time.YearMonth;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

import static java.util.stream.IntStream.*;
import static javafx.scene.control.ProgressIndicator.INDETERMINATE_PROGRESS;
import static ui.assembly64.SearchResult.*;

public class Assembly64 extends C64VBox implements UIPart {

    public static final String ID = "ASSEMBLY64";

    private static final int MAX_ROWS = 500;

    private static final int DEFAULT_WIDTH = 150;

    @FXML
    private BorderPane borderPane;

    @FXML
    private HBox hBox;

    @FXML
    private VBox nameVBox, groupVBox, handleVBox, eventVBox, ratingVBox, categoryVBox, updatedVBox, releasedVBox;

    @FXML
    private TextField nameTextField, groupTextField, handleTextField, eventTextField, updatedTextField;

    @FXML
    private TypeTextField releasedTextField;

    @FXML
    private ComboBox<Category> categoryComboBox;

    @FXML
    private ComboBox<HomeServer> serverComboBox;

    @FXML
    private Label serverStatus;

    private Assembly64Client assembly64Client;
    private String categoryType = "category";
    private boolean changingServer;
    private boolean closed;
    private int serverGeneration;

    @FXML
    private ComboBox<Integer> ratingComboBox;

    @FXML
    private ComboBox<Age> ageComboBox;

    @FXML
    private CheckBox d64CheckBox, t64CheckBox, d81CheckBox, d71CheckBox, prgCheckBox, tapCheckBox, crtCheckBox,
            sidCheckBox, binCheckBox, g64CheckBox;

    @FXML
    private TableView<SearchResult> assembly64Table;

    @FXML
    private TableView<ContentEntry> contentEntryTable;

    @FXML
    private TableColumn<ContentEntry, String> contentEntryFilenameColumn;

    @FXML
    private ContextMenu assembly64ContextMenu, contentEntryContextMenu;

    @FXML
    private Menu addColumnMenu;

    @FXML
    private MenuItem removeColumnMenuItem, insertDiskMenuItem, insertTapeMenuItem, autostartMenuItem;

    @FXML
    private Button prevButton, nextButton;

    @FXML
    private Directory directory;

    @FXML
    private ObjectProperty<SearchResult> currentlyPlayedSearchResultRowProperty;

    @FXML
    private ObjectProperty<ContentEntry> currentlyPlayedContentEntryRowProperty;

    private ObservableList<Category> categoryItems;
    private ObservableList<SearchResult> searchResultItems;
    private ObservableList<ContentEntry> contentEntryItems;

    private SearchResult searchResult;

    private ContentEntry contentEntry;

    private File contentEntryFile;

    private int searchOffset, searchStop = MAX_ROWS;

    private DiskFileFilter diskFileFilter;

    private TapeFileFilter tapeFileFilter;

    private ObjectMapper objectMapper;

    private Convenience convenience;

    private AtomicBoolean autostart;

    private SequentialTransition sequentialTransitionSearchResult, sequentialTransitionContentEntries;

    private TablePosition<?, ?> searchResultTableSelectedCell;

    public Assembly64() {
        super();
    }

    public Assembly64(C64Window window, Player player) {
        super(window, player);
    }

    @FXML
    @Override
    protected void initialize() {
        autostart = new AtomicBoolean();
        convenience = new Convenience(util.getPlayer());
        diskFileFilter = new DiskFileFilter();
        tapeFileFilter = new TapeFileFilter();

        categoryItems = FXCollections.observableArrayList(Category.ALL);
        objectMapper = createObjectMapper();

        searchResultItems = FXCollections.observableArrayList();
        SortedList<SearchResult> sortedSearchResultList = new SortedList<>(searchResultItems);
        sortedSearchResultList.comparatorProperty().bind(assembly64Table.comparatorProperty());
        assembly64Table.setItems(sortedSearchResultList);
        assembly64Table.getSelectionModel().selectedItemProperty().addListener((s, o, n) -> getContentEntries(false));
        assembly64Table.getSelectionModel().setSelectionMode(SelectionMode.SINGLE);
        assembly64Table.setOnMousePressed(e -> getContentEntries(e.isPrimaryButtonDown() && e.getClickCount() > 1));
        assembly64Table.setOnKeyPressed(event -> getContentEntries(event.getCode() == KeyCode.ENTER));
        assembly64Table.getColumns().addListener((Change<? extends TableColumn<SearchResult, ?>> change) -> {
            while (change.next()) {
                if (change.wasReplaced()) {
                    moveColumn();
                }
            }
        });
        assembly64ContextMenu.setOnShown(event -> showAssembly64ContextMenu());
        restoreColumns();

        contentEntryItems = FXCollections.observableArrayList();
        SortedList<ContentEntry> sortedContentEntryList = new SortedList<>(contentEntryItems);
        sortedContentEntryList.comparatorProperty().bind(contentEntryTable.comparatorProperty());
        contentEntryTable.setItems(sortedContentEntryList);
        contentEntryTable.getSelectionModel().selectedItemProperty().addListener((s, o, n) -> getContentEntry(false));
        contentEntryTable.getSelectionModel().setSelectionMode(SelectionMode.SINGLE);
        contentEntryTable.setOnMousePressed(e -> getContentEntry(e.isPrimaryButtonDown() && e.getClickCount() > 1));
        contentEntryTable.setOnKeyReleased(event -> getContentEntry(event.getCode() == KeyCode.ENTER));
        contentEntryTable.prefWidthProperty().bind(assembly64Table.widthProperty().multiply(0.5));
        contentEntryTable.prefHeightProperty().bind(borderPane.heightProperty().multiply(0.4));
        contentEntryContextMenu.setOnShown(event -> showContentEntryContextMenu());
        contentEntryFilenameColumn.prefWidthProperty().bind(contentEntryTable.widthProperty());

        directory.getAutoStartFileProperty().addListener((s, o, n) -> autostart(n));
        directory.prefWidthProperty().bind(assembly64Table.widthProperty().multiply(0.5));
        directory.prefHeightProperty().bind(borderPane.heightProperty().multiply(0.4));

        ratingComboBox.setItems(FXCollections
                .observableArrayList(concat(of(0), rangeClosed(1, 10)).boxed().collect(Collectors.toList())));
        ratingComboBox.getSelectionModel().select(0);
        ratingComboBox.setConverter(new IntegerToStringConverter(util.getBundle(), "ALL_CONTENT"));

        ageComboBox.setConverter(new EnumToStringConverter<>(util.getBundle()));
        ageComboBox.setItems(FXCollections.observableArrayList(Age.values()));
        ageComboBox.getSelectionModel().select(Age.ALL);

        categoryComboBox.setConverter(new CategoryToStringConverter<Category>(util.getBundle()));
        categoryComboBox.setItems(categoryItems);
        categoryComboBox.getSelectionModel().select(Category.ALL);

        PauseTransition pauseTransitionSearchResult = new PauseTransition(Duration.millis(1000));
        sequentialTransitionSearchResult = new SequentialTransition(pauseTransitionSearchResult);
        sequentialTransitionSearchResult.setCycleCount(1);
        pauseTransitionSearchResult.setOnFinished(evt -> requestSearchResults());

        Assembly64RowFactory assembly64RowFactory = new Assembly64RowFactory();
        assembly64RowFactory.setCurrentlyPlayedRowProperty(currentlyPlayedSearchResultRowProperty);
        assembly64Table.setRowFactory(assembly64RowFactory);

        PauseTransition pauseTransitionContentEntries = new PauseTransition(Duration.millis(500));
        sequentialTransitionContentEntries = new SequentialTransition(pauseTransitionContentEntries);
        sequentialTransitionContentEntries.setCycleCount(1);
        pauseTransitionContentEntries.setOnFinished(evt -> requestContentEntries());

        ContentEntryRowFactory contentEntryRowFactory = new ContentEntryRowFactory();
        contentEntryRowFactory.setCurrentlyPlayedContentEntryProperty(currentlyPlayedContentEntryRowProperty);
        contentEntryTable.setRowFactory(contentEntryRowFactory);
        refreshServers();
    }

    private <T> void background(Callable<T> request, BiConsumer<T, Throwable> completed) {
        CompletableFuture.supplyAsync(() -> {
            try {
                return request.call();
            } catch (Exception e) {
                throw new CompletionException(e);
            }
        }).whenComplete((result, error) -> Platform.runLater(() -> {
            if (!closed) completed.accept(result, error);
        }));
    }

    @FXML
    private void refreshServers() {
        int generation = ++serverGeneration;
        HomeServer previous = serverComboBox.getValue();
        assembly64Client = null;
        sequentialTransitionSearchResult.stop();
        sequentialTransitionContentEntries.stop();
        serverComboBox.setDisable(true);
        serverStatus.setText(util.getBundle().getString("LOADING"));
        background(() -> Assembly64Client.getServers(util.getConfig(), true), (servers, error) -> {
            if (generation != serverGeneration) return;
            changingServer = true;
            if (error == null) {
                serverComboBox.setItems(FXCollections.observableArrayList(servers));
            } else {
                System.err.println("Assembly64 server discovery failed: " + error.getMessage());
                if (serverComboBox.getItems().isEmpty()) {
                    serverComboBox.getItems().add(new HomeServer(HomeServer.CONFIGURED_SERVER,
                            util.getConfig().getOnlineSection().getAssembly64Url(), "Assembly64 (CSDB)"));
                }
            }
            serverComboBox.setValue(serverComboBox.getItems().stream()
                    .filter(server -> previous != null && Objects.equals(previous.getId(), server.getId())).findFirst()
                    .orElse(serverComboBox.getItems().get(0)));
            changingServer = false;
            serverComboBox.setDisable(false);
            loadSelectedServer(error == null ? "" : util.getBundle().getString("SERVERS_UNAVAILABLE"));
        });
    }

    @FXML
    private void selectServer() {
        loadSelectedServer("");
    }

    private void loadSelectedServer(String discoveryStatus) {
        if (changingServer || serverComboBox.getValue() == null) return;
        int generation = ++serverGeneration;
        sequentialTransitionSearchResult.stop();
        sequentialTransitionContentEntries.stop();
        assembly64Client = null;
        searchResult = null;
        contentEntry = null;
        contentEntryFile = null;
        autostart.set(false);
        searchResultItems.clear();
        contentEntryItems.clear();
        directory.clear();
        prevButton.setDisable(true);
        nextButton.setDisable(true);
        serverStatus.setText(util.getBundle().getString("LOADING"));
        categoryItems.setAll(Category.ALL);
        categoryComboBox.getSelectionModel().select(Category.ALL);
        Assembly64Client client = new Assembly64Client(util.getConfig(), serverComboBox.getValue());
        background(client::getPresets, (presets, error) -> {
            if (generation != serverGeneration) return;
            changingServer = true;
            if (error == null) {
                categoryType = Assembly64Client.categoryType(presets);
                categoryItems.setAll(Assembly64Client.categories(presets));
                categoryItems.add(0, Category.ALL);
                assembly64Client = client;
                serverStatus.setText(discoveryStatus);
            } else {
                serverStatus.setText(util.getBundle().getString("SERVER_UNAVAILABLE"));
                System.err.println("Assembly64 presets failed: " + error.getMessage());
            }
            categoryComboBox.getSelectionModel().select(Category.ALL);
            changingServer = false;
            if (assembly64Client != null) search();
        });
    }

    @Override
    public void doClose() {
        closed = true;
        ++serverGeneration;
        sequentialTransitionSearchResult.stop();
        sequentialTransitionContentEntries.stop();
    }

    @FXML
    private void removeColumn() {
        if (searchResultTableSelectedCell == null) {
            return;
        }
        TableColumn<?, ?> tableColumn = searchResultTableSelectedCell.getTableColumn();
        assembly64Table.getColumns().remove(tableColumn);
        removeColumn((Assembly64Column) tableColumn.getUserData());
    }

    @FXML
    private void search() {
        if (changingServer || sequentialTransitionSearchResult == null || assembly64Client == null) return;
        searchOffset = 0;
        searchAgain();
    }

    @FXML
    private void prevPage() {
        searchOffset -= MAX_ROWS;
        searchAgain();
    }

    @FXML
    private void nextPage() {
        searchOffset = searchStop;
        searchAgain();
    }

    @FXML
    private void autostart() {
        autostart(null);
    }

    @FXML
    private void insertDisk() {
        if (contentEntryFile != null) {
            try {
                util.getPlayer().insertDisk(contentEntryFile);
            } catch (IOException e) {
                System.err.printf("Cannot insert media file '%s'.%n", contentEntry.getPath());
            }
        }
    }

    @FXML
    private void insertTape() {
        if (contentEntryFile != null) {
            try {
                util.getPlayer().insertTape(contentEntryFile);
            } catch (IOException | SidTuneError e) {
                System.err.printf("Cannot insert media file '%s'.%n", contentEntry.getPath());
            }
        }
    }

    private void restoreColumns() {
        hBox.getChildren().clear();
        util.getConfig().getAssembly64Section().getColumns().removeIf(column -> column.getColumnType() == null);
        for (Assembly64Column column : util.getConfig().getAssembly64Section().getColumns()) {
            setColumnWidth(column, addColumn(column).getPrefWidth());
        }
    }

    private void showAssembly64ContextMenu() {
        searchResultTableSelectedCell = assembly64Table.getSelectionModel().getSelectedCells().stream().findFirst()
                .orElse(null);
        removeColumnMenuItem
                .setDisable(searchResultTableSelectedCell == null || searchResultTableSelectedCell.getColumn() <= 0);
        removeColumnMenuItem.setText(String.format(util.getBundle().getString("REMOVE_COLUMN"),
                !removeColumnMenuItem.isDisable() ? searchResultTableSelectedCell.getTableColumn().getText() : "?"));

        List<Assembly64ColumnType> columnTypes = new ArrayList<>(Arrays.asList(Assembly64ColumnType.values()));
        columnTypes.removeIf(columnType -> assembly64Table.getColumns().stream()
                .map(tableColumn -> ((Assembly64Column) tableColumn.getUserData()).getColumnType())
                .collect(Collectors.toList()).contains(columnType));

        addColumnMenu.getItems().clear();
        for (Assembly64ColumnType columnType : columnTypes) {
            addAddColumnHeaderMenuItem(columnType);
        }
    }

    private void showContentEntryContextMenu() {
        ContentEntry contentEntry = contentEntryTable.getSelectionModel().getSelectedItem();
        insertDiskMenuItem.setDisable(contentEntry == null || !diskFileFilter.accept(new File(contentEntry.getPath())));
        insertTapeMenuItem.setDisable(contentEntry == null || !tapeFileFilter.accept(new File(contentEntry.getPath())));
        autostartMenuItem.setDisable(contentEntry == null);
    }

    private void addAddColumnHeaderMenuItem(Assembly64ColumnType columnType) {
        MenuItem menuItem = new MenuItem();
        menuItem.setText(util.getBundle().getString(columnType.name()));
        menuItem.setOnAction(event -> {
            Assembly64Column column = new Assembly64Column();
            column.setColumnType(columnType);
            addColumn(column);
            util.getConfig().getAssembly64Section().getColumns().add(column);
        });
        addColumnMenu.getItems().add(menuItem);
    }

    private TableColumn<SearchResult, ?> addColumn(Assembly64Column column) {
        Assembly64ColumnType columnType = column.getColumnType();

        TableColumn<SearchResult, ?> tableColumn;
        switch (columnType) {
            case RATING:
                TableColumn<SearchResult, Integer> tableColumnInteger = new TableColumn<>();
                tableColumn = tableColumnInteger;
                tableColumnInteger.setCellValueFactory(
                        new PropertyValueFactory<>(columnType.name().toLowerCase()));
                tableColumnInteger.setCellFactory(new ZeroIgnoringCellFactory());
                break;
            case UPDATED:
            case RELEASED:
                TableColumn<SearchResult, LocalDate> tableColumnLocalDate = new TableColumn<>();
                tableColumn = tableColumnLocalDate;
                tableColumnLocalDate.setCellValueFactory(
                        new PropertyValueFactory<>(columnType.name().toLowerCase()));
                break;
            default:
                TableColumn<SearchResult, String> tableColumnString = new TableColumn<>();
                tableColumn = tableColumnString;
                tableColumnString.setCellValueFactory(
                        new PropertyValueFactory<>(columnType.name().toLowerCase()));
                break;
        }
        tableColumn.setUserData(column);
        tableColumn.setText(util.getBundle().getString(columnType.name()));
        tableColumn.setPrefWidth(column.getWidth() != 0 ? column.getWidth() : DEFAULT_WIDTH);
        tableColumn.widthProperty().addListener((observable, oldValue, newValue) -> {
            column.setWidth(newValue.doubleValue());
            setColumnWidth(column, newValue);
        });
        assembly64Table.getColumns().add(tableColumn);
        switch (columnType) {
            case NAME:
                hBox.getChildren().add(nameVBox);
                break;
            case GROUP:
                hBox.getChildren().add(groupVBox);
                break;
            case HANDLE:
                hBox.getChildren().add(handleVBox);
                break;
            case EVENT:
                hBox.getChildren().add(eventVBox);
                break;
            case RATING:
                hBox.getChildren().add(ratingVBox);
                break;
            case CATEGORY:
                hBox.getChildren().add(categoryVBox);
                break;
            case UPDATED:
                hBox.getChildren().add(updatedVBox);
                break;
            case RELEASED:
                hBox.getChildren().add(releasedVBox);
                break;
            default:
                break;
        }
        return tableColumn;
    }

    private void setColumnWidth(Assembly64Column column, Number width) {
        switch (column.getColumnType()) {
            case NAME:
                nameTextField.setPrefWidth(width.doubleValue());
                break;
            case GROUP:
                groupTextField.setPrefWidth(width.doubleValue());
                break;
            case HANDLE:
                handleTextField.setPrefWidth(width.doubleValue());
                break;
            case EVENT:
                eventTextField.setPrefWidth(width.doubleValue());
                break;
            case RATING:
                ratingComboBox.setPrefWidth(width.doubleValue());
                break;
            case CATEGORY:
                categoryComboBox.setPrefWidth(width.doubleValue());
                break;
            case UPDATED:
                updatedTextField.setPrefWidth(width.doubleValue());
                break;
            case RELEASED:
                releasedTextField.setPrefWidth(width.doubleValue());
                break;
        }
    }

    private void removeColumn(Assembly64Column column) {
        boolean repeatSearch = false;
        switch (column.getColumnType()) {
            case NAME:
                hBox.getChildren().remove(nameVBox);
                repeatSearch = !nameTextField.getText().isEmpty();
                nameTextField.setText("");
                break;
            case GROUP:
                hBox.getChildren().remove(groupVBox);
                repeatSearch = !groupTextField.getText().isEmpty();
                groupTextField.setText("");
                break;
            case HANDLE:
                hBox.getChildren().remove(handleVBox);
                repeatSearch = !handleTextField.getText().isEmpty();
                handleTextField.setText("");
                break;
            case EVENT:
                hBox.getChildren().remove(eventVBox);
                repeatSearch = !eventTextField.getText().isEmpty();
                eventTextField.setText("");
                break;
            case RATING:
                hBox.getChildren().remove(ratingVBox);
                repeatSearch = ratingComboBox.getSelectionModel().getSelectedIndex() > 0;
                ratingComboBox.getSelectionModel().select(0);
                break;
            case CATEGORY:
                hBox.getChildren().remove(categoryVBox);
                repeatSearch = categoryComboBox.getSelectionModel().getSelectedIndex() > 0;
                categoryComboBox.getSelectionModel().select(Category.ALL);
                break;
            case UPDATED:
                hBox.getChildren().remove(updatedVBox);
                break;
            case RELEASED:
                hBox.getChildren().remove(releasedVBox);
                repeatSearch = !releasedTextField.getText().isEmpty();
                break;

            default:
                break;
        }
        util.getConfig().getAssembly64Section().getColumns().remove(column);
        if (repeatSearch) {
            search();
        }
    }

    private void moveColumn() {
        hBox.getChildren().clear();
        util.getConfig().getAssembly64Section().getColumns().clear();
        assembly64Table.getColumns().stream().map(tableColumn -> (Assembly64Column) tableColumn.getUserData())
                .filter(column -> {
                    switch (column.getColumnType()) {
                        case NAME:
                            return hBox.getChildren().add(nameVBox);
                        case GROUP:
                            return hBox.getChildren().add(groupVBox);
                        case HANDLE:
                            return hBox.getChildren().add(handleVBox);
                        case EVENT:
                            return hBox.getChildren().add(eventVBox);
                        case RATING:
                            return hBox.getChildren().add(ratingVBox);
                        case CATEGORY:
                            return hBox.getChildren().add(categoryVBox);
                        case UPDATED:
                            return hBox.getChildren().add(updatedVBox);
                        case RELEASED:
                            return hBox.getChildren().add(releasedVBox);
                        default:
                            return false;
                    }
                }).forEach(column -> util.getConfig().getAssembly64Section().getColumns().add(column));
    }

    private ObjectMapper createObjectMapper() {
        JavaTimeModule module = new JavaTimeModule();
        module.addDeserializer(Category.class, new CategoryDeserializer(categoryItems));
        return new ObjectMapper().registerModule(module);
    }

    private void searchAgain() {
        sequentialTransitionContentEntries.stop();
        searchResult = null;
        contentEntry = null;
        contentEntryFile = null;
        autostart.set(false);
        prevButton.setDisable(true);
        nextButton.setDisable(true);
        searchResultItems.clear();
        contentEntryItems.clear();
        directory.clear();
        Platform.runLater(() -> util.progressProperty(assembly64Table.getScene()).set(INDETERMINATE_PROGRESS));
        sequentialTransitionSearchResult.playFromStart();
    }

    private void requestSearchResults() {
        try {
            if (assembly64Client == null) return;

            final String name = get(nameTextField);
            final String group = get(groupTextField);
            final String handle = get(handleTextField);
            final String event = get(eventTextField);
            final Integer rating = get(ratingComboBox, value -> value, Integer.valueOf(0)::equals, null);
            final String subCategory = get(categoryComboBox, Category::getType, Category.ALL::equals, null);
            final Integer days = get(ageComboBox, Age::getDays, Age.ALL::equals, -1);
            final String dateFrom = get(releasedTextField, true);
            final String dateTo = get(releasedTextField, false);
            final String d64 = get(d64CheckBox);
            final String t64 = get(t64CheckBox);
            final String d71 = get(d71CheckBox);
            final String d81 = get(d81CheckBox);
            final String prg = get(prgCheckBox);
            final String tap = get(tapCheckBox);
            final String crt = get(crtCheckBox);
            final String sid = get(sidCheckBox);
            final String bin = get(binCheckBox);
            final String g64 = get(g64CheckBox);

            try {
                Collection<String> searchCriterias = new ArrayList<>();
                if (name != null) {
                    searchCriterias.add("name:\"%" + name + "\"");
                }
                if (group != null) {
                    searchCriterias.add("group:\"" + group + "\"");
                }
                if (handle != null) {
                    searchCriterias.add("handle:\"" + handle + "\"");
                }
                if (event != null) {
                    searchCriterias.add("event:\"%" + event + "\"");
                }
                if (rating != null) {
                    searchCriterias.add("rating:>=" + rating);
                }
                if (subCategory != null) {
                    searchCriterias.add(categoryType + ":" + subCategory);
                }
                if (days > 0) {
                    searchCriterias.add("latest:\"" + days + "days\"");
                }
                if (dateFrom != null || dateTo != null) {
                    searchCriterias.add("date:" + dateFrom + "-" + dateTo);
                }

                Collection<String> types = new ArrayList<>();
                if (YES.equals(d64)) {
                    types.add("d64");
                }
                if (YES.equals(t64)) {
                    types.add("t64");
                }
                if (YES.equals(d71)) {
                    types.add("d71");
                }
                if (YES.equals(d81)) {
                    types.add("d81");
                }
                if (YES.equals(prg)) {
                    types.add("prg");
                }
                if (YES.equals(tap)) {
                    types.add("tap");
                }
                if (YES.equals(crt)) {
                    types.add("crt");
                }
                if (YES.equals(sid)) {
                    types.add("sid");
                }
                if (YES.equals(bin)) {
                    types.add("bin");
                }
                if (YES.equals(g64)) {
                    types.add("g64");
                }

                StringBuilder query = new StringBuilder();
                if (!searchCriterias.isEmpty()) {
                    query.append(String.join(" ", searchCriterias));
                }
                if (!types.isEmpty()) {
                    query.append(" type:").append(String.join(",", types));
                }

                if (searchCriterias.isEmpty()) {
                    // avoid it to request everything, it would take too much time!
                    return;
                }
                List<SearchResult> searchResults = objectMapper.readerForListOf(SearchResult.class)
                        .readValue(assembly64Client.search(query.toString(), searchOffset, MAX_ROWS));
                searchResultItems.setAll(searchResults);
                serverStatus.setText("");
                prevButton.setDisable(searchOffset == 0);
                nextButton.setDisable(searchResultItems.size() < MAX_ROWS);

                searchStop = searchOffset + searchResultItems.size();
            } catch (IOException e) {
                serverStatus.setText(util.getBundle().getString("REQUEST_FAILED"));
                System.err.println(e.getMessage());
            }
        } finally {
            Platform.runLater(() -> util.progressProperty(assembly64Table.getScene()).set(0));
        }
    }

    private void getContentEntries(boolean doAutostart) {
        SearchResult selected = assembly64Table.getSelectionModel().getSelectedItem();
        if (searchResult != selected) {
            sequentialTransitionContentEntries.stop();
            contentEntry = null;
            contentEntryFile = null;
            contentEntryItems.clear();
            directory.clear();
        }
        searchResult = selected;
        if (searchResult == null) {
            return;
        }
        autostart.set(doAutostart);
        Platform.runLater(() -> util.progressProperty(assembly64Table.getScene()).set(INDETERMINATE_PROGRESS));
        sequentialTransitionContentEntries.playFromStart();
    }

    private void requestContentEntries() {
        try {
            if (searchResult == null) {
                return;
            }
            directory.clear();
            if (assembly64Client == null) return;
            final String itemId = searchResult.getId();
            final Integer categoryId = searchResult.getCategory().getId();

            ContentEntrySearchResult contentEntry = assembly64Client.entries(itemId, String.valueOf(categoryId));
            contentEntryItems.setAll(contentEntry.getContentEntry().stream()
                    .filter(e -> e.getPath() != null && !e.getPath().startsWith(Convenience.MACOSX))
                    .collect(Collectors.toList()));
            contentEntryTable.getSelectionModel().select(contentEntryItems.stream().findFirst().orElse(null));
            if (autostart.getAndSet(false)) {
                autostart(null);
            }
        } catch (IOException e) {
            serverStatus.setText(util.getBundle().getString("REQUEST_FAILED"));
            System.err.println("Unexpected result: " + e.getMessage());
        } finally {
            Platform.runLater(() -> util.progressProperty(assembly64Table.getScene()).set(0));
        }
    }

    private void getContentEntry(boolean doAutostart) {
        try {
            if (contentEntryTable.getSelectionModel().getSelectedItem() == null
                    || Objects.equals(contentEntryTable.getSelectionModel().getSelectedItem(), this.contentEntry)) {
                return;
            }
            contentEntry = contentEntryTable.getSelectionModel().getSelectedItem();
            contentEntryFile = null;

            contentEntryFile = FileRequestPathServletParametersImpl.fetchAssembly64File(util.getConfig(),
                    serverComboBox.getValue().getId(), searchResult.getId(),
                    String.valueOf(searchResult.getCategory().getId()), contentEntry.getPath());

            directory.loadPreview(contentEntryFile);
        } catch (IOException | URISyntaxException e) {
            System.err.printf("Cannot DOWNLOAD file '%s'.%n", contentEntry.getPath());
            serverStatus.setText(util.getBundle().getString("REQUEST_FAILED"));
            contentEntry = null;
        } finally {
            if (doAutostart) {
                autostart(null);
            }
        }
    }

    private String get(TypeTextField field, boolean dateFromTo) {
        Object value = field.getValue();
        if (value instanceof YearMonth) {
            YearMonth yearMonth = (YearMonth) value;
            value = LocalDate.of(yearMonth.getYear(), yearMonth.getMonthValue(),
                    dateFromTo ? 1 : yearMonth.lengthOfMonth());
        } else if (value instanceof Year) {
            Year year = (Year) value;
            value = LocalDate.of(year.getValue(), dateFromTo ? 1 : 12, dateFromTo ? 1 : 31);
        }
        if (value == null) {
            return null;
        }
        return ((LocalDate) value).format(DateTimeFormatter.ofPattern(DATE_PATTERN));
    }

    private <T, U> U get(ComboBox<T> comboBox, Function<T, U> toResult, Predicate<T> checkEmpty, U emptyValue) {
        T value = comboBox.getValue();
        if (checkEmpty.test(value)) {
            return emptyValue;
        }
        return toResult.apply(value);
    }

    private String get(TextField field) {
        String value = field.getText().trim();
        if (value.isEmpty()) {
            return null;
        }
        return value;
    }

    private String get(CheckBox field) {
        return field.isSelected() ? YES : NO;
    }

    private void autostart(String dirEntry) {
        if (contentEntry != null && contentEntryFile != null) {
            try {
                if (convenience.autostart(contentEntryFile, Convenience.LEXICALLY_FIRST_MEDIA, dirEntry, true)
                        .isSuccess()) {
                    util.setPlayingTab(this, currentlyPlayedSearchResultRowProperty,
                            currentlyPlayedContentEntryRowProperty);
                    currentlyPlayedSearchResultRowProperty.set(searchResult);
                    currentlyPlayedContentEntryRowProperty.set(contentEntry);
                }
            } catch (IOException | SidTuneError e) {
                e.printStackTrace();
                System.err.printf("Cannot AUTOSTART file '%s'.%n", contentEntry.getPath());
            }
        }
    }

    public URI appendURI(URI oldUri, String queryParamValue) throws URISyntaxException {
        String newQuery = "query=" + queryParamValue;
        return new URI(oldUri.getScheme(), oldUri.getAuthority(), oldUri.getPath(), newQuery, oldUri.getFragment());
    }

}