/* Query PROV serializations.

Copyright (c) 2015 The Regents of the University of California.
All rights reserved.
Permission is hereby granted, without written agreement and without
license or royalty fees, to use, copy, modify, and distribute this
software and its documentation for any purpose, provided that the above
copyright notice and the following two paragraphs appear in all copies
of this software.

IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
ENHANCEMENTS, OR MODIFICATIONS.

*/
package org.kepler.provenance.prov;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.jar.JarFile;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;

import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;

import org.apache.commons.io.IOUtils;
import org.kepler.objectmanager.lsid.KeplerLSID;
import org.kepler.provenance.DefaultQuery;
import org.kepler.provenance.QueryException;
import org.openprovenance.prov.interop.InteropFramework;
import org.openprovenance.prov.interop.InteropFramework.ProvFormat;
import org.openprovenance.prov.model.Activity;
import org.openprovenance.prov.model.Document;
import org.openprovenance.prov.model.Entity;
import org.openprovenance.prov.model.HasOther;
import org.openprovenance.prov.model.HasRole;
import org.openprovenance.prov.model.Identifiable;
import org.openprovenance.prov.model.Other;
import org.openprovenance.prov.model.QualifiedName;
import org.openprovenance.prov.model.Role;
import org.openprovenance.prov.model.StatementOrBundle;
import org.openprovenance.prov.model.Used;
import org.openprovenance.prov.model.WasGeneratedBy;

/** A class to query provenance in PROV serializations.
 * 
 *  @author Daniel Crawl
 *  @version $Id: ProvQuery.java 33846 2015-09-02 00:25:36Z crawl $
 * 
 */
public class ProvQuery extends DefaultQuery {

    /** Create a new ProvQuery from an input stream using a specific
     *  format. The stream is not closed by this method.
     */
    public ProvQuery(InputStream stream, ProvFormat format) throws QueryException {
        
        _initialize();
                
        InteropFramework framework = new InteropFramework();
        Document document = framework.readDocument(stream, format);
        _statements = document.getStatementOrBundle();
    }
        
    /** Create a new ProvQuery for a PROV serialization in the
     *  specified file.
     */
    public ProvQuery(String filename) throws QueryException {
        
        _initialize();
        
        File file = new File(filename);
        if(!file.exists()) {
            throw new QueryException("File does not exist: " + filename);
        }
                
        InteropFramework framework = new InteropFramework();
        Document document = framework.readDocumentFromFile(filename);
        _statements = document.getStatementOrBundle();        
    }
    
    /** Disconnect from the underlying provenance store. Once this
     *  method is called, no further methods may be called on this
     *  object.
     */
    @Override
    public void disconnect() throws QueryException {
        _statements.clear();
        _wfEntity = null;
        _wfName = null;
    }
    
    /** Get the actor firing ids for a workflow execution id. */
    @Override
    public List<Integer> getActorFirings(int execId) throws QueryException {
        if(execId == _EXECUTION_ID) {
            return _getIdentifiableIds(StatementOrBundle.Kind.PROV_ACTIVITY,
                _ACTIVITY_ID_PATTERN);
        }        
        return null;
    }
    
    /** Get the firing id(s) of the actor(s) that read or wrote a token.
     *  @param tokenId the token id
     *  @param read If true, return the actor(s) firing id(s) that read
     *  the token. Otherwise, return the actor firing that wrote the token.
     */
    @Override
    public List<Integer> getActorFiringForToken(int tokenId, boolean read)
            throws QueryException {
        
        List<Integer> firings = new LinkedList<Integer>();

        StatementOrBundle.Kind kind;        
        if(read) {
            kind = StatementOrBundle.Kind.PROV_USAGE;
        } else {
            kind = StatementOrBundle.Kind.PROV_GENERATION;
        }
        
        for(StatementOrBundle statement : _statements) {
            if(statement.getKind() == kind) {
                
                QualifiedName activity;
                QualifiedName entity;
                if(kind == StatementOrBundle.Kind.PROV_USAGE) {
                    activity = ((Used)statement).getActivity();
                    entity = ((Used)statement).getEntity();
                } else {
                    activity = ((WasGeneratedBy)statement).getActivity();
                    entity = ((WasGeneratedBy)statement).getEntity();
                }
                
                Matcher matcher = _ENTITY_ID_PATTERN.matcher(entity.getLocalPart());
                if(matcher.matches()) {
                    Integer entityId = Integer.valueOf(matcher.group(1));
                    if(entityId.equals(Integer.valueOf(tokenId))) {
                        matcher = _ACTIVITY_ID_PATTERN.matcher(activity.getLocalPart());
                        if(!matcher.matches()) {
                            System.err.println("WARNING: unknown activity id: " +
                                activity.getLocalPart());
                            continue;
                        }
                        Integer idVal = Integer.valueOf(matcher.group(1));
                        firings.add(idVal);
                    }
                }
            }
        }
        return firings;

    }

