/**
 *                                                                            
 *  Copyright (c) 2011, 2018 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
 *                                                                            
 *  All rights reserved. This program and the accompanying materials           
 *  are made available under the terms of the Eclipse Public License 2.0        
 *  which accompanies this distribution, and is available at                  
 *  https://www.eclipse.org/legal/epl-2.0/                                 
 *                                 
 *  SPDX-License-Identifier: EPL-2.0                                 
 *                                                                            
 *  Contributors:                                                      
 * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
 * 
 * generated by Xtext 2.11.0
 * 
 */

package org.eclipse.osbp.xtext.signal.jvmmodel

import java.nio.file.Path
import java.util.Date
import java.util.HashSet
import javax.inject.Inject
import org.eclipse.osbp.core.api.persistence.IPersistenceService
import org.eclipse.osbp.datainterchange.api.IDataInterchange
import org.eclipse.osbp.dsl.common.xtext.extensions.AnnotationExtension
import org.eclipse.osbp.runtime.common.event.IEventDispatcher
import org.eclipse.osbp.ui.api.customfields.IBlobService
import org.eclipse.osbp.xtext.datainterchange.DataInterchange
import org.eclipse.osbp.xtext.datainterchange.DataInterchangeGroup
import org.eclipse.osbp.xtext.datainterchange.common.WorkerThreadRunnable
import org.eclipse.osbp.xtext.datainterchange.jvmmodel.DataDSLJvmModelInferrer
import org.eclipse.osbp.xtext.datainterchange.validation.DataDSLValidator
import org.eclipse.osbp.xtext.functionlibrarydsl.FunctionLibraryPackage
import org.eclipse.osbp.xtext.signal.CronScheduler
import org.eclipse.osbp.xtext.signal.DailyScheduler
import org.eclipse.osbp.xtext.signal.HourlyScheduler
import org.eclipse.osbp.xtext.signal.MonthlyScheduler
import org.eclipse.osbp.xtext.signal.SignalActionTypeEnum
import org.eclipse.osbp.xtext.signal.SignalDSLPackage
import org.eclipse.osbp.xtext.signal.SignalDatainterchange
import org.eclipse.osbp.xtext.signal.SignalDefinition
import org.eclipse.osbp.xtext.signal.SignalExecutionTypeEnum
import org.eclipse.osbp.xtext.signal.SignalFunction
import org.eclipse.osbp.xtext.signal.SignalPackage
import org.eclipse.osbp.xtext.signal.SignalScheduler
import org.eclipse.osbp.xtext.signal.SignalTask
import org.eclipse.osbp.xtext.signal.SignalWatcher
import org.eclipse.osbp.xtext.signal.WeeklyScheduler
import org.eclipse.osbp.xtext.signal.common.SchedulerImpl
import org.eclipse.osbp.xtext.signal.common.SchedulerJobImpl
import org.eclipse.osbp.xtext.signal.common.WatcherImpl
import org.eclipse.osbp.xtext.signal.common.WatcherJobImpl
import org.eclipse.xtext.common.types.JvmField
import org.eclipse.xtext.common.types.JvmGenericType
import org.eclipse.xtext.common.types.JvmVisibility
import org.eclipse.xtext.naming.IQualifiedNameProvider
import org.eclipse.xtext.xbase.jvmmodel.AbstractModelInferrer
import org.eclipse.xtext.xbase.jvmmodel.IJvmDeclaredTypeAcceptor
import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder
import org.osgi.service.component.annotations.Activate
import org.osgi.service.component.annotations.Component
import org.osgi.service.component.annotations.Deactivate
import org.osgi.service.component.annotations.Reference
import org.osgi.service.component.annotations.ReferenceCardinality
import org.osgi.service.component.annotations.ReferencePolicy
import org.quartz.Job
import org.quartz.JobDetail
import org.quartz.JobExecutionContext
import org.quartz.JobExecutionException
import org.quartz.Scheduler
import org.quartz.SchedulerException
import org.quartz.Trigger
import org.slf4j.Logger
import java.nio.file.FileSystem
import java.nio.file.FileSystems

/**
 * <p>Infers a JVM model from the source model.</p> 
 * 
 * <p>The JVM model should contain all elements that would appear in the Java code 
 * which is generated from the source model. Other models link against the JVM model rather than the source model.</p>     
 */
class SignalDSLJvmModelInferrer extends AbstractModelInferrer {

	/**
	 * convenience API to build and initialize JVM types and their members.
	 */
	@Inject extension JvmTypesBuilder
	@Inject extension IQualifiedNameProvider
	@Inject extension AnnotationExtension
	@Inject extension DataDSLJvmModelInferrer df
	@Inject extension DataDSLValidator dv

	private var operationlist =  <String>newHashSet
	
	/**
	 * infer model on package base. Will be called for every defined package.
	 * 
	 * @param dataInterchangePackage
	 *            An instance of {@link SignalDSLPackage}
	 * @param acceptor
	 *            the xtext acceptor interface
	 * @param isPreIndexingPhase
	 *            true if in preindexing phase
	 */
	def dispatch void infer(SignalPackage signalPackage, IJvmDeclaredTypeAcceptor acceptor,
		boolean isPreIndexingPhase) {
		val pckgName = signalPackage.name;
		for (signal : signalPackage.signals) {
			// create watchers and schedulers if at least on task has been defined
			if(signal !== null && signal.tasks !== null && !signal.tasks.empty) {
				var signalClass = signal.toClass(signal.fullyQualifiedName)
				if(signal instanceof SignalWatcher) {
					signalClass.simpleName = signal.name.toFirstUpper + "Watcher"
					
					// create the watcher tasks file
					var signalWatcherJobClass = signal.toClass(signal.fullyQualifiedName)
					signalWatcherJobClass.simpleName = signal.name.toFirstUpper + "WatcherJob"
					signalWatcherJobClass.packageName = pckgName
					acceptor.accept(signalWatcherJobClass, [					
						superTypes += _typeReferenceBuilder.typeRef(WatcherJobImpl)
						it.documentation = "Implements the list of tasks of "+ signal.name.toFirstUpper + "Watcher to be executed."
						it.toWatcherJobFields(signal)
						it.toWatcherJobOperations(signal)
					])
					
				}
				else if(signal instanceof SignalScheduler){
					signalClass.simpleName = signal.name.toFirstUpper + "Scheduler"
					
					// create the scheduler tasks file
					var signalSchedulerJobClass = signal.toClass(signal.fullyQualifiedName)
					signalSchedulerJobClass.simpleName = signal.name.toFirstUpper + "SchedulerJob"
					signalSchedulerJobClass.packageName = pckgName
					acceptor.accept(signalSchedulerJobClass, [					
						superTypes += _typeReferenceBuilder.typeRef(SchedulerJobImpl)
						it.documentation = "Implements the list of tasks of "+ signal.name.toFirstUpper + "Scheduler to be executed."
						it.toSchedulerJobFields(signal)
						it.toSchedulerJobOperations(signal)
					])
				}
				signalClass.packageName = pckgName
	
	 			// create the watcher and scheduler files
				acceptor.accept(signalClass, [
					if(signal instanceof SignalWatcher){
						superTypes += _typeReferenceBuilder.typeRef(WatcherImpl)
					}
					else if(signal instanceof SignalScheduler){
						superTypes += _typeReferenceBuilder.typeRef(SchedulerImpl)		
						superTypes += _typeReferenceBuilder.typeRef(Job)		
					}
					var annotationRef = _annotationTypesBuilder.annotationRef(typeof(Component))
					annotationRef.addAnnAttr(signalPackage, "immediate", Boolean.TRUE)
					annotations += annotationRef
	
					it.fileHeader = signalPackage.documentation
					it.toFields(signal)
					it.toConstructor(signal)
					it.toOperations(signal)
					it.toBinderOperations(signal)				
				])
			}
		}
	}
	
