ConstructQueryFormPane

/*
 * Copyright 2013-2023 Medical Information Systems Research Group (https://medical.zcu.cz),
 * Department of Computer Science and Engineering, University of West Bohemia.
 * Address: Univerzitni 8, 306 14 Plzen, Czech Republic.
 *
 * This file is part of Sparkle project.
 *
 * Sparkle is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License.
 *
 * Sparkle is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Sparkle. If not, see <http://www.gnu.org/licenses/>.
 */
package cz.zcu.mre.sparkle.gui.query.queryTypes.construct;

import cz.zcu.mre.sparkle.Messages;
import cz.zcu.mre.sparkle.data.DataAgent;
import cz.zcu.mre.sparkle.data.Storage;
import cz.zcu.mre.sparkle.gui.mainForm.MainForm;
import cz.zcu.mre.sparkle.gui.query.CustomTitledPane;
import cz.zcu.mre.sparkle.gui.query.QueryFormPane;
import cz.zcu.mre.sparkle.gui.query.modifiers.LimitOffsetClausePane;
import cz.zcu.mre.sparkle.gui.query.modifiers.OrderByClausePane;
import cz.zcu.mre.sparkle.gui.query.modifiers.ValuesClausePane;
import cz.zcu.mre.sparkle.gui.query.modifiers.groupBy.GroupByClausePane;
import cz.zcu.mre.sparkle.gui.query.modifiers.having.HavingClausePane;
import cz.zcu.mre.sparkle.gui.query.queryMainParts.FromClausePane;
import cz.zcu.mre.sparkle.gui.query.queryMainParts.WhereClausePane;
import cz.zcu.mre.sparkle.gui.query.queryTypes.subselect.SubSelectPane;
import cz.zcu.mre.sparkle.tools.Saveable;
import cz.zcu.mre.sparkle.tools.SparqlParser;
import cz.zcu.mre.sparkle.tools.sparqlParser.SparqlParserNode;
import cz.zcu.mre.sparkle.tools.sparqlParser.SparqlParserWhereClauseWalker;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.collections.ObservableSet;
import javafx.scene.Node;
import org.antlr.v4.runtime.tree.ParseTree;
import org.apache.jena.rdf.model.Model;
import org.w3c.dom.Element;
import java.util.*;
import static cz.zcu.mre.sparkle.gui.query.QueryFormPane.QUERY_PARTS.*;
import static cz.zcu.mre.sparkle.tools.sparqlParser.SparqlParserUtils.getTreeChild;

/**
 * Kontroler panelu s dotazem typu CONSTRUCT.
 *
 * @author Jan Smucr
 * @author Klara Hlavacova
 * @author Petr Vcelak (vcelak@kiv.zcu.cz)
 */
