package dbnp.studycapturing

import org.codehaus.groovy.grails.plugins.web.taglib.JavascriptTagLib
import dbnp.studycapturing.*
import dbnp.data.*

/**
 * Wizard tag library
 *
 * @author Jeroen Wesbeek
 * @since 20100113
 * @package wizard
 *
 * Revision information:
 * $Rev: 349 $
 * $Author: duh $
 * $Date: 2010-04-19 11:05:48 +0000 (ma, 19 apr 2010) $
 */
class WizardTagLib extends JavascriptTagLib {
	// define the tag namespace (e.g.: <wizard:action ... />
	static namespace = "wizard"

	// define the AJAX provider to use
	static ajaxProvider = "jquery"

	// define default text field width
	static defaultTextFieldSize = 25;

	/**
	 * ajaxButton tag, this is a modified version of the default
	 * grails submitToRemote tag to work with grails webflows.
	 * Usage is identical to submitToRemote with the only exception
	 * that a 'name' form element attribute is required. E.g.
	 * <wizard:ajaxButton name="myAction" value="myButton ... />
	 *
	 * you can also provide a javascript function to execute after
	 * success. This behaviour differs from the default 'after'
	 * action which always fires after a button press...
	 *
	 * @see http://blog.osx.eu/2010/01/18/ajaxifying-a-grails-webflow/
	 * @see http://www.grails.org/WebFlow
	 * @see http://www.grails.org/Tag+-+submitToRemote
	 * @todo perhaps some methods should be moved to a more generic
	 *        'webflow' taglib or plugin
	 * @param Map attributes
	 * @param Closure body
	 */
	def ajaxButton = {attrs, body ->
		// get the jQuery version
		def jQueryVersion = grailsApplication.getMetadata()['plugins.jquery']

		// fetch the element name from the attributes
		def elementName = attrs['name'].replaceAll(/ /, "_")

		// javascript function to call after success
		def afterSuccess = attrs['afterSuccess']

		// src parameter?
		def src = attrs['src']
		def alt = attrs['alt']

		// generate a normal submitToRemote button
		def button = submitToRemote(attrs, body)

		/**
		 * as of now (grails 1.2.0 and jQuery 1.3.2.4) the grails webflow does
		 * not properly work with AJAX as the submitToRemote button does not
		 * handle and submit the form properly. In order to support webflows
		 * this method modifies two parts of a 'normal' submitToRemote button:
		 *
		 * 1) replace 'this' with 'this.form' as the 'this' selector in a button
		 *    action refers to the button and / or the action upon that button.
		 *    However, it should point to the form the button is part of as the
		 *    the button should submit the form data.
		 * 2) prepend the button name to the serialized data. The default behaviour
		 *    of submitToRemote is to remove the element name altogether, while
		 *    the grails webflow expects a parameter _eventId_BUTTONNAME to execute
		 *    the appropriate webflow action. Hence, we are going to prepend the
		 *    serialized formdata with an _eventId_BUTTONNAME parameter.
		 */
		if (jQueryVersion =~ /^1.([1|2|3]).(.*)/) {
			// fix for older jQuery plugin versions
			button = button.replaceFirst(/data\:jQuery\(this\)\.serialize\(\)/, "data:\'_eventId_${elementName}=1&\'+jQuery(this.form).serialize()")
		} else {
			// as of jQuery plugin version 1.4.0.1 submitToRemote has been modified and the
			// this.form part has been fixed. Consequently, our wrapper has changed as well... 
			button = button.replaceFirst(/data\:jQuery/, "data:\'_eventId_${elementName}=1&\'+jQuery")
		}

		// add an after success function call?
		// usefull for performing actions on success data (hence on refreshed
		// wizard pages, such as attaching tooltips)
		if (afterSuccess) {
			button = button.replaceFirst(/\.html\(data\)\;/, '.html(data);' + afterSuccess + ';')
		}

		// got an src parameter?
		if (src) {
			def replace = 'type="image" src="' + src + '"'

			if (alt) replace = replace + ' alt="' + alt + '"'

			button = button.replaceFirst(/type="button"/, replace)
		}

		// replace double semi colons
		button = button.replaceAll(/;{2,}/, ';')

		// render button
		out << button
	}