    /** Get the actor name for a firing id. */
    @Override
    public String getActorName(int fireId) throws QueryException {        

        if(_wfEntity == null) {
            _findWorkflowEntity(_EXECUTION_ID);
        }

        Activity activity = _getActivityForFiring(fireId);
        if(activity != null) {
            String actorFullName = (String) _getOtherValue(activity, ProvRecording.QN_ACTOR_NAME);
            if(actorFullName != null) {
                return actorFullName.substring(_wfName.length());
            }
        }
        return null;
    }
    
    /** Get the execution LSID for a workflow execution id. */
    @Override
    public KeplerLSID getExecutionLSIDForExecution(Integer execId)
            throws QueryException {
        
        if(_wfEntity == null) {
            _findWorkflowEntity(execId);
        }
        
        if(_wfEntity != null && execId == _EXECUTION_ID) {
            String lsidStr = (String) _getOtherValue(_wfEntity, ProvRecording.QN_EXECUTION_LSID);
            if(lsidStr != null) {
                try {
                    return new KeplerLSID(lsidStr);
                } catch (Exception e) {
                    throw new QueryException("Error created LSID.", e);
                }
            }
        }        
        return null;
    }

    /** Get execution ids. For Prov, there is only one execution
     *  per file.
     */
    @Override
    public List<Integer> getExecutions() throws QueryException {
        List<Integer> list = new LinkedList<Integer>();
        list.add(Integer.valueOf(_EXECUTION_ID));
        return list;
    }

    /** Get the MoML for an execution. */
    @Override
    public String getMoMLForExecution(int execId) throws QueryException {
        
        if(_wfEntity == null) {
            _findWorkflowEntity(execId);
        }
        
        if(_wfEntity != null) {
            return (String) _wfEntity.getValue().getValue();
        }
        
        return null;
    }

    /** Get the output role (port name) of a token. */
    @Override
    public String getOutputRoleToken(int tokenId) throws QueryException {
        return _getRole(tokenId, null, StatementOrBundle.Kind.PROV_GENERATION);
    }
    
    /** Get the input role (port name) of a token. */
    @Override
    public String getInputRoleForTokenAndFireId(int tokenId, int fireId)
        throws QueryException {
        return _getRole(tokenId, fireId, StatementOrBundle.Kind.PROV_USAGE);
    }

    /** Get the start and end timestamps of an actor firing. */
    @Override
    public Date[] getTimestampsForActorFiring(int fireId)
        throws QueryException
    {

        Activity activity = _getActivityForFiring(fireId);
        if(activity != null) {
            Date startDate = null;
            Date endDate = null;
            XMLGregorianCalendar start = activity.getStartTime();
            if(start != null) {
                startDate = start.toGregorianCalendar().getTime();
            }
   
            XMLGregorianCalendar end = activity.getEndTime();
            if(end != null) {
                endDate = end.toGregorianCalendar().getTime();
            }
            
            if(startDate != null && endDate != null) {
                return new Date [] {startDate, endDate};
            }
        }
        return null;
    }
    
