aswi2020vldc-gitlab/src/main/java/vldc/aswi/utils/Converter.java @ 830a7e2e

package vldc.aswi.utils;

import vldc.aswi.model.table.*;
import vldc.aswi.model.table.contingencyTable.ContingencyTableRow;
import vldc.aswi.model.table.contingencyTable.ContingencyTableRowCell;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.concurrent.TimeUnit;

/**
 * Class used to convert original table to contingency table.
 */
public class Converter {

    /**
     * Name of the table
     */
    private final String tableName;

    /**
     * Stores information about whether user set switch to show empty rows and columns to ON.
     */
    private final boolean isNotRemoveEmpty;

    /**
     * Map of original table.
     */
    private final Map<String, TableColumn> tableColumns;

    /**
     * List of names and user names of selected rows.
     */
    private final List<NameUserName> rowNames;

    /**
     * List of names and user names of selected columns.
     */
    private final List<NameUserName> columnNames;

    /**
     * List of information about selected value and functions.
     */
    private final List<ValueFunction> valueFunctions;

    /**
     * List of columns node of contingency table going from left to right.
     */
    private List<Node> columnNodes;

    /**
     * Formatter of the cell content.
     */
    private final DecimalFormat decimalFormat = new DecimalFormat("0.###");

    /**
     * Creates and initializes converter.
     * @param tableColumns Map of original table.
     * @param rowNames List of names and user names of selected rows.
     * @param columnNames List of names and user names of selected columns.
     * @param valueFunctions List of information about selected value and functions.
     * @param isNotRemoveEmpty Stores information about whether user set switch to show empty rows and columns to ON.
     * @param tableName Name of the table.
     */
    public Converter(Map<String, TableColumn> tableColumns, List<NameUserName> rowNames, List<NameUserName> columnNames,
                     List<ValueFunction> valueFunctions, boolean isNotRemoveEmpty, String tableName) {
        this.tableColumns = tableColumns;
        this.rowNames = rowNames;
        this.columnNames = columnNames;
        this.valueFunctions = valueFunctions;
        this.isNotRemoveEmpty = isNotRemoveEmpty;
        this.tableName = tableName;
    }

    /**
     * Convert Map of TableColumns into list of ContingencyTableRow.
     * @return List of ContingencyTableRow.
     */
    public List<ContingencyTableRow> convertTableColumnsToContingencyTableRows() {
        long startTime = System.nanoTime();

        long startTime1 = System.nanoTime();
        columnNodes = new ArrayList<>();
        List<List<String>> values = new ArrayList<>();
        for(NameUserName nameUserName : columnNames) {
            TableColumn column = tableColumns.get(nameUserName.getName());
            values.add(getOriginalValuesFromList(column.getValues()));
        }

        Node startNode = new Node();
        generateColumns(0, values, columnNodes, startNode);

        long stopTime1 = System.nanoTime();
        System.out.println("Colums list:" + TimeUnit.MILLISECONDS.convert((stopTime1 - startTime1), TimeUnit.NANOSECONDS));

        List<ContingencyTableRow> contingencyTableRows = new ArrayList<>();

        long startTime2 = System.nanoTime();
        List<ContingencyTableRow> dataRows = createDataRows();
        long stopTime2 = System.nanoTime();
        System.out.println("Rows:" + TimeUnit.MILLISECONDS.convert((stopTime2 - startTime2), TimeUnit.NANOSECONDS));

        if (isNotRemoveEmpty) {
            long startTime3 = System.nanoTime();
            for (ContingencyTableRow dataRow : dataRows) {
                for (int i = 0; i < columnNodes.size(); i++) {
                    if (!columnNodes.get(i).isUsable()) {
                        dataRow.getCells().remove(i + 1);
                    }
                }
            }

            columnNodes.removeIf(node -> !node.isUsable());
            long stopTime3 = System.nanoTime();
            System.out.println("Columns remove:" + TimeUnit.MILLISECONDS.convert((stopTime3 - startTime3), TimeUnit.NANOSECONDS));
        }

        long startTime4 = System.nanoTime();
        List<ContingencyTableRow> headerRows = createHeaderOnlyRows();
        long stopTime4 = System.nanoTime();
        System.out.println("Headers:" + TimeUnit.MILLISECONDS.convert((stopTime4 - startTime4), TimeUnit.NANOSECONDS));

        contingencyTableRows.addAll(headerRows);
        contingencyTableRows.addAll(dataRows);

        long stopTime = System.nanoTime();
        System.out.println("Converter:" + TimeUnit.SECONDS.convert((stopTime - startTime), TimeUnit.NANOSECONDS) + "s");

        return contingencyTableRows;
    }

