print("Classifying...");

importlog = "Artificial - Loan Process.xes";
importmodel = "inductive_mined_net.pnml";
exportlog = "transition_result.xes";

//---------------------------------------------------
print("<import file=\"" + importlog + "\">");

// Use the name of the plugin (in lowercase) to open a log
print("    <pluginfo>");
org.deckfour.xes.model.XLog log = open_xes_log_file(importlog);
print("    </pluginfo>");

logname = org.deckfour.xes.extension.std.XConceptExtension.instance().extractName(log);
print("    <name>" + logname + "</name>");
print("    <traces>" + log.size() + "</traces>");
events = 0;
for (trace : log) {
    events += trace.size();
}
print("    <events>" + events + "</events>");
print("    <classifiers>" + log.getClassifiers().size() + "</classifiers>");
print("</import>");

print(" Classifirers:");
for ( claasifier : log.getClassifiers()) {
    print(" "+claasifier);
}

print("<import file=\"" + importmodel + "\">");

print("    <pluginfo>");
res = import_petri_net_from_pnml_file(importmodel);
print("    </pluginfo>");

model = res[0];
marking = res[1];




print("    <name>" + model.getLabel() + "</name>");
print("    <transitions size=\"" + model.getTransitions().size() + "\">");
for (transition : model.getTransitions()) {
    print("        <transition>" + transition.getAttributeMap().get(org.processmining.models.graphbased.AttributeMap.LABEL) + "</transition>");
}
print("    <places size=\"" + model.getPlaces().size() + "\">");
for (place : model.getPlaces()) {
    print("        <place>" + place.getAttributeMap().get(org.processmining.models.graphbased.AttributeMap.LABEL) + "</place>");
}
print("    <marking>" + marking + "</marking>");
print("</import>");

//---------------------------------------------------
print("<replay>");

print("    <pluginfo>");

// get th eintiial and final marking (assume there is a single final marking).
anet = pack_petri_net(model);
net = anet.getNet();
initialMarking = anet.getInitialMarking();
finalMarking = anet.getFinalMarkings().iterator().next();



// Initialize the replayer
eventClassifier = log.getClassifiers().isEmpty() ? new org.deckfour.xes.classification.XEventNameClassifier() : log.getClassifiers().get(0);
logs = org.processmining.log.models.impl.EventLogArrayFactory.createEventLogArray();
dummyClass = new org.deckfour.xes.classification.XEventClass("DUMMY", 99999);
mapping = nl.tue.alignment.test.BasicCodeSnippet.constructMappingBasedOnLabelEquality(net, log, dummyClass, eventClassifier);

print("eventClassifier:"+eventClassifier);
summary = org.deckfour.xes.info.XLogInfoFactory.createLogInfo(log, eventClassifier);
classes = summary.getEventClasses();



// Setting the correct costs
costModelMove = new HashMap();
costSyncMove = new HashMap();
costLogMove = new HashMap();
for (transition : net.getTransitions()) {
	costSyncMove.put(transition, 0);
	costModelMove.put(transition, transition.isInvisible() ? 0 : 2);
}
for (clss : summary.getEventClasses().getClasses()) {
    print("class :"+ clss);
	costLogMove.put(clss, 5);
}
costLogMove.put(dummyClass, 5);

nThreads = 6;
costUpperBound = 0;
//too low! timeoutMilliseconds = 10 * 1000;
timeoutMilliseconds = 600 * 1000;
//too high! timeoutMilliseconds = Integer.MAX_VALUE;

maximumNumberOfStates = Integer.MAX_VALUE;

parameters = new nl.tue.alignment.ReplayerParameters.AStar(true, true, true, nThreads, true,
    nl.tue.alignment.algorithms.ReplayAlgorithm.Debug.NONE,
   timeoutMilliseconds, maximumNumberOfStates, costUpperBound, false);
parameters = new nl.tue.alignment.ReplayerParameters.IncrementalAStar(true, nThreads, false,
    nl.tue.alignment.algorithms.ReplayAlgorithm.Debug.NONE, timeoutMilliseconds,
	maximumNumberOfStates, costUpperBound, false, 20);
replayer = new nl.tue.alignment.Replayer(parameters, net, initialMarking, finalMarking, classes, costModelMove,
	costLogMove, costSyncMove, mapping, false);

preProcessTimeNanoseconds = 0L;

// Starting the replayer
service = java.util.concurrent.Executors.newFixedThreadPool(parameters.nThreads);
futures = new java.util.concurrent.Future[log.size()];
eventWithErrors = new int[0];



//TraceReplayTask for each Trace i log
for (i = 0; i < log.size(); i++) {
	task = new nl.tue.alignment.TraceReplayTask(replayer, parameters, log.get(i), i, timeoutMilliseconds,
		parameters.maximumNumberOfStates, preProcessTimeNanoseconds, eventWithErrors);
	futures[i] = service.submit(task);
}
service.shutdown();
print("    </pluginfo>");
print("</replay>");
//---------------------------------------------------
print("<classify>");