    /** Get the start and stop timestampes for a workflow execution id. */
    @Override
    public Date[] getTimestampsForExecution(int execId) throws QueryException {

        if(_wfEntity == null) {
            _findWorkflowEntity(execId);
        }

        if(_wfEntity != null && execId == _EXECUTION_ID) {
            Date timestamps[] = new Date[2];
            for(Other other : _wfEntity.getOther()) {
                String localPart = other.getElementName().getLocalPart();
                if(localPart.equals(ProvRecording.QN_EXECUTION_START_DATETIME)) {
                    String timestampStr = (String) other.getValue();
                    timestamps[0] = _dataTypeFactory.newXMLGregorianCalendar(timestampStr).toGregorianCalendar().getTime();
                } else if(localPart.equals(ProvRecording.QN_EXECUTION_END_DATETIME)) {
                    String timestampStr = (String) other.getValue();
                    timestamps[1] = _dataTypeFactory.newXMLGregorianCalendar(timestampStr).toGregorianCalendar().getTime();                    
                }
            }
            return timestamps;
        }
        return null;
    }

    /** Get the timestamp(s) when a token was read. If a token was
     *  never read, this can return null or an empty array.
     */
    @Override
    public Date[] getTimestampsForTokenRead(Integer tokenId) throws QueryException {
        
        List<Date> dates = new LinkedList<Date>();
        for(StatementOrBundle statement : _statements) {
            if(statement.getKind() == StatementOrBundle.Kind.PROV_USAGE) {
                Used used = (Used)statement;
                QualifiedName entity = used.getEntity();
                Matcher matcher = _ENTITY_ID_PATTERN.matcher(entity.getLocalPart());
                if(!matcher.matches()) {
                    System.err.println("WARNING: unknown entity id: " +
                        entity.getLocalPart() + " in Used " + used);
                    continue;
                }
                if(Integer.valueOf(matcher.group(1)).equals(tokenId)) {
                    XMLGregorianCalendar time = used.getTime();
                    if(time != null) {
                        dates.add(time.toGregorianCalendar().getTime());
                    }
                } 
            }
        }
        return dates.toArray(new Date[dates.size()]);
    }

    /** Get the timestamp when a token was written. */
    @Override
    public Date getTimestampForTokenWrite(Integer tokenId) throws QueryException {
     
        for(StatementOrBundle statement : _statements) {
            if(statement.getKind() == StatementOrBundle.Kind.PROV_GENERATION) {
                WasGeneratedBy wgb = (WasGeneratedBy)statement;
                QualifiedName entity = wgb.getEntity();
                Matcher matcher = _ENTITY_ID_PATTERN.matcher(entity.getLocalPart());
                if(!matcher.matches()) {
                    System.err.println("WARNING: unknown entity id: " +
                        entity.getLocalPart() + " in WasGeneratedBy " + wgb);
                    continue;
                }
                if(Integer.valueOf(matcher.group(1)).equals(tokenId)) {
                    XMLGregorianCalendar time = wgb.getTime();
                    if(time != null) {
                        return time.toGregorianCalendar().getTime();
                    }
                }
            }
        }
        return null;
    }

    /** Get an sequence of tokens for an execution.
     *  @param execId the execution id
     *  @param portId the port id. If null, returns a the ids of
     *  tokens read in entire execution.
     *  @param last if true, the sequence starts at the last token created
     *  and goes backwards to the first; otherwise the sequence starts at
     *  the first.
     */
    @Override
    public List<Integer> getTokensForExecution(int execId, Integer portId,
        boolean last) throws QueryException {
     
        if(portId != null) {
            throw new QueryException("Getting tokens for a specific " +
                "port not implemented for PROV.");
        }
        
        if(_wfEntity == null) {
            _findWorkflowEntity(execId);
        }
        
        if(_wfEntity != null && execId == _EXECUTION_ID) {
            
            List<Integer> tokenIds = new ArrayList<Integer>();
            for(StatementOrBundle statement : _statements) {
                if(statement.getKind() == StatementOrBundle.Kind.PROV_GENERATION) {

                    QualifiedName entity = ((WasGeneratedBy)statement).getEntity();

                    Matcher matcher = _ENTITY_ID_PATTERN.matcher(entity.getLocalPart());
                    if(!matcher.matches()) {
                        System.err.println("WARNING: unknown entity id: " +
                            entity.getLocalPart());
                        continue;
                    }
                    Integer idVal = Integer.valueOf(matcher.group(1));
                    tokenIds.add(idVal);
                }
            }
            if(last) {
                Collections.sort(tokenIds, Collections.reverseOrder());
            } else {
                Collections.sort(tokenIds);
            }
            return tokenIds;
        }
        return null;        
    }