	/**
	 * generate a ajax submit JavaScript
	 * @see WizardTagLib::ajaxFlowRedirect
	 * @see WizardTagLib::baseElement (ajaxSubmitOnChange)
	 */
	def ajaxSubmitJs = {attrs, body ->
		// define AJAX provider
		setProvider([library: ajaxProvider])

		// got a function name?
		def functionName = attrs.remove('functionName')
		if (functionName && !attrs.get('name')) {
			attrs.name = functionName
		}

		// generate an ajax button
		def button = this.ajaxButton(attrs, body)

		// strip the button part to only leave the Ajax call
		button = button.replaceFirst(/<[^\"]*\"jQuery.ajax/, 'jQuery.ajax')
		button = button.replaceFirst(/return false.*/, '')

		// change form if a form attribute is present
		if (attrs.get('form')) {
			button = button.replaceFirst(/this\.form/,
				"\\\$('" + attrs.get('form') + "')"
			)
		}

		out << button
	}

	/**
	 * generate ajax webflow redirect javascript
	 *
	 * As we have an Ajaxified webflow, the initial wizard page
	 * cannot contain a wizard form, as upon a failing submit
	 * (e.g. the form data does not validate) the form should be
	 * shown again. However, the Grails webflow then renders the
	 * complete initial wizard page into the success div. As this
	 * ruins the page layout (a page within a page) we want the
	 * initial page to redirect to the first wizard form to enter
	 * the webflow correctly. We do this by emulating an ajax post
	 * call which updates the wizard content with the first wizard
	 * form.
	 *
	 * Usage: <wizard:ajaxFlowRedirect form="form#wizardForm" name="next" url="[controller:'wizard',action:'pages']" update="[success:'wizardPage',failure:'wizardError']" />
	 * form = the form identifier
	 * name = the action to execute in the webflow
	 * update = the divs to update upon success or error
	 *
	 * OR: to generate a JavaScript function you can call yourself, use 'functionName' instead of 'name'
	 *
	 * Example initial webflow action to work with this javascript:
	 * ...
	 * mainPage {* 	render(view: "/wizard/index")
	 * 	onRender {* 		flow.page = 1
	 *}* 	on("next").to "pageOne"
	 *}* ...
	 *
	 * @param Map attributes
	 * @param Closure body
	 */
	def ajaxFlowRedirect = {attrs, body ->
		// generate javascript
		out << '<script type="text/javascript">'
		out << '$(document).ready(function() {'
		out << ajaxSubmitJs(attrs, body)
		out << '});'
		out << '</script>'
	}

	/**
	 * render the content of a particular wizard page
	 * @param Map attrs
	 * @param Closure body  (help text)
	 */
	def pageContent = {attrs, body ->
		// define AJAX provider
		setProvider([library: ajaxProvider])

		// render new body content
		out << render(template: "/wizard/common/tabs")
		out << '<div class="content">'
		out << body()
		out << '</div>'
		out << render(template: "/wizard/common/navigation")
		out << render(template: "/wizard/common/error")
	}

	/**
	 * generate a base form element
	 * @param String inputElement name
	 * @param Map attributes
	 * @param Closure help content
	 */
	def baseElement = {inputElement, attrs, help ->
		// work variables
		def description = attrs.remove('description')
		def addExampleElement = attrs.remove('addExampleElement')
		def addExample2Element = attrs.remove('addExample2Element')
		def helpText = help().trim()

		// got an ajax onchange action?
		def ajaxOnChange = attrs.remove('ajaxOnChange')
		if (ajaxOnChange) {
			if (!attrs.onChange) attrs.onChange = ''

			// add onChange AjaxSubmit javascript
			attrs.onChange += ajaxSubmitJs(
				[
					functionName: ajaxOnChange,
					url: attrs.get('url'),
					update: attrs.get('update'),
					afterSuccess: attrs.get('afterSuccess')
				],
				''
			)
		}

		// execute inputElement call
		def renderedElement = "$inputElement"(attrs)

		// if false, then we skip this element
		if (!renderedElement) return false

		// render a form element
		out << '<div class="element">'
		out << ' <div class="description">'
		out << description
		out << ' </div>'
		out << ' <div class="input">'
		out << renderedElement
		if (helpText.size() > 0) {
			out << '	<div class="helpIcon"></div>'
		}

		// add an disabled input box for feedback purposes
		// @see dateElement(...)
		if (addExampleElement) {
			def exampleAttrs = new LinkedHashMap()
			exampleAttrs.name = attrs.get('name') + 'Example'
			exampleAttrs.class = 'isExample'
			exampleAttrs.disabled = 'disabled'
			exampleAttrs.size = 30
			out << textField(exampleAttrs)
		}

		// add an disabled input box for feedback purposes
		// @see dateElement(...)
		if (addExample2Element) {
			def exampleAttrs = new LinkedHashMap()
			exampleAttrs.name = attrs.get('name') + 'Example2'
			exampleAttrs.class = 'isExample'
			exampleAttrs.disabled = 'disabled'
			exampleAttrs.size = 30
			out << textField(exampleAttrs)
		}

		out << ' </div>'

		// add help content if it is available
		if (helpText.size() > 0) {
			out << '  <div class="helpContent">'
			out << '    ' + helpText
			out << '  </div>'
		}

		out << '</div>'
	}

	/**
	 * render an ajaxButtonElement
	 * @param Map attrs
	 * @param Closure body  (help text)
	 */
	def ajaxButtonElement = { attrs, body ->
		baseElement.call(
			'ajaxButton',
			attrs,
			body
		)
	}

	/**
	 * render a textFieldElement
	 * @param Map attrs
	 * @param Closure body  (help text)
	 */
	def textFieldElement = {attrs, body ->
		// set default size, or scale to max length if it is less than the default size
		if (!attrs.get("size")) {
			if (attrs.get("maxlength")) {
				attrs.size = ((attrs.get("maxlength") as int) > defaultTextFieldSize) ? defaultTextFieldSize : attrs.get("maxlength")
			} else {
				attrs.size = defaultTextFieldSize
			}
		}

		// render template element
		baseElement.call(
			'textField',
			attrs,
			body
		)
	}

	/**
	 * render a select form element
	 * @param Map attrs
	 * @param Closure body  (help text)
	 */
	def selectElement = {attrs, body ->
		baseElement.call(
			'select',
			attrs,
			body
		)
	}

	/**
	 * render a checkBox form element
	 * @param Map attrs
	 * @param Closure body  (help text)
	 */
	def checkBoxElement = {attrs, body ->
		baseElement.call(
			'checkBox',
			attrs,
			body
		)
	}

	/**
	 * render a dateElement
	 * NOTE: datepicker is attached through wizard.js!
	 * @param Map attrs
	 * @param Closure body  (help text)
	 */
	def dateElement = {attrs, body ->
		// transform value?
		if (attrs.value instanceof Date) {
			// transform date instance to formatted string (dd/mm/yyyy)
			attrs.value = String.format('%td/%<tm/%<tY', attrs.value)
		}

		// add 'rel' field to identity the datefield using javascript
		attrs.rel = 'date'

		// set some textfield values
		attrs.maxlength = (attrs.maxlength) ? attrs.maxlength : 10
		attrs.addExampleElement = true

		// render a normal text field
		//out << textFieldElement(attrs,body)
		textFieldElement.call(
			attrs,
			body
		)
	}

	/**
	 * render a dateElement
	 * NOTE: datepicker is attached through wizard.js!
	 * @param Map attrs
	 * @param Closure body  (help text)
	 */
	def timeElement = {attrs, body ->
		// transform value?
		if (attrs.value instanceof Date) {
			// transform date instance to formatted string (dd/mm/yyyy)
			attrs.value = String.format('%td/%<tm/%<tY %<tH:%<tM', attrs.value)
		}

		// add 'rel' field to identity the field using javascript
		attrs.rel = 'datetime'

		attrs.addExampleElement = true
		attrs.addExample2Element = true
		attrs.maxlength = 16

		// render a normal text field
		//out << textFieldElement(attrs,body)
		textFieldElement.call(
			attrs,
			body
		)
	}

	/**
	 * Template form element
	 * @param Map attributes
	 * @param Closure help content
	 */
	def speciesElement = {attrs, body ->
		// render template element
		baseElement.call(
			'speciesSelect',
			attrs,
			body
		)
	}

	/**
	 * Button form element
	 * @param Map attributes
	 * @param Closure help content
	 */
	def buttonElement = {attrs, body ->
		// render template element
		baseElement.call(
			'ajaxButton',
			attrs,
			body
		)
	}

	/**
	 * render a species select element
	 * @param Map attrs
	 */
	def speciesSelect = {attrs ->
		// fetch the speciesOntology
		// note that this is a bit nasty, probably the ontologyName should
		// be configured in a configuration file... --> TODO: centralize species configuration
		def speciesOntology = Ontology.findByName('NCBI Taxonomy')

		// fetch all species
		attrs.from = Term.findAllByOntology(speciesOntology)

		// got a name?
		if (!attrs.name) {
			// nope, use a default name
			attrs.name = 'species'
		}

		out << select(attrs)
	}

	/**
	 * Ontology form element
	 * @param Map attributes
	 * @param Closure help content
	 */
	def ontologyElement = { attrs, body ->
		// @see http://www.bioontology.org/wiki/index.php/NCBO_Widgets#Term-selection_field_on_a_form
		// @see ontology-chooser.js, table-editor.js
		baseElement.call(
			'textField',
			[
			    name: attrs.name,
				value: attrs.value,
				description: attrs.description,
				rel: 'ontology-' + ((attrs.ontology) ? attrs.ontology : 'all') + '-name',
				size: 25
			],
			body
		)
		out << hiddenField(
			name: attrs.name + '-concept_id'
		)
		out << hiddenField(
			name: attrs.name + '-ontology_id'
		)
		out << hiddenField(
			name: attrs.name + '-full_id'
		)
	}

	/**
	 * Study form element
	 * @param Map attributes
	 * @param Closure help content
	 */
	def studyElement = { attrs, body ->
		// render study element
		baseElement.call(
			'studySelect',
			attrs,
			body
		)
	}


	/**
	 * render a study select element
	 * @param Map attrs
	 */
	def studySelect = { attrs ->
		// for now, just fetch all studies
		attrs.from = Study.findAll()

		// got a name?
		if (!attrs.name) {
			attrs.name = "study"
		}

		// got result?
		if (attrs.from.size() > 0) {
			out << select(attrs)
		} else {
			// no, return false to make sure this element
			// is not rendered in the template
			return false
		}
	}

	/**
	 * Template form element
	 * @param Map attributes
	 * @param Closure help content
	 */
	def templateElement = {attrs, body ->
		// render template element
		baseElement.call(
			'templateSelect',
			attrs,
			body
		)
	}

	/**
	 * render a template select element
	 * @param Map attrs
	 */
	def templateSelect = {attrs ->
		def entity = attrs.remove('entity')

		// fetch templates
		if (attrs.remove('addDummy')) {
			attrs.from = ['']
			if (entity && entity instanceof Class) {
				Template.findAllByEntity(entity).each() {
					attrs.from[attrs.from.size()] = it
				}
			}
		} else {
			attrs.from = (entity) ? Template.findAllByEntity(entity) : Template.findAll()
		}

		// got a name?
		if (!attrs.name) {
			attrs.name = 'template'
		}

		// got result?
		if (attrs.from.size() > 0) {
			out << select(attrs)
		} else {
			// no, return false to make sure this element
			// is not rendered in the template
			return false
		}
	}

	/**
	 * Term form element
	 * @param Map attributes
	 * @param Closure help content
	 */
	def termElement = {attrs, body ->
		// render term element
		baseElement.call(
			'termSelect',
			attrs,
			body
		)
	}

	/**
	 * render a term select element
	 * @param Map attrs
	 */
	def termSelect = {attrs ->
		// fetch all terms
		attrs.from = Term.findAll()	// for now, all terms as we cannot identify terms as being treatment terms...

		// got a name?
		if (!attrs.name) {
			attrs.name = 'term'
		}

		out << select(attrs)
	}

	/**
	 * Protocol form element
	 * @param Map attributes
	 * @param Closure help content
	 */
	def protocolElement = {attrs, body ->
		// render protocol element
		baseElement.call(
			'protocolSelect',
			attrs,
			body
		)
	}

	/**
	 * render a protocol select element
	 * @param Map attrs
	 */
	def protocolSelect = {attrs ->
		// fetch all protocold
		attrs.from = Protocol.findAll()	// for now, all protocols

		// got a name?
		if (!attrs.name) {
			attrs.name = 'protocol'
		}

		out << select(attrs)
	}

	def show = {attrs ->
		// is object parameter set?
		def o = attrs.object

		println o.getProperties();
		o.getProperties().each {
			println it
		}

		out << "!! test version of 'show' tag !!"
	}

	/**
	 * render table headers for all subjectFields in a template
	 * @param Map attributes
	 */
	def templateColumnHeaders = {attrs ->
		def template = attrs.remove('template')

		// output table headers for template fields
		template.fields.each() {
			out << '<div class="' + attrs.get('class') + '">' + it + '</div>'
		}
	}

	/**
	 * render table input elements for all subjectFields in a template
	 * @param Map attributes
	 */
	def templateColumns = {attrs, body ->
		def subject = attrs.remove('subject')
		def subjectId = attrs.remove('id')
		def template = attrs.remove('template')
		def intFields = subject.templateIntegerFields
		def stringFields = subject.templateStringFields
		def floatFields = subject.templateFloatFields
		def termFields = subject.templateTermFields

		// output columns for these subjectFields
		template.fields.each() {
			def fieldValue = subject.getFieldValue(it.name)

			// output div
			out << '<div class="' + attrs.get('class') + '">'

			// handle field types
			switch (it.type.toString()) {
				case ['STRING', 'TEXT', 'INTEGER', 'FLOAT', 'DOUBLE']:
					out << textField(
						name: attrs.name + '_' + it.escapedName(),
						value: fieldValue
					)
					break
				case 'STRINGLIST':
					// render stringlist subjectfield
					if (!it.listEntries.isEmpty()) {
						out << select(
							name: attrs.name + '_' + it.escapedName(),
							from: it.listEntries,
							value: fieldValue
						)
					} else {
						out << '<span class="warning">no values!!</span>'
					}
					break
				case 'DATE':
					// transform value?
					if (fieldValue instanceof Date) {
						if (fieldValue.getHours() == 0 && fieldValue.getMinutes() == 0) {
							// transform date instance to formatted string (dd/mm/yyyy)
							fieldValue = String.format('%td/%<tm/%<tY', fieldValue)
						} else {
							// transform to date + time
							fieldValue = String.format('%td/%<tm/%<tY %<tH:%<tM', fieldValue)
						}
					}

					// output a date field (not the 'rel' which makes the
					// javascript front-end bind the jquery-ui datepicker)
					out << textField(
						name: attrs.name + '_' + it.escapedName(),
						value: fieldValue,
						rel: 'date'
					)
					break
				case 'ONTOLOGYTERM':
					// @see http://www.bioontology.org/wiki/index.php/NCBO_Widgets#Term-selection_field_on_a_form
					// @see ontology-chooser.js, table-editor.js
					//out << it.getClass()
					out << textField(
						name: attrs.name + '_' + it.escapedName(),
						value: fieldValue,
						rel: 'ontology-all-name',
						size: 100
					)
					out << hiddenField(
						name: attrs.name + '_' + it.escapedName() + '-concept_id'
					)
					out << hiddenField(
						name: attrs.name + '_' + it.escapedName() + '-ontology_id'
					)
					out << hiddenField(
						name: attrs.name + '_' + it.escapedName() + '-full_id'
					)
					break
				default:
					// unsupported field type
					out << '<span class="warning">!' + it.type + '</span>'
					break
			}

			out << '</div>'
		}
	}

	/**
	 * render form elements based on an entity's template
	 * @param Map attributes
	 * @param String body
	 */
	def templateElements = {attrs ->
		def entity = (attrs.get('entity'))
		def template = (entity && entity instanceof TemplateEntity) ? entity.template : null

		// got a template?
		if (template) {
			// render template fields
			template.fields.each() {
				def fieldValue = entity.getFieldValue(it.name)

				switch (it.type.toString()) {
					case ['STRING', 'TEXT', 'INTEGER', 'FLOAT', 'DOUBLE']:
						out << textFieldElement(
							description: it.name,
							name: it.escapedName(),
							value: fieldValue
						)
						break
					case 'STRINGLIST':
						if (!it.listEntries.isEmpty()) {
							out << selectElement(
								description: it.name,
								name: it.escapedName(),
								from: it.listEntries,
								value: fieldValue
							)
						} else {
							out << '<span class="warning">no values!!</span>'
						}
						break
					case 'ONTOLOGYTERM':
						// @see http://www.bioontology.org/wiki/index.php/NCBO_Widgets#Term-selection_field_on_a_form
						// @see ontology-chooser.js
						out << textFieldElement(
							name: it.escapedName(),
							value: fieldValue,
							rel: 'ontology-all-name',
							size: 100
						)
						out << hiddenField(
							name: it.name + '-concept_id',
							value: fieldValue
						)
						out << hiddenField(
							name: it.escapedName() + '-ontology_id',