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

package vldc.aswi.utils;

import vldc.aswi.model.table.NameUserName;
import vldc.aswi.model.table.Node;
import vldc.aswi.model.table.TableColumn;
import vldc.aswi.model.table.ValueFunction;
import vldc.aswi.model.table.contingencyTable.ContingencyTableRow;
import vldc.aswi.model.table.contingencyTable.ContingencyTableRowCell;

import javax.persistence.criteria.CriteriaBuilder;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * Class for converting classes.
 */
public class Converter {

    private List<Node> rowNodes;
    private List<Node> columnNodes;

    /**
     * Convert Map of TableColumns into list of ContingencyTableRow.
     * @param tableColumns - Map of TableColumn.
     * @return List of ContingencyTableRow.
     */
    public List<ContingencyTableRow> convertTableColumnsToContingencyTableRows(Map<String, TableColumn> tableColumns,
                                                                                      List<NameUserName> rowNames,
                                                                                      List<NameUserName> columnNames,
                                                                               List<ValueFunction> valueFunctions) {
        long startTime = System.nanoTime();
        List<ContingencyTableRow> contingencyTableRows = new ArrayList<>();

        long startTime2 = System.nanoTime();
        List<ContingencyTableRow> headerRows = createHeaderOnlyRows(tableColumns, columnNames, valueFunctions);
        long stopTime2 = System.nanoTime();
        System.out.println("Headers:" + TimeUnit.MILLISECONDS.convert((stopTime2 - startTime2), TimeUnit.NANOSECONDS));

        long startTime3 = System.nanoTime();
        List<ContingencyTableRow> dataRows = createDataRows(tableColumns, columnNames, rowNames, valueFunctions);
        long stopTime3 = System.nanoTime();
        System.out.println("Rows:" + TimeUnit.MILLISECONDS.convert((stopTime3 - startTime3), 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.
     * @param tableColumns Map of TableColumn
     * @param columnNames list of column and user column names
     * @param valueFunctions list of values and their functions
     * @return list of contingency table rows
     */
    private List<ContingencyTableRow> createHeaderOnlyRows(Map<String, TableColumn> tableColumns,
                                                           List<NameUserName> columnNames, List<ValueFunction> valueFunctions) {
        List<List<String>> values = new ArrayList<>();
        columnNodes = new ArrayList<>();
        List<ContingencyTableRow> headerRows = new ArrayList<>();

        List<String> valueOptions = new ArrayList<>();
        for (ValueFunction valueFunction : valueFunctions) {
            valueOptions.add(valueFunction.getFunction() + " z " + valueFunction.getValue());
        }
        values.add(valueOptions);
        headerRows.add(new ContingencyTableRow(true, 0));

        for(NameUserName nameUserName : columnNames) {
            TableColumn column = tableColumns.get(nameUserName.getName());
            values.add(getOriginalValuesFromList(column.getValues()));
            headerRows.add(new ContingencyTableRow(true, 0));
        }

        for (int i = 0; i < values.size(); i++) {
            int colSpan = 1;
            for (int j = values.size() - 1; j > i; j--) {
                if (values.size() - 1 == j) {
                    colSpan = values.get(j).size();
                }
                else {
                    colSpan = (colSpan + 1) * values.get(j).size();
                }
            }
            int loopCount = 1;
            for (int k = 0; k < i; k++) {
                loopCount = loopCount * values.get(k).size();
            }
            headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("", 1));
            for (int k = 0; k < loopCount; k++) {
                for (String value : values.get(i)) {
                    headerRows.get(i).addTableRowCell(new ContingencyTableRowCell(value, colSpan));
                    if (i != values.size() - 1 && i != 0) {
                        headerRows.get(i).addTableRowCell(new ContingencyTableRowCell(value + " Celkem", 1));
                    }
                }

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

        long startTime = System.nanoTime();
        values.remove(0);
        Node node = new Node();
        generateColumns(0, values, columnNodes, node);
        long stopTime = System.nanoTime();
        System.out.println("Colums list:" + TimeUnit.MILLISECONDS.convert((stopTime - startTime), TimeUnit.NANOSECONDS));

        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.
     * @param tableColumns Map of TableColumn
     * @param columnNames list of column and user column names
     * @param rowNames list of row and user row names
     * @param valueFunctions list of values and their functions
     * @return list of contingency table rows
     */
    private List<ContingencyTableRow> createDataRows(Map<String, TableColumn> tableColumns, List<NameUserName> columnNames,
                                                     List<NameUserName> rowNames, List<ValueFunction> valueFunctions) {
        List<ContingencyTableRow> dataRows = new ArrayList<>();
        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));

        for (int i = 0; i < dataRows.size(); i++) {
            fillRowWithData(dataRows.get(i), tableColumns, rowNodes.get(i), rowNames, columnNames, valueFunctions);
        }

        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();
                for (int i = 0; i < index; i++) {
                    levelString.append("----");
                }
                levelString.append(s);
                ContingencyTableRow row = new ContingencyTableRow(false, index);
                row.addTableRowCell(new ContingencyTableRowCell(levelString.toString(), 1));
                rows.add(row);
                Node node = new Node(prevNode);
                node.getValues().add(s);
                rowNodes.add(node);
                int newIndex = index + 1;
                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);
                node.getValues().add(s);
                int newIndex = index + 1;
                generateColumns(newIndex, values, columnNodes, node);
                columnNodes.add(node);
            }
        }
    }