    /** Get tokens for a firing.
     *  @param fireId the firing id
     *  @param read if true, get the tokens read; otherwise get the tokens
     *  written.
     */
    @Override
    public List<Integer> getTokensForFiring(int fireId, boolean read)
        throws QueryException {

        List<Integer> tokens = new LinkedList<Integer>();

        StatementOrBundle.Kind kind;        
        if(read) {
            kind = StatementOrBundle.Kind.PROV_USAGE;
        } else {
            kind = StatementOrBundle.Kind.PROV_GENERATION;
        }
        
        for(StatementOrBundle statement : _statements) {
            if(statement.getKind() == kind) {
                
                QualifiedName activity;
                QualifiedName entity;
                if(kind == StatementOrBundle.Kind.PROV_USAGE) {
                    activity = ((Used)statement).getActivity();
                    entity = ((Used)statement).getEntity();
                } else {
                    activity = ((WasGeneratedBy)statement).getActivity();
                    entity = ((WasGeneratedBy)statement).getEntity();
                }
                
                Matcher matcher = _ACTIVITY_ID_PATTERN.matcher(activity.getLocalPart());
                if(matcher.matches()) {
                    Integer activityId = Integer.valueOf(matcher.group(1));
                    if(activityId.equals(Integer.valueOf(fireId))) {
                        matcher = _ENTITY_ID_PATTERN.matcher(entity.getLocalPart());
                        if(!matcher.matches()) {
                            System.err.println("WARNING: unknown entity id: " + entity.getLocalPart());
                            continue;
                        }
                        Integer idVal = Integer.valueOf(matcher.group(1));
                        tokens.add(idVal);
                    }
                }
            }
        }
        return tokens;
    }

    /** Get the value of a token. */
    @Override
    public String getTokenValue(int tokenId) throws QueryException {
        
        Entity entity = _getEntity(tokenId);
        if(entity != null) {
            return (String) entity.getValue().getValue();
        }
        return null;
    }

    /** Get the type of a token. */
    @Override
    public String getTokenType(int tokenId) throws QueryException {
        
        Entity entity = _getEntity(tokenId);
        if(entity != null) {
            return (String) _getOtherValue(entity, ProvRecording.QN_TOKEN_CLASS);
        }
        return null;
    }

    /** Get the channel that a token was read or written on.
     *  @param tokenId the token id
     *  @param read if true, return the channel the token was read on.
     *  otherwise, return the channel the token was written on.
     *  @param fireId the actor firing id. can be null for writes, but
     *  must be specified for reads.
     *  @return the channel the token was read or written on.
     */
    @Override
    public Integer getChannelForToken(int tokenId, boolean read, Integer fireId)
        throws QueryException {

        StatementOrBundle.Kind kind;
        if(read) {
            kind = StatementOrBundle.Kind.PROV_USAGE;
        } else {
            kind = StatementOrBundle.Kind.PROV_GENERATION;
        }
        
        StatementOrBundle statement = _getUsedOrWasGeneratedBy(tokenId, fireId, kind);
        
        if(statement != null) {
            String value = (String) _getOtherValue((HasOther) statement,
                ProvRecording.QN_CHANNEL);
            if(value != null) {
                try {
                    return Integer.valueOf(value);
                } catch(NumberFormatException e) {
                    throw new QueryException("Error converting channel to number: " +
                        value);
                }
            }
        }
        return null;        
    }

    ///////////////////////////////////////////////////////////////////
    ////                       protected methods                   ////

    /** Returns false since ProvRecording saves StringToken values
     *  using StringToken.stringValue(), which does not add
     *  surrounding double-quotes.
     */
    @Override
    protected boolean _stringTokenValuesHaveSurroundingQuotes() {
        return false;
    }