    /**
     * Generates header rows.
     * @return list of contingency table rows
     */
    private List<ContingencyTableRow> createHeaderOnlyRows() {
        List<ContingencyTableRow> headerRows = new ArrayList<>();

        headerRows.add(new ContingencyTableRow(true, 0));

        for (int i = 0; i < columnNames.size(); i++) {
            headerRows.add(new ContingencyTableRow(true, 0));
        }

        if (valueFunctions.get(0).getFunction() != null && valueFunctions.get(0).getFunction().equals("NIC") &&
                columnNames.size() == 0) {
            headerRows.get(0).addTableRowCell(new ContingencyTableRowCell("Seznam", 1));

            return headerRows;
        }

        for (int i = 0; i < headerRows.size(); i++) {
            ContingencyTableRow headerRow = headerRows.get(i);

            if (i == 0) {
                headerRow.addTableRowCell(new ContingencyTableRowCell(tableName, 1));
            }
            else {
                headerRow.addTableRowCell(new ContingencyTableRowCell("", 1));
            }
        }

        List<String> prevValues = new ArrayList<>(); // values that were visited
        int prevSize = 0; // number of previous column node values
        for (ValueFunction valueFunction : valueFunctions) { // for each function
            // add cell with the function name and value name to the 0th row with span 0
            headerRows.get(0).addTableRowCell(new ContingencyTableRowCell(valueFunction.getFunction() + " z " + valueFunction.getParameterName(), 0));
            for (Node columnNode : columnNodes) { // for each column
                for (int i = 0; i < columnNode.getValues().size(); i++) { // for each value in column
                    String value = columnNode.getValues().get(i);
                    // check if value is not in the visited list, if list size equals i, the value is not visited
                    // eg. i = 0 -> no values in the list, if list size is bigger than i, there are more values than i
                    // so then check if value at ith position is not equal to the current value (is not visited)
                    if (prevValues.size() == i || (prevValues.size() > i && !prevValues.get(i).equals(value))) {
                        prevValues.add(value);
                        // add cell with value with span 0 to the i + 1th row (0th is for function name and value name cells)
                        headerRows.get(i + 1).addTableRowCell(new ContingencyTableRowCell(columnNames.get(i).getUserName() + " - " + value, 1));
                        // add 1 to the span of the last added function and value name cell
                        headerRows.get(0).getCells().get(headerRows.get(0).getCells().size() - 1).setColSpan(headerRows.get(0).getCells().get(headerRows.get(0).getCells().size() - 1).getColSpan() + 1);
                    } else if (columnNode.getValues().size() >= prevSize) {
                        // add 1 to the span of the last added cell of the row of i + 1th value
                        headerRows.get(i + 1).getCells().get(headerRows.get(i + 1).getCells().size() - 1).setColSpan(headerRows.get(i + 1).getCells().get(headerRows.get(i + 1).getCells().size() - 1).getColSpan() + 1);
                    }
                }

                if (columnNode.getValues().size() < prevSize) { // if there are less values than in previous column node
                    for (int s = prevSize; s < headerRows.size(); s++) {
                        // add blank cell to the rows bellow
                        headerRows.get(s).addTableRowCell(new ContingencyTableRowCell("", 1));
                    }
                    for (int s = 1; s < columnNode.getValues().size(); s++) {
                        // add 1 to colspan to the cells above
                        headerRows.get(s).getCells().get(headerRows.get(s).getCells().size() - 1).setColSpan(headerRows.get(s).getCells().get(headerRows.get(s).getCells().size() - 1).getColSpan() + 1);
                    }
                    // create cell for total values (not for lists of the tree)
                    headerRows.get(columnNode.getValues().size()).addTableRowCell(new ContingencyTableRowCell(columnNode.getValues().get(columnNode.getValues().size() - 1) + " Celkem", 1));
                }

                prevSize = columnNode.getValues().size();

                if (!prevValues.isEmpty()) {
                    prevValues.remove(prevValues.size() - 1); // remove last value
                }
            }
        }

        for (ValueFunction valueFunction : valueFunctions) {
            for (int i = 1; i < headerRows.size(); i++) {
                headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("", 1));
            }
            headerRows.get(0).addTableRowCell(new ContingencyTableRowCell("Celkový " + valueFunction.getFunction() +
                    " z " + valueFunction.getParameterName(), 1));
        }