public final class ConstructQueryFormPane
        extends QueryFormPane<Model> {

    public static final String XML_QUERY_TYPE_VALUE = "construct"; //$NON-NLS-1$

    private List<Object> queryFormParts;

    private ObservableSet<String> constructClauseVariables;
    private ObservableSet<String> whereClauseVariables;
    private ObservableSet<String> orderByClauseVariables;
    private ObservableSet<String> groupByClauseVariables;
    private ObservableSet<String> valuesClauseVariables;

    public ConstructQueryFormPane(final MainForm mainForm, final DataAgent dataAgent, final Storage localStorage,
            String paneType) {
        super(mainForm, dataAgent, localStorage, paneType);
    }

    public ConstructQueryFormPane(final MainForm mainForm, final DataAgent dataAgent, final Storage localStorage,
            final Object root, String paneType)
            throws LoadException {
        super(mainForm, dataAgent, localStorage, root, paneType);
    }

    @Override
    public final void load(final Object root) throws LoadException {
        constructClauseVariables = FXCollections.observableSet();
        whereClauseVariables = FXCollections.observableSet();
        orderByClauseVariables = FXCollections.observableSet();
        groupByClauseVariables = FXCollections.observableSet();
        valuesClauseVariables = FXCollections.observableSet();

        initializeQueryFormParts();
        addVariablesCollectors();
        addPartsTitles();

        loadForm(root);

        watch((((ConstructClausePane) getPane(FIRST_CLAUSE))));
        addWatches();
    }

    /**
     * Nacte formular
     *
     * @param root rodicovsky element
     *
     * @throws LoadException
     */
    private void loadForm(Object root) throws LoadException {
        if (root == null) {
            // Výchozí nastavení nového dotazu
            (((ConstructClausePane) getPane(FIRST_CLAUSE))).addTriple(null, true);
            ((WhereClausePane) getPane(WHERE_CLAUSE)).addTriple(null, true);

        } else if (root instanceof Element) {
            Element rootNode = (Element) root;
            // Načtení uloženého dotazu
            loadElement(rootNode, (((ConstructClausePane) getPane(FIRST_CLAUSE))));
            loadQueryPartsElements((Element) root, queryFormParts);

        } else if (root instanceof ParseTree) {
            setVariables((ParseTree) root);
        }
    }

    /**
     * Inicializace pole casti
     */
    private void initializeQueryFormParts() {
        queryFormParts = new ArrayList<>();

        queryFormParts.add(new ConstructClausePane(this));

        queryFormParts.add(new FromClausePane(this));
        queryFormParts.add(new WhereClausePane(this));
        queryFormParts.add(new OrderByClausePane(this));
        queryFormParts.add(new GroupByClausePane(this));
        queryFormParts.add(new HavingClausePane(this));
        queryFormParts.add(new LimitOffsetClausePane());
        queryFormParts.add(new ValuesClausePane(this));
    }

    /**
     * Nastavi kolektory promennych
     */
    private void addVariablesCollectors() {
        ((ConstructClausePane) getPane(FIRST_CLAUSE)).addVariablesCollector(
                createCollector(constructClauseVariables, whereClauseVariables, groupByClauseVariables,
                        orderByClauseVariables, valuesClauseVariables));

        ((WhereClausePane) getPane(WHERE_CLAUSE)).addVariablesCollector(
                createCollector(whereClauseVariables, groupByClauseVariables, orderByClauseVariables,
                        valuesClauseVariables));

        ((OrderByClausePane) getPane(ORDER_BY_CLAUSE)).addVariablesCollector(
                createCollector(orderByClauseVariables, whereClauseVariables, groupByClauseVariables,
                        valuesClauseVariables));

        ((GroupByClausePane) getPane(GROUP_BY_CLAUSE)).addVariablesCollector(
                createCollector(groupByClauseVariables, whereClauseVariables, orderByClauseVariables,
                        valuesClauseVariables));

        ((ValuesClausePane) getPane(VALUES_CLAUSE)).addVariablesCollector(
                createCollector(valuesClauseVariables, whereClauseVariables, groupByClauseVariables,
                        orderByClauseVariables));
    }

    /**
     * Vrati panel ze seznamu casti formulare
     *
     * @param paneType typ panelu
     *
     * @return panel ze seznamu casti formulare
     */
    private Object getPane(QUERY_PARTS paneType) {
        return getPane(queryFormParts, paneType);
    }

    /**
     * Titulky panelu
     */
    private void addPartsTitles() {
        final ObservableList<Node> children = getChildren();
        addChild(children, "CONSTRUCT_QUERY_FRAGMENT", (ConstructClausePane) getPane(FIRST_CLAUSE));
        addTitlesPanes(children);
    }

    private void addTitlesPanes(ObservableList<Node> children) {
        addChild(children, "FROM_QUERY_FRAGMENT", (FromClausePane) getPane(FROM_CLAUSE));
        addChild(children, "WHERE_QUERY_FRAGMENT", (WhereClausePane) getPane(WHERE_CLAUSE));
        addChild(children, "GROUP_BY_QUERY_FRAGMENT", (GroupByClausePane) getPane(GROUP_BY_CLAUSE));
        addChild(children, "HAVING_QUERY_FRAGMENT", (HavingClausePane) getPane(HAVING_CLAUSE));
        addChild(children, "ORDER_BY_QUERY_FRAGMENT", (OrderByClausePane) getPane(ORDER_BY_CLAUSE));
        addChild(children, "MODIFIERS_QUERY_FRAGMENT", (LimitOffsetClausePane) getPane(LIMIT_OFFSET_CLAUSE));
        addChild(children, "VALUES_QUERY_FRAGMENT", (ValuesClausePane) getPane(VALUES_CLAUSE));
    }

    /**
     * Vlozi {@code CustomTitledPane} do seznamu uzlu
     *
     * @param children seznam uzlu
     * @param title titulek
     * @param content obsah (panel)
     */
    private void addChild(ObservableList<Node> children, final String title, final Node... content) {
        children.add(new CustomTitledPane(Messages.getString(title), content));
    }

    /**
     * Nastavení hlídání změn
     */
    private void addWatches() {
        watch((FromClausePane) getPane(FROM_CLAUSE));
        watch((WhereClausePane) getPane(WHERE_CLAUSE));
        watch(((OrderByClausePane) getPane(ORDER_BY_CLAUSE)));
        watch(((GroupByClausePane) getPane(GROUP_BY_CLAUSE)));
        watch(((HavingClausePane) getPane(HAVING_CLAUSE)));
        watch(((LimitOffsetClausePane) getPane(LIMIT_OFFSET_CLAUSE)));
        watch(((ValuesClausePane) getPane(VALUES_CLAUSE)));
    }

    @Override
    protected void setVariables(ParseTree root) throws LoadException {
        Stack<SparqlParserNode> nodeStack = new Stack<>(); //current path in parse tree
        nodeStack.push(new SparqlParserNode(root));
        while (!nodeStack.isEmpty()) {
            SparqlParserNode currentNode = nodeStack.pop();

            ParseTree nodeData = currentNode.getNodeData();

            if (nodeData instanceof SparqlParser.ConstructTriplesContext) { //part with variables of query
                new SparqlParserWhereClauseWalker(nodeData, (((ConstructClausePane) getPane(FIRST_CLAUSE))))
                        .processWhereClauseDFS();
            } else if (nodeData instanceof SparqlParser.DatasetClauseContext) { //from clause
                ((FromClausePane) getPane(FROM_CLAUSE)).load(nodeData);

            } else if (nodeData instanceof SparqlParser.LimitClauseContext) { //limit clause
                ((LimitOffsetClausePane) getPane(LIMIT_OFFSET_CLAUSE)).load(nodeData);

            } else if (nodeData instanceof SparqlParser.OffsetClauseContext) { //offset clause
                ((LimitOffsetClausePane) getPane(LIMIT_OFFSET_CLAUSE)).load(nodeData);

            } else if (nodeData instanceof SparqlParser.OrderConditionContext) { //order clause
                ((OrderByClausePane) getPane(ORDER_BY_CLAUSE)).load(nodeData);

            } else if (nodeData instanceof SparqlParser.HavingConditionContext) { //having clause
                ((HavingClausePane) getPane(HAVING_CLAUSE)).load(nodeData);

            } else if (nodeData instanceof SparqlParser.WhereClauseContext) { //where clause
                new SparqlParserWhereClauseWalker(nodeData, ((WhereClausePane) getPane(WHERE_CLAUSE)))
                        .processWhereClauseDFS();

            } else if (nodeData instanceof SparqlParser.GroupConditionContext) { //group by clause
                ((GroupByClausePane) getPane(GROUP_BY_CLAUSE)).load(nodeData);

            } else if (nodeData instanceof SparqlParser.ValuesClauseContext) { // Values clause
                ((ValuesClausePane) getPane(VALUES_CLAUSE)).load(nodeData);

            } else { //uninsteresting node -> get next node
                nodeStack.push(currentNode);
                getTreeChild(currentNode, nodeStack);
            }
        }
    }

    @Override
    public final String getQueryPart() {
        return "CONSTRUCT " //$NON-NLS-1$
                + (((ConstructClausePane) getPane(FIRST_CLAUSE))).getQueryPart()
                + ((FromClausePane) getPane(FROM_CLAUSE)).getQueryPart() + "WHERE "//$NON-NLS-1$
                + ((WhereClausePane) getPane(WHERE_CLAUSE)).getQueryPart()
                + ((GroupByClausePane) getPane(GROUP_BY_CLAUSE)).getQueryPart()
                + ((HavingClausePane) getPane(HAVING_CLAUSE)).getQueryPart()
                + ((OrderByClausePane) getPane(ORDER_BY_CLAUSE)).getQueryPart()
                + ((LimitOffsetClausePane) getPane(LIMIT_OFFSET_CLAUSE)).getQueryPart()
                + ((ValuesClausePane) getPane(VALUES_CLAUSE)).getQueryPart() + " ";
    }

    @Override
    public final Set<String> getPrefixesUsed(final boolean appendDelimiter) {
        final Set<String> result
                = new HashSet<>((((ConstructClausePane) getPane(FIRST_CLAUSE))).getPrefixesUsed(appendDelimiter));
        result.addAll(((WhereClausePane) getPane(WHERE_CLAUSE)).getPrefixesUsed(appendDelimiter));
        result.addAll(((FromClausePane) getPane(FROM_CLAUSE)).getPrefixesUsed(appendDelimiter));
        result.addAll(((OrderByClausePane) getPane(ORDER_BY_CLAUSE)).getPrefixesUsed(appendDelimiter));
        result.addAll(((GroupByClausePane) getPane(GROUP_BY_CLAUSE)).getPrefixesUsed(appendDelimiter));
        result.addAll(((HavingClausePane) getPane(HAVING_CLAUSE)).getPrefixesUsed(appendDelimiter));
        result.addAll(((ValuesClausePane) getPane(VALUES_CLAUSE)).getPrefixesUsed(appendDelimiter));
        return result;
    }

    @Override
    public final List<SubSelectPane> getSubSelectPanes() {
        return ((WhereClausePane) getPane(WHERE_CLAUSE)).getSubSelectPanes();
    }

    @Override
    public final ObservableList<String> getSortedVariables() {
        ObservableSet<String> variables = FXCollections.observableSet();
        variables.addAll(this.getNetVariables());
        ((WhereClausePane) getPane(WHERE_CLAUSE)).getSubSelectPanes().forEach((subSelectPane) -> variables.addAll(subSelectPane.getSubSelectQueryPane().getSelectedVariables()));
        return FXCollections.observableArrayList(variables).sorted(String.CASE_INSENSITIVE_ORDER);
    }

    @Override
    public final void save(final Element root) {
        Saveable.defaultSave(root, (((ConstructClausePane) getPane(FIRST_CLAUSE))),
                ((FromClausePane) getPane(FROM_CLAUSE)), ((WhereClausePane) getPane(WHERE_CLAUSE)),
                ((LimitOffsetClausePane) getPane(LIMIT_OFFSET_CLAUSE)),
                ((OrderByClausePane) getPane(ORDER_BY_CLAUSE)),
                ((HavingClausePane) getPane(HAVING_CLAUSE)),
                ((GroupByClausePane) getPane(GROUP_BY_CLAUSE)),
                ((ValuesClausePane) getPane(VALUES_CLAUSE)));
    }

    @Override
    protected final String getXMLQueryType() {
        return XML_QUERY_TYPE_VALUE;
    }

}