    ///////////////////////////////////////////////////////////////////
    ////                       private methods                     ////

    /** Set the workflow entity for a workflow execution id. */
    private void _findWorkflowEntity(int execId) throws QueryException {
        if(_wfEntity == null && execId == _EXECUTION_ID) {
            for(StatementOrBundle statement : _statements) {
                if(statement.getKind() == StatementOrBundle.Kind.PROV_ENTITY &&
                    ((Entity)statement).getId().getLocalPart().equals(ProvRecording.QN_WORKFLOW)) {
                    _wfEntity = (Entity)statement;
                    _wfName = (String) _getOtherValue(_wfEntity, ProvRecording.QN_ACTOR_NAME);                  
                    break;
                }
            }
        }
        
        //System.out.println(_wfEntity);
        
        if(_wfEntity == null) {
            throw new QueryException("Could not query workflow entity.");
        }
        if(_wfName == null) {
            throw new QueryException("Could not find workflow name in workflow entity.");
        }
    }
    
    /** Get the value for an Other with a specific id. */
    private Object _getOtherValue(HasOther hasOther, String idLocalPart) {
        for(Other other : hasOther.getOther()) {
            if(other.getElementName().getLocalPart().equals(idLocalPart)) {
                return other.getValue();
            }
        }
        return null;
    }
    
    /** Get the Activity for an actor firing id. */
    private Activity _getActivityForFiring(int fireId) {
        return (Activity) _getIdentifiable(fireId,
                StatementOrBundle.Kind.PROV_ACTIVITY,
                _ACTIVITY_ID_PATTERN);
    }
    
    
    /** Get the Entity for an token id. */
    private Entity _getEntity(int tokenId) {
        return (Entity) _getIdentifiable(tokenId,
                StatementOrBundle.Kind.PROV_ENTITY,
                _ENTITY_ID_PATTERN);
    }

    /** Get an Identifiable with a specific id. */
    private Identifiable _getIdentifiable(int id, StatementOrBundle.Kind kind,
            Pattern pattern) {
        for(StatementOrBundle statement : _statements) {
            if(statement.getKind() == kind) {              
                String idStr = ((Identifiable)statement).getId().getLocalPart();
                if(!idStr.equals(ProvRecording.QN_WORKFLOW)) {
                    Matcher matcher = pattern.matcher(idStr);
                    if(!matcher.matches()) {
                        System.err.println("WARNING: unknown id for " + 
                            kind + ": " + id);
                        continue;
                    }
                    Integer idVal = Integer.valueOf(matcher.group(1));
                    if(idVal.equals(Integer.valueOf(id))) {
                        return (Identifiable) statement;
                    }
                }
            }
        }
        return null;
    }
    
    /** Get the ids of identifiables.
     *  @param kind The kind of identifiable, e.g., activity, entity.
     *  @param pattern The regex pattern to capture that id in the identifiable name.
     *  @return The ids of the identifiables.
     */
    private List<Integer> _getIdentifiableIds(StatementOrBundle.Kind kind, Pattern pattern) {        
        List<Integer> ids = new LinkedList<Integer>();
        for(StatementOrBundle statement : _statements) {
            if(statement.getKind() == kind) {
                //System.out.println(statement);
                String id = ((Identifiable) statement).getId().getLocalPart();
                Matcher matcher = pattern.matcher(id);
                if(!matcher.matches()) {
                    System.err.println("WARNING: unknown id in activity: " + id);
                    continue;
                }
                ids.add(Integer.valueOf(matcher.group(1)));
            }
        }
        return ids;
    }

    /** Get the role (port name) for a token read or write. */
    private String _getRole(int entityId, Integer activityId,
            StatementOrBundle.Kind kind) {       

        StatementOrBundle statement = _getUsedOrWasGeneratedBy(entityId,
                activityId, kind);
        
        if(statement != null) {
            // get the port name from the Role
            List<Role> roles = ((HasRole)statement).getRole();
            if(roles != null && !roles.isEmpty()) {
                String roleStr = (String) roles.get(0).getValue();                            
                return roleStr.substring(_wfName.length());
            }
        }
        return null;
    }
    