pos = 0;
neg = 0;
unr = 0;

//Collection pnReplayResultList = new java.util.TreeSet<org.processmining.plugins.replayer.replayresult.SyncReplayResult>();
java.util.Set pnReplayResultList = new java.util.HashSet();

for (i = 0; i < log.size(); i++) {
    isPos = false;
	try {
		result =  futures[i].get();
        
       // print("\nfuture task :"+futures[i]+" trace replay task :"+result);
		if (result.getResult() == nl.tue.alignment.TraceReplayTask.TraceReplayResult.SUCCESS) {
			replayResult = result.getSuccesfulResult();
            pnReplayResultList.add(replayResult);
          
           // print("replay result:"+replayResult + " getInfo:"+replayResult.getInfo());
			exitCode = replayResult.getInfo().get(nl.tue.alignment.Replayer.TRACEEXITCODE).intValue();
			if ((exitCode & nl.tue.alignment.Utils.OPTIMALALIGNMENT) == nl.tue.alignment.Utils.OPTIMALALIGNMENT) {
                isPos = true;
                pos++;
            } else if ((exitCode & nl.tue.alignment.Utils.COSTLIMITREACHED) == nl.tue.alignment.Utils.COSTLIMITREACHED) {
                neg++;
            } else if ((exitCode & nl.tue.alignment.Utils.FINALMARKINGUNREACHABLE) == nl.tue.alignment.Utils.FINALMARKINGUNREACHABLE) {
                neg++;
			} else {
                print("Trace '" + log.get(i).getAttributes().get("concept:name") + "': exit code " + exitCode);
                unr++;
            }
        } else {
            unr++;
        }
	} catch (Exception e) {
		throw new RuntimeException("Error while executing replayer in ExecutorService. Interrupted maybe?", e);
	}
    log.get(i).getAttributes().put("pdc:costs", org.deckfour.xes.factory.XFactoryRegistry.instance().currentDefault().createAttributeBoolean("pdc:isPos", isPos, null));
}

print("    <positive>" + pos + "</positive>");
print("    <negative>" + neg + "</negative>");
print("    <unreliable>" + unr + "</unreliable>");

print("</classify>");

//---------------------------------------------------
print("<export file=\"" + exportlog + "\">");

exportfile = new java.io.File(exportlog);

print("    <pluginfo>");
org.processmining.plugins.log.exporting.ExportLogXes.export(log, exportfile);	
print("    </pluginfo>");

print("    <bytes>" + exportfile.length() + "</bytes>");

print("</export>");

//---------------------- 

org.processmining.framework.plugin.GlobalContext globalContext = new org.processmining.contexts.cli.CLIContext();
org.processmining.framework.plugin.PluginContext pluginContext = new org.processmining.contexts.cli.CLIPluginContext(globalContext ,"Plugin Context");

org.processmining.plugins.petrinet.manifestreplayer.algorithms.IPNManifestReplayAlgorithm algorithm = new org.processmining.plugins.petrinet.manifestreplayer.algorithms.PNManifestReplayerILPAlgorithm();
initMarking = initialMarking ; 
org.processmining.models.semantics.petrinet.Marking[] finalMarkings = new org.processmining.models.semantics.petrinet.Marking[finalMarking.size()];
finalMarkings[0] = finalMarking;

//Error - Can't find constructor: PNManifestReplayerParameter - not sure about how to populate the parameters 
pnmParameter = new org.processmining.plugins.petrinet.manifestreplayer.PNManifestReplayerParameter(null,null, mapping, maximumNumberOfStates, initMarking, finalMarkings);
manifestReplayer = new org.processmining.plugins.petrinet.manifestreplayer.PNManifestReplayer();
manifest = manifestReplayer.replayLogParameter(pluginContext, model, log, algorithm, pnmParameter);

//----------------------

//Error - these 2 plugin invocation fails with - Command not found
//manifest = from_petri_net_and_event_log_given_algorithm_and_parameters(pluginContext, net, log, algorithm, pnmParameter);

//context = new org.processmining.contexts.uitopia.UIContext();
//pluginContext = context.getMainPluginContext();
// manifest = replay_a_log_on_petri_net_for_performance_conformance_analysis(pluginContext, model, log, algorithm, pnmParameter );
//component = performance_projection_to_model(manifest);

//----------------------

//Error - The below code throws CancellationException
//org.processmining.plugins.petrinet.replayresult.PNRepResult alignment = new org.processmining.plugins.petrinet.replayresult.PNRepResultImpl(pnReplayResultList);
//performance_matrix = time_between_transition_analysis(alignment); 
//print("component:"+performance_matrix);
//----------------------