    /**
     * Fills each data row with data.
     * @param row row to ne filled with data
     * @param tableColumns Map of TableColumn
     * @param node node of the row
     * @param rowNames list of row names and user names
     * @param columnNames list of column names and user names
     * @param valueFunctions list of values and their functions
     */
    private void fillRowWithData(ContingencyTableRow row, Map<String, TableColumn> tableColumns, Node node,
                                 List<NameUserName> rowNames, List<NameUserName> columnNames, List<ValueFunction> valueFunctions) {
        if (columnNodes.size() == 0) {
            columnNodes.add(new Node());
        }

        List<Integer> usableIDs = getUsableIDs(tableColumns, node, rowNames);

        int[] totals = new int[valueFunctions.size()];
        //hodnota
        for (int v = 0; v < valueFunctions.size(); v++) {
            ValueFunction valueFunction = valueFunctions.get(v);
            //sloupec v kont. tabulce
            for (Node columnNode : columnNodes) {
                int result = 0;
                // radek v orig. tabulce
                for (Integer usableID : usableIDs) {
                    boolean isUsable = true;
                    int j;
                    // zvoleny sloupec ze sloupcu
                    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;
                        }
                    }
                    // zvoleny sloupec z hodnot
                    if (tableColumns.get(valueFunction.getValue()).getValues().get(usableID) == null) {
                        isUsable = false;
                    }

                    if (isUsable) {
                        if (valueFunction.getFunction().equals("COUNT")) {
                            result++;
                        } else if (valueFunction.getFunction().equals("SUM")) {
                            result += Integer.parseInt(tableColumns.get(valueFunction.getValue()).getValues().get(usableID));
                        }
                        if (j - 1 == 0 || j == 0) {
                            if (valueFunction.getFunction().equals("COUNT")) {
                                totals[v]++;
                            } else if (valueFunction.getFunction().equals("SUM")) {
                                totals[v] += Integer.parseInt(tableColumns.get(valueFunction.getValue()).getValues().get(usableID));
                            }
                        }
                    }
                }
                row.addTableRowCell(new ContingencyTableRowCell(Integer.toString(result), 0));
            }
        }
        for (int total : totals) {
            row.addTableRowCell(new ContingencyTableRowCell(Integer.toString(total), 0));
        }
    }

    /**
     * Gets a list of IDs of the query rows that fit the contingency table row settings.
     * @param tableColumns Map of TableColumn
     * @param node node of the row
     * @param rowNames list of row names and user names
     * @return list of usable IDs
     */
    private List<Integer> getUsableIDs(Map<String, TableColumn> tableColumns, Node node, List<NameUserName> rowNames) {
        List<Integer> ids = new ArrayList<>();

        for (int i = 0; i < tableColumns.get(rowNames.get(0).getName()).getValues().size(); i++) {
            for (int j = 0; j < node.getValues().size(); j++) {
                if (tableColumns.get(rowNames.get(j).getName()).getValues().get(i).equals(node.getValues().get(j))) {
                    ids.add(i);
                }
            }
        }

        return ids;
    }
}