	def void toSchedulerJobOperations(JvmGenericType type, SignalScheduler scheduler){
		//the constructor
		type.members += scheduler.toConstructor [
			parameters += scheduler.toParameter("persistenceService", _typeReferenceBuilder.typeRef(IPersistenceService))
			parameters += scheduler.toParameter("dataInterchange", _typeReferenceBuilder.typeRef(IDataInterchange))
			parameters += scheduler.toParameter("blobService", _typeReferenceBuilder.typeRef(IBlobService))
			parameters += scheduler.toParameter("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher))
			parameters += scheduler.toParameter("schedulerid", _typeReferenceBuilder.typeRef(String))
			body = [
				append(
				'''
				this.persistenceService = persistenceService;
				this.dataInterchange = dataInterchange;
				this.blobService = blobService;
				this.eventDispatcher = eventDispatcher;
				setSchedulerId(schedulerid);
				«IF scheduler.hasFunctionWithFile»paths = new HashMap<String, Path>();
				«ENDIF»''')
			]				
		]
		//create the execute task operation
		type.members += scheduler.toMethod("executeListOfTasks", _typeReferenceBuilder.typeRef(Void::TYPE), [
			annotations += _annotationTypesBuilder.annotationRef(Override)			
			body = [append('''«scheduler.executeSchedulerTasksList»''')]
		])
		// create all scheduler operations
		operationlist.clear
		// a list of all available tasks 
		createTaskOperations(type, scheduler)
	}
	
	def void toSchedulerJobFields(JvmGenericType type, SignalScheduler signal) {
		var JvmField field = null
		// create persistence service field
		field = signal.toField("log", _typeReferenceBuilder.typeRef(Logger))
		field.visibility = JvmVisibility::PRIVATE
		field.documentation = "the log"
		field.initializer = '''LoggerFactory.getLogger("signal")'''
		type.members += field
		// create persistence service field
		field = signal.toField("persistenceService", _typeReferenceBuilder.typeRef(IPersistenceService))
		field.static = true
		field.visibility = JvmVisibility::PRIVATE
		type.members += field
		// create datainterchange service field
		field = signal.toField("dataInterchange", _typeReferenceBuilder.typeRef(IDataInterchange))
		field.static = true
		field.visibility = JvmVisibility::PRIVATE
		type.members += field
		// create blob service field		
		field = signal.toField("blobService", _typeReferenceBuilder.typeRef(IBlobService))
		field.static = true
		field.visibility = JvmVisibility::PRIVATE
		type.members += field
		// create event dispatcher service field		
		field = signal.toField("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher))
		field.static = true
		field.visibility = JvmVisibility::PRIVATE
		type.members += field

		// create the file path field
		if(signal.hasFunctionWithFile){
			field = signal.toField("paths", _typeReferenceBuilder.typeRef("HashMap<String,Path>"))
			field.visibility = JvmVisibility::PRIVATE
			field.static = true
			type.members += field			
		}
	}
	
	def void toWatcherJobOperations(JvmGenericType type, SignalWatcher watcher){
		//the constructor
		type.members += watcher.toConstructor [
			parameters += watcher.toParameter("persistenceService", _typeReferenceBuilder.typeRef(IPersistenceService))
			parameters += watcher.toParameter("dataInterchange", _typeReferenceBuilder.typeRef(IDataInterchange))
			parameters += watcher.toParameter("blobService", _typeReferenceBuilder.typeRef(IBlobService))
			parameters += watcher.toParameter("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher))
			parameters += watcher.toParameter("file", _typeReferenceBuilder.typeRef(Path))
			parameters += watcher.toParameter("watcherid", _typeReferenceBuilder.typeRef(String))
			body = [
				append(
				'''
				this.persistenceService = persistenceService;
				this.dataInterchange = dataInterchange;
				this.blobService = blobService;
				this.eventDispatcher = eventDispatcher;
				«if(watcher.hasFileMask){
					'''setParallelJobExecutionAllowed(true);'''
				}»
				setTriggerfile(file);
				setWatcherId(watcherid);
				«IF watcher.hasFunctionWithFile»paths = new HashMap<String, Path>();
				«ENDIF»''')
			]				
		]
		
		//create the execute task operation
		type.members += watcher.toMethod("executeListOfTasks", _typeReferenceBuilder.typeRef(Void::TYPE), [
			annotations += _annotationTypesBuilder.annotationRef(Override)
			body = [append('''«watcher.executeWatcherTasksList»''')]
		])
		
		// create all watcher operations
		operationlist = new HashSet()
		createTaskOperations(type, watcher)
	}
	
	def void toWatcherJobFields(JvmGenericType type, SignalWatcher signal) {
		var JvmField field = null
		// create persistence service field
		field = signal.toField("log", _typeReferenceBuilder.typeRef(Logger))
		field.visibility = JvmVisibility::PRIVATE
		field.documentation = "the log"
		field.initializer = '''LoggerFactory.getLogger("signal")'''
		type.members += field
		// create persistence service field
		field = signal.toField("persistenceService", _typeReferenceBuilder.typeRef(IPersistenceService))
		field.static = true
		field.visibility = JvmVisibility::PRIVATE
		type.members += field
		// create datainterchange service field
		field = signal.toField("dataInterchange", _typeReferenceBuilder.typeRef(IDataInterchange))
		field.static = true
		field.visibility = JvmVisibility::PRIVATE
		type.members += field
		// create blob service field		
		field = signal.toField("blobService", _typeReferenceBuilder.typeRef(IBlobService))
		field.static = true
		field.visibility = JvmVisibility::PRIVATE
		type.members += field
		// create event dispatcher service field		
		field = signal.toField("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher))
		field.static = true
		field.visibility = JvmVisibility::PRIVATE
		type.members += field
		
		// create the file paths field
		if(signal.hasFunctionWithFile){
			field = signal.toField("paths", _typeReferenceBuilder.typeRef("HashMap<String,Path>"))
			field.visibility = JvmVisibility::PRIVATE
			field.static = true
			type.members += field			
		}
	}
	
	def void toBinderOperations(JvmGenericType type, SignalDefinition signal) {
		// getter sor services		
		type.members += signal.toMethod("getDataInterchange", _typeReferenceBuilder.typeRef(IDataInterchange), [
			visibility = JvmVisibility.PUBLIC
			static = true
			body = [append('''return dataInterchange;''')]
		])
		type.members += signal.toMethod("getBlobService", _typeReferenceBuilder.typeRef(IBlobService), [
			visibility = JvmVisibility.PUBLIC
			static = true
			body = [append('''return blobService;''')]
		])
		type.members += signal.toMethod("getEventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher), [
			visibility = JvmVisibility.PUBLIC
			static = true
			body = [append('''return eventDispatcher;''')]
		])
		type.members += signal.toMethod("getPersistenceService", _typeReferenceBuilder.typeRef(IPersistenceService), [
			visibility = JvmVisibility.PUBLIC
			static = true
			body = [append('''return persistenceService;''')]
		])
		// bind datainterchange service
		type.members += signal.toMethod("bindDataInterchangeMethod", _typeReferenceBuilder.typeRef(Void::TYPE), [
			var annotationRef = _annotationTypesBuilder.annotationRef(typeof(Reference))
			annotationRef.addAnnAttr(signal, "cardinality", ReferenceCardinality.MANDATORY)
			annotationRef.addAnnAttr(signal, "policy", ReferencePolicy.STATIC)
			annotations += annotationRef
			visibility = JvmVisibility.PUBLIC
			synchronized = true
			parameters += signal.toParameter("dataInterchange", _typeReferenceBuilder.typeRef(IDataInterchange))
			body = [
				append('''
				this.dataInterchange = dataInterchange;
				«if(signal instanceof SignalWatcher){
				'''log.info("«signal.name.toFirstUpper + "Watcher"» - DataInterchange bound");'''
				}else if (signal instanceof SignalScheduler){
				'''log.info("«signal.name.toFirstUpper + "Scheduler"» - DataInterchange bound");'''
				}»''')
			]
		])
		// unbind datainterchange service
		type.members += signal.toMethod("unbindDataInterchangeMethod", _typeReferenceBuilder.typeRef(Void::TYPE), [
			visibility = JvmVisibility.PUBLIC
			synchronized = true
			parameters += signal.toParameter("dataInterchange", _typeReferenceBuilder.typeRef(IDataInterchange))
			body = [
				append(
				'''
				this.dataInterchange = null;
				«if(signal instanceof SignalWatcher){
				'''log.info("«signal.name.toFirstUpper + "Watcher"» - DataInterchange unbound");'''
				}else if (signal instanceof SignalScheduler){
				'''log.info("«signal.name.toFirstUpper + "Scheduler"» - DataInterchange unbound");'''
				}»
				''')
			]
		])
		// bind blob service
		type.members += signal.toMethod("bindBlobMethod", _typeReferenceBuilder.typeRef(Void::TYPE), [
			var annotationRef = _annotationTypesBuilder.annotationRef(typeof(Reference))
			annotationRef.addAnnAttr(signal, "cardinality", ReferenceCardinality.MANDATORY)
			annotationRef.addAnnAttr(signal, "policy", ReferencePolicy.STATIC)
			annotations += annotationRef
			visibility = JvmVisibility.PUBLIC
			synchronized = true
			parameters += signal.toParameter("blobService", _typeReferenceBuilder.typeRef(IBlobService))
			body = [
				append(
				'''
				this.blobService = blobService;
				«if(signal instanceof SignalWatcher){
				'''log.info("«signal.name.toFirstUpper + "Watcher"» - BlobService bound");'''
				}else if (signal instanceof SignalScheduler){
				'''log.info("«signal.name.toFirstUpper + "Scheduler"» - BlobService bound");'''
				}»
				''')
			]
		])
		// unbind blob service
		type.members += signal.toMethod("unbindBlobMethod", _typeReferenceBuilder.typeRef(Void::TYPE), [
			visibility = JvmVisibility.PUBLIC
			synchronized = true
			parameters += signal.toParameter("blobService", _typeReferenceBuilder.typeRef(IBlobService))
			body = [
				append(
				'''
				this.blobService = null;
				«if(signal instanceof SignalWatcher){
				'''log.info("«signal.name.toFirstUpper + "Watcher"» - BlobService unbound");'''
				}else if (signal instanceof SignalScheduler){
				'''log.info("«signal.name.toFirstUpper + "Scheduler"» - BlobService unbound");'''
				}»
				''')
			]
		])
		// bind eventDispatcher service
		type.members += signal.toMethod("bindEventDispatcher", _typeReferenceBuilder.typeRef(Void::TYPE), [
			var annotationRef = _annotationTypesBuilder.annotationRef(typeof(Reference))
			annotationRef.addAnnAttr(signal, "cardinality", ReferenceCardinality.MANDATORY)
			annotationRef.addAnnAttr(signal, "policy", ReferencePolicy.STATIC)
			annotations += annotationRef
			visibility = JvmVisibility.PUBLIC
			synchronized = true
			parameters += signal.toParameter("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher))
			body = [
				append(
				'''
				this.eventDispatcher = eventDispatcher;
				«if(signal instanceof SignalWatcher){
				'''log.info("«signal.name.toFirstUpper + "Watcher"» - EventDispatcher bound");'''
				}else if (signal instanceof SignalScheduler){
				'''log.info("«signal.name.toFirstUpper + "Scheduler"» - EventDispatcher bound");'''
				}»
				''')
			]
		])
		// unbind eventDispatcher service
		type.members += signal.toMethod("unbindEventDispatcher", _typeReferenceBuilder.typeRef(Void::TYPE), [
			visibility = JvmVisibility.PUBLIC
			synchronized = true
			parameters += signal.toParameter("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher))
			body = [
				append(
				'''
				this.eventDispatcher = null;
				«if(signal instanceof SignalWatcher){
				'''log.info("«signal.name.toFirstUpper + "Watcher"» - EventDispatcher unbound");'''
				}else if (signal instanceof SignalScheduler){
				'''log.info("«signal.name.toFirstUpper + "Scheduler"» - EventDispatcher unbound");'''
				}»
				''')
			]
		])
		// bind persistence service
		type.members += signal.toMethod("bindPersistenceMethod", _typeReferenceBuilder.typeRef(Void::TYPE), [
			var annotationRef = _annotationTypesBuilder.annotationRef(typeof(Reference))
			annotationRef.addAnnAttr(signal, "cardinality", ReferenceCardinality.MANDATORY)
			annotationRef.addAnnAttr(signal, "policy", ReferencePolicy.STATIC)
			annotations += annotationRef
			visibility = JvmVisibility.PUBLIC
			synchronized = true
			parameters += signal.toParameter("persistenceService", _typeReferenceBuilder.typeRef(IPersistenceService))
			body = [
				append(
				'''
				this.persistenceService = persistenceService;
				«if(signal instanceof SignalWatcher){
				'''log.info("«signal.name.toFirstUpper + "Watcher"» - PersistenceService bound");'''
				}else if (signal instanceof SignalScheduler){
				'''log.info("«signal.name.toFirstUpper + "Scheduler"» - PersistenceService bound");'''
				}»
				''')
			]
		])
		// unbind persistence service
		type.members += signal.toMethod("unbindPersistenceMethod", _typeReferenceBuilder.typeRef(Void::TYPE), [
			visibility = JvmVisibility.PUBLIC
			synchronized = true
			parameters += signal.toParameter("persistenceService", _typeReferenceBuilder.typeRef(IPersistenceService))
			body = [
				append(
				'''
				this.persistenceService = null;
				«if(signal instanceof SignalWatcher){
				'''log.info("«signal.name.toFirstUpper + "Watcher"» - PersistenceService unbound");'''
				}else if (signal instanceof SignalScheduler){
				'''log.info("«signal.name.toFirstUpper + "Scheduler"» - PersistenceService unbound");'''
				}»
				''')
			]
		])
	}

	def void toOperations(JvmGenericType type, SignalDefinition signal) {
		if(signal instanceof SignalWatcher){
			// creating the register operation, detailing the order 
			// of execution of each operation after a signal is caught
			type.members += signal.toMethod("handleEvent", _typeReferenceBuilder.typeRef(Void::TYPE), [
				annotations += _annotationTypesBuilder.annotationRef(Override)
				parameters += signal.toParameter("file", _typeReferenceBuilder.typeRef(Path))
				body = [append('''«signal.handleEvent»''')]
			])
			
			// create watcher executeWatcherService
			type.members += signal.toMethod("executeWatcherService", _typeReferenceBuilder.typeRef(Void::TYPE), [
				body = [append('''«signal.executeService»''')]
			])
		}
		if(signal instanceof SignalScheduler){
			// create startScheduler operation
			type.members += signal.toMethod("startScheduler", _typeReferenceBuilder.typeRef(Void::TYPE), [
					documentation = 
					'''
					Starts the {@link #scheduler}.'''
					exceptions += _typeReferenceBuilder.typeRef(SchedulerException)
					body = [append('''«signal.startScheduler»''')]
			])
			// create shutdownScheduler operation
			type.members += signal.toMethod("shutdownScheduler", _typeReferenceBuilder.typeRef(Void::TYPE), [
					documentation = 
					'''
					Halts the Scheduler's firing of Triggers, and cleans up all resources associated with the Scheduler.
					@param waitForJobsToComplete whether or not the scheduler shuts down immediately or wait for jobs to finish.
					@throws SchedulerException'''
					exceptions += _typeReferenceBuilder.typeRef(SchedulerException)
					parameters += signal.toParameter("waitForJobsToComplete", _typeReferenceBuilder.typeRef(boolean))
					body = [append('''«signal.shutdownScheduler»''')]
			])
			// create scheduleJob operation
			type.members += signal.toMethod("scheduleJob", _typeReferenceBuilder.typeRef(Date), [
					documentation = 
					'''
					Schedules a given job based on a given trigger.
					@param job the {@link JobDetail} to be scheduled
					@param trigger the corresponding trigger
					@return'''
					exceptions += _typeReferenceBuilder.typeRef(SchedulerException)
					parameters += signal.toParameter("job", _typeReferenceBuilder.typeRef(JobDetail))
					parameters += signal.toParameter("trigger", _typeReferenceBuilder.typeRef(Trigger))
					body = [append('''«signal.scheduleJob»''')]
			])
			// create watcher scheduleAllJobs
			type.members += signal.toMethod("scheduleAllJobs", _typeReferenceBuilder.typeRef(Void::TYPE), [
				exceptions += _typeReferenceBuilder.typeRef(SchedulerException)
				body = [append('''«signal.scheduleAllJobs»''')]
			])
			// create watcher executeSchedulerService
			type.members += signal.toMethod("executeSchedulerService", _typeReferenceBuilder.typeRef(Void::TYPE), [
				body = [append('''«signal.executeService»''')]
			])
			// create job execute method
			type.members += signal.toMethod("execute", _typeReferenceBuilder.typeRef(Void::TYPE), [
				exceptions += _typeReferenceBuilder.typeRef(JobExecutionException)
				annotations += _annotationTypesBuilder.annotationRef(Override)
				parameters += signal.toParameter("context", _typeReferenceBuilder.typeRef(JobExecutionContext))
				documentation = "Executes the list of tasks as job's logic."
				body = [
					append(
					'''
					new «signal.name.toFirstUpper»SchedulerJob(persistenceService, dataInterchange, blobService, eventDispatcher, 
					"«signal.fullyQualifiedName»Scheduler").executeListOfTasks();''')]
			])
		}
		// creating the getHandlerPropertyFromConfigurationFile operation
		type.members += signal.toMethod("getHandlerPropertyFromConfigurationFile", _typeReferenceBuilder.typeRef(String), [
			documentation = "Gives the property value of the given property name if existing."
			parameters += signal.toParameter("propertyname", _typeReferenceBuilder.typeRef(String))
			body = [append('''«signal.handlerPropertyFromConfigurationFile»''')]
		])
		// create watcher activate
		type.members += signal.toMethod("activate", _typeReferenceBuilder.typeRef(Void::TYPE), [
			annotations += _annotationTypesBuilder.annotationRef(Activate)
			body = [append('''«signal.activate»''')]
		])
		// create watcher deactivate
		type.members += signal.toMethod("deactivate", _typeReferenceBuilder.typeRef(Void::TYPE), [
			annotations += _annotationTypesBuilder.annotationRef(Deactivate)
			body = [append('''«signal.deactivate»''')]
		])
	}
	
	def String scheduleJob(SignalScheduler scheduler){
		return
		'''
		try {
			return scheduler.scheduleJob(job, trigger);
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		return null;'''
	}
	
	def String shutdownScheduler(SignalScheduler scheduler){
		return
		'''
		log.info("Shutdowns "+scheduler.getSchedulerName()+" ...");
		scheduler.shutdown(waitForJobsToComplete);'''
	}
	
	def String startScheduler(SignalScheduler scheduler){
		return
		'''
		scheduler.start();
		log.info(scheduler.getSchedulerName() + " service successfully started!");'''
	}
		
	def String handleEvent(SignalWatcher watcher) {
		if(watcher !== null) {
			return 
			'''
			«if(watcher.hasFileMask){
			'''
			String maskcfg = getFilemaskValue(getHandlerPropertyFromConfigurationFile("«watcher.fullyQualifiedName»Watcher" + SignalConstants.FILEMASK));
			String modelfilemask = "«watcher.identifier»";
			if(isFileMaskValid(maskcfg) && isFileMaskValidWithExpectedFileExtension(maskcfg, "«watcher.baseInterchange.fileEndpoint.getValidExtensionToInterchange»")){
				modelfilemask = maskcfg;
			   	log.info("«watcher.name»Watcher - The file mask used for file identification is ["+maskcfg+"].");
			}else{
			   	log.info("«watcher.name»Watcher - The default file mask [«watcher.identifier»] is used for file identification.");
			}
			if(isFileNameValidToFileMask(file.getFileName().toString(), modelfilemask)){
				addWatcherJob(new «watcher.name.toFirstUpper»WatcherJob(persistenceService, dataInterchange, blobService, eventDispatcher, file, "«watcher.fullyQualifiedName»Watcher"));
			}'''
			}
			else{
			'''
			String namecfg = getFilemaskValue(getHandlerPropertyFromConfigurationFile("«watcher.fullyQualifiedName»Watcher" + SignalConstants.FILENAME));
			String filemask = namecfg != null ? namecfg : "«watcher.identifier»";
			if(isFileNameValidToBaseFileName(file.getFileName().toString(), filemask)){
				addWatcherJob(new «watcher.name.toFirstUpper»WatcherJob(persistenceService, dataInterchange, blobService, eventDispatcher, file, "«watcher.fullyQualifiedName»Watcher"));
			}'''
			}
			»
			else{
				log.info("«watcher.name.toFirstUpper»Watcher - No action planed for file ["+file+"].");
			}'''
		}
		return ''''''
	}

	def void toConstructor(JvmGenericType type, SignalDefinition signal) {
		type.members += signal.toConstructor [
			if(signal instanceof SignalWatcher){
				exceptions += _typeReferenceBuilder.typeRef(Exception)
				body = [append('''super("«signal.name.toFirstUpper + "Watcher"»");''')]				
			}
		]
	}
	
	def String executeWatcherTasksList(SignalWatcher watcher) {
		return 
		'''
		«if(watcher !== null) {
			var operationList = ""
			var functionWithFile = watcher.hasFunctionWithFile
			for (task : watcher.tasks) {
				operationList = operationList + getTaskListOperationName(task, functionWithFile)
			}
			
			if(watcher.executiontype.equals(SignalExecutionTypeEnum.SEQ)){
				'''
				log.info("WatcherJobsHandler - START - Sequential execution of «watcher.name.toFirstUpper»WatcherJob ...");
				try {
					«operationList»
					deleteFile(getTriggerfile(), "«watcher.name.toFirstUpper»WatcherJob - Triggerfile");
				} catch(Exception e){
					log.error("WatcherJobsHandler - ERROR during sequential execution of «watcher.name.toFirstUpper»WatcherJob!", e);
				}
				setDone(true);  // for the WatcherhandlerJob to continue 
				log.info("WatcherJobsHandler - END - Sequential execution of «watcher.name.toFirstUpper»WatcherJob ...");'''
			}
			else{
				'''
				log.info("WatcherJobsHandler - START - Parallel execution of «watcher.name.toFirstUpper»WatcherJob ...");
				try {					«operationList»
					finalizeTaskExecution("«watcher.name.toFirstUpper»WatcherJob");
				} catch(Exception e){
					log.error("WatcherJobsHandler - ERROR during parallel execution of «watcher.name.toFirstUpper»WatcherJob!", e);
					setDone(true); // for the WatcherhandlerJob to continue
					log.info("WatcherJobsHandler - END - Parallel execution of «watcher.name.toFirstUpper»WatcherJob ...");
				}'''
			}
		}»
		'''
	}

	def String executeSchedulerTasksList(SignalScheduler scheduler) {
		return 
		'''
		«if(scheduler !== null){
			var operationList = ""
			var functionWithFile = scheduler.hasFunctionWithFile
			for (task : scheduler.tasks) {
				operationList = operationList + getTaskListOperationName(task, functionWithFile)
			}

			if(scheduler.executiontype.equals(SignalExecutionTypeEnum.SEQ)){
				'''
				log.info("START - Sequential execution of «scheduler.name.toFirstUpper»SchedulerJob ...");
				try {
					«operationList»
				} catch(Exception e){
					log.error("ERROR during sequential execution of «scheduler.name.toFirstUpper»SchedulerJob!", e);
				}
				log.info("END - Sequential execution of «scheduler.name.toFirstUpper»SchedulerJob.");'''
			}
			else{
				'''
				log.info("START - Parallel execution of «scheduler.name.toFirstUpper»SchedulerJob ...");
				try {
					«operationList»
					finalizeTaskExecution("«scheduler.name.toFirstUpper»SchedulerJob");
				} catch(Exception e){
					log.error("ERROR during parallel execution of «scheduler.name.toFirstUpper»SchedulerJob!", e);
				log.info("END - Parallel execution of «scheduler.name.toFirstUpper»SchedulerJob.");
				}'''
			}
		}»
		'''
	}
	
	
	def getTaskListOperationName(SignalTask task, boolean existFunctionWithFile){
		if(task instanceof SignalFunction){
			if(task !== null && task.doExecuteFunction !== null ) {
				if((task.onExportFile || task.onImportFile) && !task.doExecuteFunction.params.empty){
					var operationName = ""
					if(task.onExportFile){
						operationName = "export" + task.supportInterchange.name.toFirstUpper
					}
					else if(task.onImportFile){
						operationName = "import" + task.supportInterchange.name.toFirstUpper
					}
					return 
					'''«(task.group.eContainer as FunctionLibraryPackage).fullyQualifiedName».«task.group.name.toString.toFirstUpper».«task.doExecuteFunction.name.toString»(paths.get("«operationName»"));
					'''
				}
				else if(!task.onExportFile && !task.onImportFile){
					return 
					'''«(task.group.eContainer as FunctionLibraryPackage).fullyQualifiedName».«task.group.name.toString.toFirstUpper».«task.doExecuteFunction.name.toString»();
					'''
				}
			}
		}
		else{
			return 
			'''«IF existFunctionWithFile» paths.put("«task.getAppropriateTaskOperationName»", «task.getAppropriateTaskOperationName»()); «ELSE»«task.getAppropriateTaskOperationName»(); «ENDIF»
			'''
		}
	}
	
	/**
	 * Returns the operation name of the given task.
	 */
	def String getAppropriateTaskOperationName(SignalTask task) {
		var operation_name = ""
		if(task instanceof SignalDatainterchange){
			if (task.getActionType == SignalActionTypeEnum.DATAIMPORT && task.dataRef !== null) {
				operation_name = "import" + task.dataRef.name.toFirstUpper
			} else if (task.dataRef !== null) {
				operation_name = "export" + task.dataRef.name.toFirstUpper
			}
		}
		return operation_name
	}
	
	/**
	 * Creates the content of each task operation for scheduler and watcher jobs task files.
	 */
	def createTaskOperations(JvmGenericType type, SignalDefinition signal) {
		for(task : signal.tasks){
			var operationname = task.getAppropriateTaskOperationName
			// create the operation only if it has not already been created 
			if (!operationlist.contains(operationname)) {
				if(task instanceof SignalDatainterchange){			
					if(signal instanceof SignalWatcher){
						watcherInterchangeOperation(type, signal, task, operationname)
					}
					else if(signal instanceof SignalScheduler){
						schedulerInterchangeOperation(type, signal, task, operationname)
					}
				}
				operationlist.add(operationname)
			}
		}
	}
	
	def schedulerInterchangeOperation(JvmGenericType type, SignalScheduler signal, SignalDatainterchange interchange, String operationname){
		if (interchange.getActionType == SignalActionTypeEnum.DATAIMPORT) {
				type.members += signal.toMethod(operationname, _typeReferenceBuilder.typeRef(Path), [
					exceptions += _typeReferenceBuilder.typeRef(Exception)
					body = [append(
						'''
						«getConfigFileURL((interchange.dataRef.eContainer as DataInterchangeGroup).name)»
						«interchange.dataRef.getBasicRunConfiguration(true, WorkerThreadRunnable.Direction.IMPORT.name, null)»
						«interchange.dataRef.defaultVariableName».setDirection(WorkerThreadRunnable.Direction.IMPORT);
						try {
							«if((signal as SignalScheduler).executiontype.equals(SignalExecutionTypeEnum.SEQ)){
								'''«signal.name.toFirstUpper + "Scheduler"».getExecutorService().submit(«interchange.dataRef.defaultVariableName»).get();'''
							}else{
								'''«signal.name.toFirstUpper + "Scheduler"».getExecutorService().execute(«interchange.dataRef.defaultVariableName»);'''
							}»
						}catch (Exception e) {
							log.error("Execution - " + «interchange.dataRef.defaultVariableName».getDirection() + " for " + «interchange.dataRef.defaultVariableName».getName() + " interupted!\n" + e.getMessage());
							«if (interchange.getActionType == SignalActionTypeEnum.DATAIMPORT) {	
								'''
								«IF interchange.dataRef.isDeleteFileAfterImport»
								renameFile(Paths.get(«interchange.dataRef.defaultVariableName».getFileURL().toString()), "«signal.name.toFirstUpper»SchedulerJob");
								«ENDIF»
								'''
							}»
						}
						return Paths.get(«interchange.dataRef.defaultVariableName».getFileURL().getPath().substring(1));
						''')]
				])
			} else {
				type.members += signal.toMethod(operationname, _typeReferenceBuilder.typeRef(Path), [
					body = [
						append(
						'''
						«getConfigFileURL((interchange.dataRef.eContainer as DataInterchangeGroup).name)»
						«interchange.dataRef.getBasicRunConfiguration(true, WorkerThreadRunnable.Direction.EXPORT.name, null)»
						«interchange.dataRef.defaultVariableName».setDirection(WorkerThreadRunnable.Direction.EXPORT);
						try {
							«if((signal as SignalScheduler).executiontype.equals(SignalExecutionTypeEnum.SEQ)){
								'''«signal.name.toFirstUpper + "Scheduler"».getExecutorService().submit(«interchange.dataRef.defaultVariableName»).get();'''
							}else{
								'''«signal.name.toFirstUpper + "Scheduler"».getExecutorService().execute(«interchange.dataRef.defaultVariableName»);'''
							}»
						}catch (Exception e) {
							log.error("Execution - " + «interchange.dataRef.defaultVariableName».getDirection() + " for " + «interchange.dataRef.defaultVariableName».getName() + " interupted!\n" + e.getMessage());
						}
						return «interchange.dataRef.defaultVariableName».getExportPath();
						'''
					)]
				])
			}
	}
	
	def watcherInterchangeOperation(JvmGenericType type, SignalWatcher watcher, SignalDatainterchange interchange, String operationname){
		if(watcher.executiontype.equals(SignalExecutionTypeEnum.SEQ)){
				type.members += watcher.toMethod(operationname, _typeReferenceBuilder.typeRef(Path), [
					exceptions += _typeReferenceBuilder.typeRef(Exception)
					body = [
						append(
							'''
							«if (interchange.getActionType == SignalActionTypeEnum.DATAIMPORT) {
								'''
								«interchange.dataRef.getBasicRunConfiguration(true, WorkerThreadRunnable.Direction.IMPORT.name, watcher.baseInterchange)»
								«interchange.dataRef.defaultVariableName».setDirection(WorkerThreadRunnable.Direction.IMPORT);
								'''
							} else {
								'''
								«getConfigFileURL((interchange.dataRef.eContainer as DataInterchangeGroup).name)»
								«interchange.dataRef.getBasicRunConfiguration(true, WorkerThreadRunnable.Direction.EXPORT.name, watcher.baseInterchange)»
								«interchange.dataRef.defaultVariableName».setDirection(WorkerThreadRunnable.Direction.EXPORT);
								'''
							}»
							«if(interchange == watcher.baseInterchange){ // for the (trigger)interchange marked with the keyword 'applyon'
								'''
								URI uri = getTriggerfile().toUri();
								«interchange.dataRef.defaultVariableName».setFileURL(uri.toString());
								'''
							}else{
								'''«interchange.dataRef.defaultVariableName».setFileURL(getTriggerfile().getParent().toString() + File.separator + "«interchange.dataRef.getDataInterchangeFileName»");'''
							}»
							try{
								WatcherImpl.getExecutorService().submit(«interchange.dataRef.defaultVariableName»).get();
							}catch (Exception e) {
								log.error("Execution - " + «interchange.dataRef.defaultVariableName».getDirection() + " for " + «interchange.dataRef.defaultVariableName».getName() + " interupted!\n" + e.getMessage());
								«interchange.dataRef.defaultVariableName».setExecutionDone(true);
								«if (interchange.getActionType == SignalActionTypeEnum.DATAIMPORT) {	
									if(interchange.dataRef == watcher.baseInterchange && interchange.dataRef.deleteFileAfterImport){
									'''renameFile(getTriggerfile(), "«watcher.name.toFirstUpper»WatcherJob");'''
									}
									else if(interchange.dataRef.deleteFileAfterImport){									
									'''renameFile(Paths.get(«interchange.dataRef.defaultVariableName».getFileURL().toString()), "«watcher.name.toFirstUpper»WatcherJob");'''
									}
								}»
							}
							«if (interchange.getActionType == SignalActionTypeEnum.DATAIMPORT) {
							'''return Paths.get(«interchange.dataRef.defaultVariableName».getFileURL().getPath().substring(1));'''								
							}
							else{
								'''return «interchange.dataRef.defaultVariableName».getExportPath();'''
							}»
							''')
					]
				])
			}
			else{
				type.members += watcher.toMethod(operationname, _typeReferenceBuilder.typeRef(Path), [
					exceptions += _typeReferenceBuilder.typeRef(Exception)
					body = [
						append(
							'''
							«if (interchange.getActionType == SignalActionTypeEnum.DATAIMPORT) {
								'''
								«interchange.dataRef.getBasicRunConfiguration(true, WorkerThreadRunnable.Direction.IMPORT.name, watcher.baseInterchange)»
								«interchange.dataRef.defaultVariableName».setDirection(WorkerThreadRunnable.Direction.IMPORT);
								'''
							} else {
								'''
								«getConfigFileURL((interchange.dataRef.eContainer as DataInterchangeGroup).name)»
								«interchange.dataRef.getBasicRunConfiguration(true, WorkerThreadRunnable.Direction.EXPORT.name, watcher.baseInterchange)»
								«interchange.dataRef.defaultVariableName».setDirection(WorkerThreadRunnable.Direction.EXPORT);
								'''
							}»
							«if(interchange == watcher.baseInterchange){
								'''
								URI uri = getTriggerfile().toUri();
								«interchange.dataRef.defaultVariableName».setFileURL(uri.toString());'''
							}else{
								'''«interchange.dataRef.defaultVariableName».setFileURL(getTriggerfile().getParent().toString() + File.separator + "«interchange.dataRef.getDataInterchangeFileName»");'''
							}»
							checkForCompletion(«interchange.dataRef.defaultVariableName»);
							try{
								WatcherImpl.getExecutorService().execute(«interchange.dataRef.defaultVariableName»);
							}catch (Exception e) {
								log.error("Execution - " + «interchange.dataRef.defaultVariableName».getDirection() + " for " + «interchange.dataRef.defaultVariableName».getName() + " interupted!\n" + e.getMessage());
								«interchange.dataRef.defaultVariableName».setExecutionDone(true);
								«if (interchange.getActionType == SignalActionTypeEnum.DATAIMPORT) {	
									if(interchange.dataRef == watcher.baseInterchange && interchange.dataRef.deleteFileAfterImport){
									'''renameFile(getTriggerfile(), "«watcher.name.toFirstUpper»WatcherJob");'''
									}
									else if(interchange.dataRef.deleteFileAfterImport){										
									'''renameFile(Paths.get(«interchange.dataRef.defaultVariableName».getFileURL().toString()), "«watcher.name.toFirstUpper»WatcherJob");'''
									}								
								}»
							}
							«if (interchange.getActionType == SignalActionTypeEnum.DATAIMPORT) {
								'''return Paths.get(«interchange.dataRef.defaultVariableName».getFileURL().getPath().substring(1));'''								
							}
							else{
								'''return «interchange.dataRef.defaultVariableName».getExportPath();'''
							}»
							''')
					]
				])
			}
	}
	
	/**
	 * Creates the fields for all watcher and scheduler files. 
	 */
	def void toFields(JvmGenericType type, SignalDefinition signal) {
		var JvmField field = null
		// create thread field
		field = signal.toField("thread", _typeReferenceBuilder.typeRef(Thread)) [
			visibility = JvmVisibility::PRIVATE
		]
		type.members += field
		// create persistence service field
		field = signal.toField("persistenceService", _typeReferenceBuilder.typeRef(IPersistenceService))
		field.static = true
		field.visibility = JvmVisibility::PRIVATE
		type.members += field
		// create datainterchange service field
		field = signal.toField("dataInterchange", _typeReferenceBuilder.typeRef(IDataInterchange))
		field.static = true
		field.visibility = JvmVisibility::PRIVATE
		type.members += field
		// create blob service field		
		field = signal.toField("blobService", _typeReferenceBuilder.typeRef(IBlobService))
		field.static = true
		field.visibility = JvmVisibility::PRIVATE
		type.members += field
		// create event dispatcher service field		
		field = signal.toField("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher))
		field.static = true
		field.visibility = JvmVisibility::PRIVATE
		type.members += field

		if(signal instanceof SignalScheduler){
			// create executor service dispatcher service field		
			field = signal.toField("scheduler", _typeReferenceBuilder.typeRef(Scheduler))
			field.documentation = '''the scheduler instance'''
			field.static = true
			field.visibility = JvmVisibility::PRIVATE
			type.members += field
		}
	}

	def String getActivate(SignalDefinition signal) {
		var signalName = ""
		if(signal instanceof SignalWatcher){
			signalName = signal.name.toFirstUpper + "Watcher"
		}else if(signal instanceof SignalScheduler){
			signalName = signal.name.toFirstUpper + "Scheduler"
		}
		return 
		'''
		thread = new Thread("«signalName»") {
			
			@Override
			public void run() {
				«if(signal instanceof SignalWatcher){
				 	'''
					setMaxParallelThreadsCount(getHandlerPropertyFromConfigurationFile(SignalConstants.MAXPARALLELTHREADCOUNT_NAME));
					initMaxThreadCount();
					startWatcherJobsHandling();
					executeWatcherService();
				 	'''
				}
				else if(signal instanceof SignalScheduler){
					'''
					setMaxParallelThreadsCount(getHandlerPropertyFromConfigurationFile(SignalConstants.MAXPARALLELTHREADCOUNT_NAME));
					initMaxThreadCount();
					setExecutorService("«signalName»");
					executeSchedulerService();
					'''
				}»
				}
			};
		thread.start();'''
	}

	def String getExecuteService(SignalDefinition signal) {
		var signalName = ""
		if(signal instanceof SignalWatcher){
			signalName = signal.name.toFirstUpper + "Watcher"
		}else if(signal instanceof SignalScheduler){
			signalName = signal.name.toFirstUpper + "Scheduler"
		}
		return 
		'''
		«if(signal instanceof SignalWatcher){
		'''
		try {
			«signal.registerHandlerPathToWatch»
			log.info("«signalName» service successfully started.");
			processEvents();
		} catch (Exception e) {
			log.error("«signalName» service interrupted due to: ", e);
		}'''
		}
		else if(signal instanceof SignalScheduler){
		'''
		try {
			scheduler = createScheduler("«signalName»");
			scheduleAllJobs();
			startScheduler();
		} catch (Exception e) {
			log.error("«signalName» service interrupted due to: ", e);
		}'''}»'''
	}

	def String getDeactivate(SignalDefinition signal) {
		var signalName = ""
		if(signal instanceof SignalWatcher){
			signalName = signal.name.toFirstUpper + "Watcher"
		}else if(signal instanceof SignalScheduler){
			signalName = signal.name.toFirstUpper + "Scheduler"
		}
		return 
		'''
		«if(signal instanceof SignalScheduler){
		'''
		try {
			if(scheduler != null){
				shutdownScheduler(false);
			}
			thread.join();
		} catch (Exception e) {
			log.error("«signalName» service shortly interrupted ...", e);
		}
		log.info("«signalName» service shutted down...");
		'''
		}else{
		'''
		try {
			closeWatcher();
			stopWatcherJobsHandling();
			thread.join();
		} catch (Exception e) {
			log.error("«signalName» service shortly interrupted ...", e);
		}
		log.info("«signalName» service shutted down...");
		'''
		}»
		'''
	}

	def String scheduleAllJobs(SignalScheduler scheduler) {
		var signalName = scheduler.name.toFirstUpper + "Scheduler"
		var index = 1
		var result = '''
			log.info("«signalName» - Starting scheduling all jobs ...");
			Trigger trigger; JobDetail job; Date ft; String expr; int hour; int min; int dOw; int dOm; String key;String keyOne;String keyTwo;
		'''
		if (scheduler.getSchedulertype instanceof CronScheduler) {
			var type = scheduler.getSchedulertype as CronScheduler
			if (type !== null && type.expression !== null && !type.expression.empty) {
				result = result.concat('''
					job = createDataTransferJob("«scheduler.fullyQualifiedName»SchedulerJob«index»", "jobs", "-", «scheduler.executiontype.equals(SignalExecutionTypeEnum.SEQ)», "«scheduler.fullyQualifiedName»", «signalName».class);
					key = "«scheduler.fullyQualifiedName»Scheduler" + SignalConstants.CRON_SCHEDULER;
					expr = getCronExpressionValue(getHandlerPropertyFromConfigurationFile(key));
					trigger = createCronTrigger("«scheduler.fullyQualifiedName»SchedulerTrigger«index»", "triggers", expr != null ? expr : "«type.expression»");
					ft = scheduleJob(job, trigger);
					log.info("«scheduler.name.toFirstUpper»SchedulerJob«index» has been scheduled to run at: " + ft);
				''')
			}
		} else if (scheduler.getSchedulertype instanceof HourlyScheduler) {
			var type = scheduler.getSchedulertype as HourlyScheduler
			if (type !== null && type.minute > -1) {
				result = result.concat('''
					job = createDataTransferJob("«scheduler.fullyQualifiedName»SchedulerJob«index»", "jobs", "-", «scheduler.executiontype.equals(SignalExecutionTypeEnum.SEQ)», "«scheduler.fullyQualifiedName»", «signalName».class);
					key = "«scheduler.fullyQualifiedName»Scheduler" + SignalConstants.HOURLY_SCHEDULER;
					min = getMinutesValue(getHandlerPropertyFromConfigurationFile(key));
					trigger = createHourlyTrigger("«scheduler.fullyQualifiedName»SchedulerTrigger«index»", "triggers", min>=0? min : «type.minute»);
					ft = scheduleJob(job, trigger);
					log.info("«scheduler.name.toFirstUpper»SchedulerJob«index» has been scheduled to run at: " + ft);
				''')
			}
		} else if (scheduler.getSchedulertype instanceof DailyScheduler) {
			var type = scheduler.getSchedulertype as DailyScheduler

			if (type !== null && type.hour > -1 && type.minute > -1) {
				result = result.concat('''
					job = createDataTransferJob("«scheduler.fullyQualifiedName»SchedulerJob«index»", "jobs", "-", «scheduler.executiontype.equals(SignalExecutionTypeEnum.SEQ)», "«scheduler.fullyQualifiedName»", «signalName».class);
					key = "«scheduler.fullyQualifiedName»Scheduler" + SignalConstants.DAILY_SCHEDULER_HOUR;
					hour = getHourValue(getHandlerPropertyFromConfigurationFile(key));
					keyOne = "«scheduler.fullyQualifiedName»Scheduler" + SignalConstants.DAILY_SCHEDULER_MIN;
					min = getMinutesValue(getHandlerPropertyFromConfigurationFile(keyOne));
					trigger = createDailyTriggerAtHourandMins("«scheduler.fullyQualifiedName»SchedulerTrigger«index»", "triggers", hour>=0 ? hour : «type.hour», min>=0 ? min : «type.minute»);
					ft = scheduleJob(job, trigger);
					log.info("«scheduler.name.toFirstUpper»SchedulerJob«index» has been scheduled to run at: " + ft);
				''')
			}
		} else if (scheduler.getSchedulertype instanceof WeeklyScheduler) {
			var type = scheduler.getSchedulertype as WeeklyScheduler
			if (type !== null && type.dayofweek !== null && type.hour > -1 &&
				type.minute > -1) {
				result = result.concat('''
					job = createDataTransferJob("«scheduler.fullyQualifiedName»SchedulerJob«index»", "jobs", "-", «scheduler.executiontype.equals(SignalExecutionTypeEnum.SEQ)», "«scheduler.fullyQualifiedName»", «signalName».class);
					key = "«scheduler.fullyQualifiedName»Scheduler" + SignalConstants.WEEKLY_SCHEDULER_DAYOFWEEK;
					dOw = getDayOfWeekValue(getHandlerPropertyFromConfigurationFile(key));
					keyOne = "«scheduler.fullyQualifiedName»Scheduler" + SignalConstants.WEEKLY_SCHEDULER_HOUR;
					hour = getHourValue(getHandlerPropertyFromConfigurationFile(keyOne));
					keyTwo = "«scheduler.fullyQualifiedName»Scheduler" + SignalConstants.WEEKLY_SCHEDULER_MIN;
					min = getMinutesValue(getHandlerPropertyFromConfigurationFile(keyTwo));
					trigger = createWeeklyTriggerOnDayAndHourAndMinute("«scheduler.fullyQualifiedName»SchedulerTrigger«index»", "triggers", dOw>0? dOw : «type.dayofweek.ordinal», hour>=0 ? hour : «type.hour», min>=0 ? min : «type.minute»);
					ft = scheduleJob(job, trigger);
					log.info("«scheduler.name.toFirstUpper»SchedulerJob«index» has been scheduled to run at: " + ft);
				''')
			}
		} else if (scheduler.getSchedulertype instanceof MonthlyScheduler) {
			var type = scheduler.getSchedulertype as MonthlyScheduler
			if (type !== null && type.dayofmonth > -1 && type.hour > -1 && type.minute > -1) {
				result = result.concat('''
					job = createDataTransferJob("«scheduler.fullyQualifiedName»SchedulerJob«index»", "jobs", "-", «scheduler.executiontype.equals(SignalExecutionTypeEnum.SEQ)», "«scheduler.fullyQualifiedName»", «signalName».class);
					key = "«scheduler.fullyQualifiedName»Scheduler" + SignalConstants.MONTHLY_SCHEDULER_DAYOFMONTH;
					dOm = getDayOfMonthValue(getHandlerPropertyFromConfigurationFile(key));
					keyOne = "«scheduler.fullyQualifiedName»Scheduler" + SignalConstants.MONTHLY_SCHEDULER_HOUR;
					hour = getHourValue(getHandlerPropertyFromConfigurationFile(keyOne));
					keyTwo = "«scheduler.fullyQualifiedName»Scheduler" + SignalConstants.MONTHLY_SCHEDULER_MIN;
					min = getMinutesValue(getHandlerPropertyFromConfigurationFile(keyTwo));
					trigger = createMonthlyTriggerOnDayAndHourAndMinute("«scheduler.fullyQualifiedName»SchedulerTrigger«index»", "triggers", dOm>0? dOm : «type.dayofmonth», hour>=0 ? hour : «type.hour», min>=0 ? min : «type.minute»);
					ft = scheduleJob(job, trigger);
					log.info("«scheduler.name.toFirstUpper»SchedulerJob«index» has been scheduled to run at: " + ft);
				''')
			}
		}
		index++
		result = result.concat('''log.info("«signalName» - Scheduling all jobs done.");''')
		return result
	}
	
	def String registerHandlerPathToWatch(SignalWatcher signal){
		var result = "";
		var interchange = signal.baseInterchange
		if(interchange !== null){
			var modelurl = interchange.getDataInterchangeDirectoryUrlPath 			
			result = result.concat('''registerUrl(getHandlerPropertyFromConfigurationFile("«interchange.name»-import"),"«modelurl»");
			''')
		}
		return result
	}
	
	/**
	 * Special function to read signal (watcher or scheduler) properties 
	 * from configuration files.
	 */
	def String handlerPropertyFromConfigurationFile(SignalDefinition signal){
		if(signal !== null) {
			var signalName = ""
			if(signal instanceof SignalWatcher){
				signalName = signal.name.toFirstUpper + "Watcher"
			}else if(signal instanceof SignalScheduler){
				signalName = signal.name.toFirstUpper + "Scheduler"
			}
			
			return
			'''
			if (propertyname != null) {
				«getConfigFileURL(signal.interchangegroup.name)»
				File file = new File(url);
				if (file.exists()) {
					try {
						FileInputStream fileInput = new FileInputStream(file);
						Properties properties = new Properties();
						properties.loadFromXML(fileInput);
						fileInput.close();
						String value = properties.getProperty(propertyname);
						if (value != null) {
							if (log.isDebugEnabled()) {
								log.debug("«signalName» - getHandlerPropertyFromConfigurationFile propertyname[" + propertyname
										+ "] -> value [" + value + "]");
							}
							return value;
						}
					} catch (IOException e) {
						StringWriter sw = new StringWriter();
						e.printStackTrace(new PrintWriter(sw));
						log.error("«signalName» - Error during getHandlerPropertyFromConfigurationFile of propertyname: [" + propertyname
								+ "] ... {}", sw.toString());
					}
				}
			}
			if (log.isDebugEnabled()) {
				log.debug("«signalName» - getHandlerPropertyFromConfigurationFile propertyname[" + propertyname + "] -> value [null] because the given path"
				+ " in 'Window->Preferences->OSBP Application Configuration->External Data Sources->DataInterchange Settings' is non-existing or the propertyname is not defined.");
			}
			return null;
			'''
		}
		return '''return "";''' 
	}
	
	def boolean hasSchedulers(SignalPackage pck) {
		if (pck !== null && pck.signals!== null && !pck.signals.isEmpty) {
			for(signal : pck.signals){
				if(signal instanceof SignalScheduler){
					return true
				}
			}
		}
		return false
	}
	
	def boolean hasWatchers(SignalPackage pck) {
		if (pck !== null && pck.signals !== null && !pck.signals.isEmpty) {
			 	for(signal : pck.signals){
				if(signal instanceof SignalScheduler){
					return true
				}
			}
		}
		return false;
	}
	
	def int getSignalCount(SignalPackage pck, boolean isWatcher) {
		if (pck !== null && pck.signals !== null && !pck.signals.isEmpty) {
			var count = 0
			for(signal : pck.signals){
				if(isWatcher &&  (signal instanceof SignalWatcher)){
					count++
				}
				else if(!isWatcher && signal instanceof SignalScheduler){
					count++
				}
			}
			return count
		}
		return -1
	}
	
	def boolean hasFunctionWithFile(SignalDefinition signal){
		if(signal !== null && signal.tasks !== null && !signal.tasks.empty){
			for(task : signal.tasks){
				if(task instanceof SignalFunction){
					if(task.onExportFile || task.onImportFile){
						return true
					}
				}
			}
		}
		return false
	}
	
	/**
	 * Gives back the default interchange unit. 
	 */
	def DataInterchange baseInterchange(SignalDefinition signal){
		if(signal instanceof SignalWatcher) {
			if(signal.defaultInterchange !== null){
				return signal.defaultInterchange
			}
			else if (signal.tasks !== null && !signal.tasks.empty){
				for(task : signal.tasks){
					if(task instanceof SignalDatainterchange){
						if(task.baseinterchange){
							return task.dataRef
						} 				
					}					
				}
			}
		}
		return null
	}
	
	def int definedBaseInterchangeCount(SignalDefinition signal) {
		var count = 0
		for (task : signal.tasks) {
			if(task instanceof SignalDatainterchange){
				if(task.baseinterchange){
					count++
				}
			}
		}
		return count
	}

	def SignalDatainterchange definedBaseInterchange(SignalDefinition signal) {
		for (task : signal.tasks) {
			if(task instanceof SignalDatainterchange){
				if(task.baseinterchange){
					return task
				}
			}
		}
		return null
	}
	
	def int taskCount(SignalDefinition signal, boolean interchange) {
		var count = 0
		for (task : signal.tasks) {
			if(interchange){
				if(task instanceof SignalDatainterchange){
					count++
				}
			}
			else if(task instanceof SignalFunction){
				count++
			}
		}
		return count
	}
}