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

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 java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 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) {
        /*
        List<ContingencyTableRow> contingencyTableRows = new ArrayList<>();

        // Create header row with column names.
        ContingencyTableRow contingencyTableRowHeader = new ContingencyTableRow(true, 0);
        for (String columnName : tableColumns.keySet()) {
            contingencyTableRowHeader.addTableRowCell(new ContingencyTableRowCell(columnName, 0));
        }
        contingencyTableRows.add(contingencyTableRowHeader);

        boolean listExpanded = false;

        // Create contingency table row.
        for (TableColumn tableColumn : tableColumns.values()) {
            List<String> values = tableColumn.getValues();

            // If list is not created, then create it.
            if (!listExpanded) {
                for (int j = 0; j < values.size(); j++) {
                    ContingencyTableRow contingencyTableRow = new ContingencyTableRow(false, 0);
                    contingencyTableRows.add(contingencyTableRow);
                }
                listExpanded = true;
            }

            // Iterate through all values and assign one value per one row.
            for (int j = 0; j < values.size(); j++) {
                ContingencyTableRowCell contingencyTableRowCell = new ContingencyTableRowCell(values.get(j), 0);
                contingencyTableRows.get(j + 1).addTableRowCell(contingencyTableRowCell);
            }
        }

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

        List<ContingencyTableRow> headerRows = createHeaderOnlyRows(tableColumns, columnNames);
        List<ContingencyTableRow> dataRows = createDataRows(tableColumns, columnNames, rowNames, valueFunctions);

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

        return contingencyTableRows;
    }

    private List<ContingencyTableRow> createHeaderOnlyRows(Map<String, TableColumn> tableColumns, List<NameUserName> columnNames) {
        List<List<String>> values = new ArrayList<>();
        columnNodes = new ArrayList<>();
        List<ContingencyTableRow> headerRows = new ArrayList<>();
        for(NameUserName nameUserName : columnNames) {
            TableColumn column = tableColumns.get(nameUserName.getName());
            values.add(getOriginalValuesFromList(column.getValues()));
            headerRows.add(new ContingencyTableRow(true, 0));
        }

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

        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) {
                        headerRows.get(i).addTableRowCell(new ContingencyTableRowCell(value + " Celkem", 1));
                    }
                }

                for (int l = 0; l < i; l++) {
                    headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("", 1));
                }
            }
            if (i == 0) {
                headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("Celkový počet", 1));
            }
        }

        return headerRows;
    }

    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;
    }

    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()));
        }

        Node node = new Node();
        generateRows(dataRows, 0, values, rowNodes, node);

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

        return dataRows;
    }

    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("\t");
                }
                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);
            }
        }
    }

    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);
            }
        }
    }

    private void fillRowWithCountData(ContingencyTableRow row, Map<String, TableColumn> tableColumns, Node node,
                                      List<NameUserName> rowNames, List<NameUserName> columnNames, List<ValueFunction> valueFunctions) {
        //sloupec v kont. tabulce
        for (Node columnNode : columnNodes) {
            int count = 0;
            // radek v orig. tabulce
            for (int i = 0; i < tableColumns.get(rowNames.get(0).getName()).getValues().size(); i++) {
                boolean isUsable = true;
                //zvoleny sloupec z radku
                for (int j = 0; j < node.getValues().size(); j++) {
                    if (!tableColumns.get(rowNames.get(j).getName()).getValues().get(i).equals(node.getValues().get(j))) {
                        isUsable = false;
                        break;
                    }
                }
                // zvoleny sloupec ze sloupcu
                for (int j = 0; j < columnNode.getValues().size(); j++) {
                    if (!tableColumns.get(columnNames.get(j).getName()).getValues().get(i).equals(columnNode.getValues().get(j))) {
                        isUsable = false;
                        break;
                    }
                }
                // zvoleny sloupec z hodnot
                for (ValueFunction valueFunction : valueFunctions) {
                    if (tableColumns.get(valueFunction.getValue()).getValues().get(i) == null) {
                        isUsable = false;
                        break;
                    }
                }

                if (isUsable) {
                    count++;
                }
            }

            row.addTableRowCell(new ContingencyTableRowCell(Integer.toString(count), 0));
        }
    }
}