    /** Get a used or was generated by for the specified entity and
     *  optional activity.
     *  @param entityId the id of the entity
     *  @param activityId the id of the activity. can be null
     *  @param kind the kind of statement to find, either used or
     *  was generated by.
     */
    private StatementOrBundle _getUsedOrWasGeneratedBy(int entityId,
            Integer activityId,  StatementOrBundle.Kind kind) {       
        
        for(StatementOrBundle statement : _statements) {
            if(statement.getKind() == kind) {
                
                QualifiedName activity;
                QualifiedName entity;
                if(kind == StatementOrBundle.Kind.PROV_USAGE) {
                    activity = ((Used)statement).getActivity();
                    entity = ((Used)statement).getEntity();
                } else {
                    activity = ((WasGeneratedBy)statement).getActivity();
                    entity = ((WasGeneratedBy)statement).getEntity();
                }

                // find the matching entity
                Matcher matcher = _ENTITY_ID_PATTERN.matcher(entity.getLocalPart());
                if(matcher.matches()) {
                    Integer curEntityId = Integer.valueOf(matcher.group(1));
                    if(curEntityId.equals(Integer.valueOf(entityId))) {
                    
                        // see if activity was specified
                        if(activityId != null) {
                            // find the matching activity
                            matcher = _ACTIVITY_ID_PATTERN.matcher(activity.getLocalPart());
                            if(!matcher.matches()) {
                                continue;
                            } else {
                                Integer curActivityId = Integer.valueOf(matcher.group(1));
                                if(!curActivityId.equals(Integer.valueOf(activityId))) {
                                    continue;
                                }
                            }
                        }
                        return statement;
                    }
                }
            }
        }
        return null;
    }

    /** Perform initialization . */
    private void _initialize() throws QueryException {
        try {
            _dataTypeFactory = DatatypeFactory.newInstance();
        } catch (DatatypeConfigurationException e) {
            throw new QueryException("Error create DataTypeFactory.", e);
        }
    }

    ///////////////////////////////////////////////////////////////////
    ////                       private fields                      ////

    /** The statements in the PROV record. */
    private List<StatementOrBundle> _statements;
    
    /** The workflow Entity. */
    private Entity _wfEntity;
    
    /** The name of the workflow. */
    private String _wfName;
    
    /** The execution id of the workflow. */
    private final static int _EXECUTION_ID = 1;
    
    /** Factory for calendars. */
    private DatatypeFactory _dataTypeFactory;
    
    /** Regex pattern for activity ids. */
    private final static Pattern _ACTIVITY_ID_PATTERN = Pattern.compile("a(\\d+)");

    /** Regex pattern for entity ids. */
    private final static Pattern _ENTITY_ID_PATTERN = Pattern.compile("e(\\d+)");
    
    /** For testing. */
    public static void main(String[] args) {
        
        try {

            String file = "/home/crawl/KeplerData/workflows/MyWorkflows/prov/04-HelloWorld-run382.kar"; 
            JarFile jar = new JarFile(file);
            ZipEntry entry = jar.getEntry("04-HelloWorld.382.PROV.xml");
            InputStream stream = jar.getInputStream(entry);
            
            FileOutputStream out = new FileOutputStream("/tmp/a.xml");
            out.write(IOUtils.toByteArray(stream));
            out.close();
            stream.close();
            jar.close();
            
            //ProvQuery query = new ProvQuery(stream, ProvFormat.XML);
            
            /*
            String file = "/home/crawl/KeplerData/workflows/MyWorkflows/prov/04-HelloWorld.382.PROV.xml"; 
            @SuppressWarnings("resource")
            ProvQuery query = new ProvQuery(new FileInputStream(file), ProvFormat.XML);
            */
            
            
            //@SuppressWarnings("unused")
            //String momlStr = query.getMoMLForExecution(_EXECUTION_ID);
            //System.out.println("got moml");
        } catch (Exception e) {
            System.err.println("ERROR: " + e.getMessage());
            e.printStackTrace();
        }
        
    }
    
}