        return headerRows;
    }

    /**
     * Gets original values of a given list.
     * @param list List from which original values should be taken.
     * @return List of original values.
     */
    private List<String> getOriginalValuesFromList(List<String> list) {
        List<String> origList = new ArrayList<>();

        for (String string : list) {
            if (origList.stream().noneMatch(s -> s.equals(string))) {
                origList.add(string);
            }
        }

        return origList;
    }

    /**
     * Creates data rows.
     * @return List of contingency table rows.
     */
    private List<ContingencyTableRow> createDataRows() {
        List<ContingencyTableRow> dataRows = new ArrayList<>();
        List<Node> rowNodes = new ArrayList<>();
        List<List<String>> values = new ArrayList<>();
        for(NameUserName nameUserName : rowNames) {
            TableColumn column = tableColumns.get(nameUserName.getName());
            values.add(getOriginalValuesFromList(column.getValues()));
        }

        long startTime = System.nanoTime();
        Node node = new Node();
        generateRows(dataRows, 0, values, rowNodes, node);
        long stopTime = System.nanoTime();
        System.out.println("Rows List:" + TimeUnit.MILLISECONDS.convert((stopTime - startTime), TimeUnit.NANOSECONDS));

        // loop through all generated rows and store unusable rows to the list rowsToBeRemoved
        List<ContingencyTableRow> rowsToBeRemoved = new ArrayList<>();
        for (int i = 0; i < dataRows.size(); i++) {
            if (!fillRowWithData(dataRows.get(i), rowNodes.get(i))) {
                rowsToBeRemoved.add(dataRows.get(i));
            }
        }

        // remove unusable rows
        dataRows.removeAll(rowsToBeRemoved);

        // create final row (row with total values of each column)
        if (valueFunctions.get(0).getFunction() != null && (!valueFunctions.get(0).getFunction().equals("NIC") ||
                (valueFunctions.get(0).getFunction().equals("NIC") && columnNames.size() > 0))) {
            dataRows.add(createFinalRow());
        }

        return dataRows;
    }

    /**
     * Recursively generates all possible row combinations, sorted as in contingency table.
     * @param rows List of sorted contingency table rows.
     * @param index Index in the values list.
     * @param values List of lists of values of each query row.
     * @param rowNodes List of row nodes.
     * @param prevNode Parent node of the nodes.
     */
    private void generateRows(List<ContingencyTableRow> rows, int index, List<List<String>> values, List<Node> rowNodes,
                              Node prevNode) {
        if (index < values.size()) {
            List<String> list = values.get(index);
            for (String s : list) {
                StringBuilder levelString = new StringBuilder();
                // add indent if row value has index higher than 0
                for (int i = 0; i < index; i++) {
                    levelString.append("      ");
                }
                levelString.append(rowNames.get(index).getUserName()).append(" - ").append(s);
                ContingencyTableRow row = new ContingencyTableRow(false, index);
                row.addTableRowCell(new ContingencyTableRowCell(levelString.toString(), 1));
                rows.add(row);
                Node node = new Node(prevNode);
                // save a value from a chosen row
                node.getValues().add(s);
                // visit (save) root
                rowNodes.add(node);
                int newIndex = index + 1;
                // visit sub tree
                generateRows(rows, newIndex, values, rowNodes, node);
            }
        }
    }

    /**
     * Recursively generates all possible column combinations, sorted as in contingency table.
     * @param index Index in the values list.
     * @param values List of lists of values of each query row.
     * @param columnNodes List of column nodes.
     * @param prevNode Parent node of the nodes.
     */
    private void generateColumns(int index, List<List<String>> values, List<Node> columnNodes, Node prevNode) {
        if (index < values.size()) {
            List<String> list = values.get(index);
            for (String s : list) {
                Node node = new Node(prevNode);
                // save a value from a chosen column
                node.getValues().add(s);
                if (isNotRemoveEmpty) {
                    int newIndex = index + 1;
                    // first visit all subtrees
                    generateColumns(newIndex, values, columnNodes, node);
                    // visit (save) root
                    columnNodes.add(node);
                }
                else if (checkIfColumnIsUsable(node.getValues())) {
                    int newIndex = index + 1;
                    // first visit all subtrees
                    generateColumns(newIndex, values, columnNodes, node);
                    // visit (save) root
                    columnNodes.add(node);
                }
            }
        }
    }

    /**
     * Fills each data row with data.
     * @param row Row to be filled with data.
     * @param rowNode Node of the row.
     */
    private boolean fillRowWithData(ContingencyTableRow row, Node rowNode) {
        if (valueFunctions.size() == 0) {
            return true;
        }

        boolean isSingleValueRow = false;

        // check if row is a root (single) value
        if (rowNode.getValues().size() <= 1) {
            isSingleValueRow = true;
        }

        // stores if row is usable
        boolean isRowUsable = false;

        // if user selected an option to show all rows and columns, set that row is always usable
        if (isNotRemoveEmpty) {
            isRowUsable = true;
        }

        // if no columns or functions were selected
        if (columnNodes.size() == 0) {
            columnNodes.add(new Node());
        }

        // load the list of usable original row IDs
        List<Integer> usableIDs = getUsableIDs(rowNode.getValues());

        if (valueFunctions.get(0).getFunction() != null && valueFunctions.get(0).getFunction().equals("NIC") &&
                !usableIDs.isEmpty()) { // return that row is usable because it is used for list generation
            return true;
        }
        else if (valueFunctions.get(0).getFunction() != null && valueFunctions.get(0).getFunction().equals("NIC") &&
                usableIDs.isEmpty()) { // no function selected and no usable rows in original return if row is usable
            return isRowUsable;
        }

        // array of total values for functions
        DoubleWrapper[] totals = new DoubleWrapper[valueFunctions.size()];
        initializeDoubleWrapperField(totals);

        // array of total sum values for functions if functions are AVG
        DoubleWrapper[] totalsAvgSum = new DoubleWrapper[valueFunctions.size()];
        initializeDoubleWrapperField(totalsAvgSum);

        // array that stores if total value cell will be filled or left blank for current row and each function
        boolean[] isFilledValueCells = new boolean[valueFunctions.size()];
        // for each function
        for (int v = 0; v < valueFunctions.size(); v++) {
            // if function has not been selected
            if (valueFunctions.get(v).getFunction() != null && (valueFunctions.get(v).getFunction().equals("") ||
                    valueFunctions.get(v).getFunction().equals("NIC"))) {
                isRowUsable = true;
                break;
            }

            // stores if first MIN or MAX total value was saved for current function
            BooleanWrapper isFirstMinMaxTotal = new BooleanWrapper(true);

            ValueFunction valueFunction = valueFunctions.get(v);
            // for each contingency table column
            for (Node columnNode : columnNodes) {
                // result that will be stored in a cell given by row and column rowNode
                DoubleWrapper result = new DoubleWrapper(0);
                // sum result used to calculate AVG result in a cell given by row and column rowNode
                DoubleWrapper resultAvgSum = new DoubleWrapper(0);
                // stores if first MIN or MAX value was saved for current cell
                BooleanWrapper isFirstMinMax = new BooleanWrapper(true);
                // stores if a cell will be filled or left blank
                boolean isFilledCell = false;
                // for each usable row
                for (Integer usableID : usableIDs) {
                    boolean isUsable = true;
                    // index of selected row
                    int j;
                    // check if values of the contingency table column rowNode are present in the row (at usableID position
                    // of original table) for columns that belong to column rowNode
                    for (j = 0; j < columnNode.getValues().size(); j++) {
                        if (!tableColumns.get(columnNames.get(j).getName()).getValues().get(usableID).equals(columnNode.getValues().get(j))) {
                            isUsable = false;
                            break;
                        }
                    }

                    // selected column from value
                    if (tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID) == null) {
                        isUsable = false;
                    }

                    // if value is usable, "intersect" of values from contingency table row and column, and value is true
                    if (isUsable) {
                        columnNode.setUsable(true);
                        isRowUsable = true;
                        isFilledCell = true;
                        computeValues(valueFunction, result, resultAvgSum, columnNode, isFirstMinMax,
                                usableID, false, isSingleValueRow);
                        // row is a root (single) value, save the result to the total function value cell
                        if (j <= 1) {
                            isFilledValueCells[v] = true;
                            computeValues(valueFunction, totals[v], totalsAvgSum[v], null, isFirstMinMaxTotal,
                                    usableID, true, isSingleValueRow);
                        }
                    }
                }
                // if cell should be blank, add empty value
                if (!isFilledCell) {
                    row.addTableRowCell(new ContingencyTableRowCell("", 0));
                }
                else { // generate a cell with a value
                    columnNode.setFilledTotalValue(true);
                    row.addTableRowCell(generateFilledCell(valueFunction.getFunction(), result.getValue(), result.getValue(), result.getValue(),
                            result.getValue(), resultAvgSum.getValue(), result.getValue()));
                }
            }
        }
        // generate cell for total function values
        for (int i = 0; i < valueFunctions.size(); i++) {
            if (valueFunctions.get(i).getFunction() != null && valueFunctions.get(i).getFunction().equals("NIC")) {
                break;
            }
            // if cell should be blank, add empty value
            if (!isFilledValueCells[i]) {
                row.addTableRowCell(new ContingencyTableRowCell("", 0));
            }
            else { // generate a cell with a value
                valueFunctions.get(i).setFilledTotalValue(true);
                row.addTableRowCell(generateFilledCell(valueFunctions.get(i).getFunction(), totals[i].getValue(), totals[i].getValue(),
                        totals[i].getValue(), totals[i].getValue(), totalsAvgSum[i].getValue(), totals[i].getValue()));
            }
        }

        // returns if row should be visible in the contingency table
        return isRowUsable;
    }

    /**
     * Gets a list of IDs of the query rows that fit the contingency table row settings.
     * @param rowNodeValues Values of a row node.
     * @return List of usable row IDs.
     */
    private List<Integer> getUsableIDs(List<String> rowNodeValues) {
        List<Integer> ids = new ArrayList<>();

        // for each row in original table
        for (int i = 0; i < tableColumns.get(rowNames.get(0).getName()).getValues().size(); i++) {
            boolean isUsable = true;
            // check if a row has values that are stored in the row node (for each chosen row)
            for (int j = 0; j < rowNodeValues.size(); j++) {
                if (!tableColumns.get(rowNames.get(j).getName()).getValues().get(i).equals(rowNodeValues.get(j))) {
                    isUsable = false;
                    break;
                }
            }
            if (isUsable) {
                ids.add(i);
            }
        }

        return ids;
    }

    /**
     * Checks if column is usable by going through all values of columns of a node in the original table.
     * @param columnNodeValues Values of a column node.
     * @return True if all values of a node are present in the original table columns.
     */
    private boolean checkIfColumnIsUsable(List<String> columnNodeValues) {
        // for each row in original table
        for (int i = 0; i < tableColumns.get(columnNames.get(0).getName()).getValues().size(); i++) {
            boolean isUsable = true;
            // check if a row has values that are stored in the column node (for each chosen column)
            for (int j = 0; j < columnNodeValues.size(); j++) {
                if (!tableColumns.get(columnNames.get(j).getName()).getValues().get(i).equals(columnNodeValues.get(j))) {
                    isUsable = false;
                    break;
                }
            }

            if (isUsable) {
                return true;
            }
        }

        return false;
    }

    /**
     * Computes value of the cell in regards to function.
     * @param valueFunction Column from which value should be taken and a function used and other info.
     * @param result Variable to which result is saved.
     * @param resultAvgSum Variable to which sum is saved of a function is AVG.
     * @param columnNode Column node of a cell.
     * @param isFirstMinMax Tells if the counted value is the first value of the MIN or MAX function.
     * @param usableID ID of the row in the original table.
     * @param isValueTotal Tells if a value is total value for the given function.
     * @param isSingleValueRow Tells whether a row only has single value (only represents one column of the original table).
     */
    private void computeValues(ValueFunction valueFunction, DoubleWrapper result, DoubleWrapper resultAvgSum, Node columnNode,
                               BooleanWrapper isFirstMinMax, int usableID, boolean isValueTotal, boolean isSingleValueRow) {
        switch (valueFunction.getFunction()) {
            case "COUNT":
                count(valueFunction, result, columnNode, isValueTotal, isSingleValueRow);
                break;
            case "SUM":
                sum(valueFunction, result, columnNode, usableID, isValueTotal, isSingleValueRow);
                break;
            case "MIN":
                min(valueFunction, result, columnNode, isFirstMinMax, usableID, isValueTotal, isSingleValueRow);
                break;
            case "MAX":
                max(valueFunction, result, columnNode, isFirstMinMax, usableID, isValueTotal, isSingleValueRow);
                break;
            case "AVG":
                average(valueFunction, result, resultAvgSum, columnNode, usableID, isValueTotal, isSingleValueRow);
                break;
        }
    }

    /**
     * Generates a cell with filled data.
     * @param function Name of the function.
     * @param totalResult Result of COUNT function to be saved.
     * @param totalResultSum Result of SUM function to be saved.
     * @param totalMin Result of MIN function to be saved.
     * @param totalMax Result of MAX function to be saved.
     * @param totalResultAvgSum Result of sum of AVG function to be saved.
     * @param totalResultAvg Result of count of AVG function to be saved.
     * @return Generated and filled cell.
     */
    private ContingencyTableRowCell generateFilledCell(String function, double totalResult, double totalResultSum,
                                                       double totalMin, double totalMax, double totalResultAvgSum,
                                                       double totalResultAvg) {
        ContingencyTableRowCell cell = null;
        switch (function) {
            case "COUNT":
                cell = new ContingencyTableRowCell(decimalFormat.format(totalResult), 1);
                break;
            case "SUM":
                cell = new ContingencyTableRowCell(decimalFormat.format(totalResultSum), 1);
                break;
            case "MIN":
                cell = new ContingencyTableRowCell(decimalFormat.format(totalMin), 1);
                break;
            case "MAX":
                cell = new ContingencyTableRowCell(decimalFormat.format(totalMax), 1);
                break;
            case "AVG":
                if (totalResultAvg == 0) {
                    cell = new ContingencyTableRowCell("!!Dělení nulou!!", 0);
                } else {
                    cell = new ContingencyTableRowCell(decimalFormat.format(totalResultAvgSum / totalResultAvg), 0);
                }
                break;
        }

        return cell;
    }

    /**
     * Initializes a filled of the values of a DoubleWrapper type.
     * @param field Field to be initialized.
     */
    private void initializeDoubleWrapperField(DoubleWrapper[] field) {
        for (int i = 0; i < field.length; i++) {
            field[i] = new DoubleWrapper(0);
        }
    }

    /**
     * Calculates COUNT function.
     * @param valueFunction Column from which value should be taken and other info.
     * @param result Variable to which result is saved.
     * @param columnNode Column node of a cell.
     * @param isValueTotal Tells if a value is total value for the given function.
     * @param isSingleValueRow Tells whether a row only has single value (only represents one column of the original table).
     */
    private void count(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, boolean isValueTotal,
                       boolean isSingleValueRow) {
        result.setValue(result.getValue() + 1);
        if (columnNode != null && isSingleValueRow) {
            columnNode.setTotalResult(columnNode.getTotalResult() + 1);
        }
        if (isValueTotal && isSingleValueRow) {
            valueFunction.setTotalResult(valueFunction.getTotalResult() + 1);
        }
    }

    /**
     * Calculates SUM function.
     * @param valueFunction Column from which value should be taken and other info.
     * @param result Variable to which result is saved.
     * @param columnNode Column node of a cell.
     * @param usableID ID of the row in the original table.
     * @param isValueTotal Tells if a value is total value for the given function.
     * @param isSingleValueRow Tells whether a row only has single value (only represents one column of the original table).
     */
    private void sum(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, int usableID, boolean isValueTotal,
                     boolean isSingleValueRow) {
        if (valueFunction.getType().equals("Číslo")) {
            double res = getDoubleValueFromTableCell(valueFunction, usableID);
            result.setValue(result.getValue() + res);
            if (columnNode != null && isSingleValueRow) {
                columnNode.setTotalResultSum(columnNode.getTotalResultSum() + res);
            }
            if (isValueTotal && isSingleValueRow) {
                valueFunction.setTotalResultSum(valueFunction.getTotalResultSum() + res);
            }
        }
    }

    /**
     * Calculates MIN function.
     * @param valueFunction Column from which value should be taken and other info.
     * @param result Variable to which result is saved.
     * @param columnNode Column node of a cell.
     * @param isFirstMinMax Tells if the counted value is the first value of the MIN or MAX function.
     * @param usableID ID of the row in the original table.
     * @param isValueTotal Tells if a value is total value for the given function.
     * @param isSingleValueRow Tells whether a row only has single value (only represents one column of the original table).
     */
    private void min(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, BooleanWrapper isFirstMinMax,
                     int usableID, boolean isValueTotal, boolean isSingleValueRow) {
        if (valueFunction.getType().equals("Číslo")) {
            double res = getDoubleValueFromTableCell(valueFunction, usableID);
            // if min value of the cell has not been stored yet
            if (isFirstMinMax.isValue()) {
                isFirstMinMax.setValue(false);
                result.setValue(res);
            }
            else {
                result.setValue(Math.min(result.getValue(), res));
            }
            if (columnNode != null && isSingleValueRow) {
                // if min value of the entire column has not been stored yet
                if (columnNode.isFirstMin()) {
                    columnNode.setFirstMin(false);
                    columnNode.setTotalMin(res);
                } else {
                    columnNode.setTotalMin(Math.min(columnNode.getTotalMin(), res));
                }
            }
            if (isValueTotal && isSingleValueRow) {
                // if min value of the entire value column has not been stored yet
                if (valueFunction.isFirstMin()) {
                    valueFunction.setFirstMin(false);
                    valueFunction.setTotalMin(res);
                } else {
                    valueFunction.setTotalMin(Math.min(valueFunction.getTotalMin(), res));
                }
            }
        }
    }

    /**
     * Calculates MAX function.
     * @param valueFunction Column from which value should be taken and other info.
     * @param result Variable to which result is saved.
     * @param columnNode Column node of a cell.
     * @param isFirstMinMax Tells if the counted value is the first value of the MIN or MAX function.
     * @param usableID ID of the row in the original table.
     * @param isValueTotal Tells if a value is total value for the given function.
     * @param isSingleValueRow Tells whether a row only has single value (only represents one column of the original table).
     */
    private void max(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, BooleanWrapper isFirstMinMax,
                     int usableID, boolean isValueTotal, boolean isSingleValueRow) {
        if (valueFunction.getType().equals("Číslo")) {
            double res = getDoubleValueFromTableCell(valueFunction, usableID);
            if (isFirstMinMax.isValue()) {
                // if max value of the cell has not been stored yet
                isFirstMinMax.setValue(false);
                result.setValue(res);
            }
            else {
                result.setValue(Math.max(result.getValue(), res));
            }
            if (columnNode != null && isSingleValueRow) {
                // if max value of the entire column has not been stored yet
                if (columnNode.isFirstMax()) {
                    columnNode.setFirstMax(false);
                    columnNode.setTotalMax(res);
                } else {
                    columnNode.setTotalMax(Math.max(columnNode.getTotalMax(), res));
                }
            }
            if (isValueTotal && isSingleValueRow) {
                // if max value of the entire value column has not been stored yet
                if (valueFunction.isFirstMax()) {
                    valueFunction.setFirstMax(false);
                    valueFunction.setTotalMax(res);
                } else {
                    valueFunction.setTotalMax(Math.max(valueFunction.getTotalMax(), res));
                }
            }
        }
    }

    /**
     * Calculates AVG function.
     * @param valueFunction Column from which value should be taken and other info.
     * @param result Variable to which count result is saved.
     * @param resultAvgSum Variable to which sum result is saved.
     * @param columnNode Column node of a cell.
     * @param usableID ID of the row in the original table.
     * @param isValueTotal Tells if a value is total value for the given function.
     * @param isSingleValueRow Tells whether a row only has single value (only represents one column of the original table).
     */
    private void average(ValueFunction valueFunction, DoubleWrapper result, DoubleWrapper resultAvgSum, Node columnNode,
                         int usableID, boolean isValueTotal, boolean isSingleValueRow) {
        if (valueFunction.getType().equals("Číslo")) {
            double res = getDoubleValueFromTableCell(valueFunction, usableID);
            result.setValue(result.getValue() + 1);
            resultAvgSum.setValue(resultAvgSum.getValue() + res);
            if (columnNode != null && isSingleValueRow) {
                columnNode.setTotalResultAvg(columnNode.getTotalResultAvg() + 1);
                columnNode.setTotalResultAvgSum(columnNode.getTotalResultAvgSum() + res);
            }
            if (isValueTotal && isSingleValueRow) {
                valueFunction.setTotalResultAvg(valueFunction.getTotalResultAvg() + 1);
                valueFunction.setTotalResultAvgSum(valueFunction.getTotalResultAvgSum() + res);
            }
        }
    }

    /**
     * Gets double value from a cell in a value column and usableID row in an original table
     * @param valueFunction Column from which value should be taken and other info.
     * @param usableID ID of the row in the original table.
     * @return Parsed double value.
     */
    private double getDoubleValueFromTableCell(ValueFunction valueFunction, int usableID) {
        double res;
        try {
            res = Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID));
        }
        catch (Exception e) {
            res = Double.NaN;
        }

        return res;
    }

    /**
     * Generates a final row, with total values of columns.
     * @return Final row filled with data.
     */
    private ContingencyTableRow createFinalRow() {
        ContingencyTableRow finalRow = new ContingencyTableRow(false, 0);
        finalRow.addTableRowCell(new ContingencyTableRowCell("Celkem", 1));

        if (valueFunctions.get(0).getFunction() != null && valueFunctions.get(0).getFunction().equals("NIC")) {
            return finalRow;
        }

        List<ContingencyTableRowCell> valueCells = new ArrayList<>();
        // for each selected function
        for (ValueFunction valueFunction : valueFunctions) {
            //for each column
            for (Node columnNode : columnNodes) {
                if (columnNode.isFilledTotalValue()) {
                    finalRow.addTableRowCell(generateFilledCell(valueFunction.getFunction(), columnNode.getTotalResult(), columnNode.getTotalResultSum(),
                            columnNode.getTotalMin(), columnNode.getTotalMax(), columnNode.getTotalResultAvgSum(),
                            columnNode.getTotalResultAvg()));
                }
                else {
                    finalRow.addTableRowCell(new ContingencyTableRowCell("", 0));
                }
            }
            if (valueFunction.isFilledTotalValue()) {
                valueCells.add(generateFilledCell(valueFunction.getFunction(), valueFunction.getTotalResult(), valueFunction.getTotalResultSum(),
                        valueFunction.getTotalMin(), valueFunction.getTotalMax(), valueFunction.getTotalResultAvgSum(),
                        valueFunction.getTotalResultAvg()));
            }
            else {
                valueCells.add(new ContingencyTableRowCell("", 0));
            }
        }

        // append value cells to the end
        finalRow.addTableRowCells(valueCells);

        return finalRow;
    }
}