/**
 * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), 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:
 *         Florian Pirchner - Initial implementation
 */
package org.eclipse.osbp.dsl.common.xtext.jvmmodel

import com.google.inject.Inject
import java.util.List
import java.util.ListIterator
import javax.validation.Valid
import javax.validation.constraints.AssertFalse
import javax.validation.constraints.AssertTrue
import javax.validation.constraints.DecimalMax
import javax.validation.constraints.DecimalMin
import javax.validation.constraints.Digits
import javax.validation.constraints.Future
import javax.validation.constraints.Max
import javax.validation.constraints.Min
import javax.validation.constraints.NotNull
import javax.validation.constraints.Null
import javax.validation.constraints.Past
import javax.validation.constraints.Pattern
import javax.validation.constraints.Size
import org.eclipse.emf.ecore.EObject
import org.eclipse.osbp.dsl.common.xtext.extensions.AnnotationExtension
import org.eclipse.osbp.dsl.semantic.common.types.LAnnotationTarget
import org.eclipse.osbp.dsl.semantic.common.types.LAttribute
import org.eclipse.osbp.dsl.semantic.common.types.LDataType
import org.eclipse.osbp.dsl.semantic.common.types.LDatatypeConstraint
import org.eclipse.osbp.dsl.semantic.common.types.LDtCAssertFalse
import org.eclipse.osbp.dsl.semantic.common.types.LDtCAssertTrue
import org.eclipse.osbp.dsl.semantic.common.types.LDtCDecimalMax
import org.eclipse.osbp.dsl.semantic.common.types.LDtCDecimalMin
import org.eclipse.osbp.dsl.semantic.common.types.LDtCDigits
import org.eclipse.osbp.dsl.semantic.common.types.LDtCFuture
import org.eclipse.osbp.dsl.semantic.common.types.LDtCNotNull
import org.eclipse.osbp.dsl.semantic.common.types.LDtCNull
import org.eclipse.osbp.dsl.semantic.common.types.LDtCNumericMax
import org.eclipse.osbp.dsl.semantic.common.types.LDtCNumericMin
import org.eclipse.osbp.dsl.semantic.common.types.LDtCPast
import org.eclipse.osbp.dsl.semantic.common.types.LDtCRegEx
import org.eclipse.osbp.dsl.semantic.common.types.LDtCSize
import org.eclipse.osbp.dsl.semantic.common.types.LKeyAndValue
import org.eclipse.osbp.dsl.semantic.common.types.LOperation
import org.eclipse.osbp.dsl.semantic.common.types.LReference
import org.eclipse.osbp.dsl.semantic.common.types.LScalarType
import org.eclipse.osbp.dsl.semantic.common.types.LType
import org.eclipse.osbp.runtime.common.annotations.Dirty
import org.eclipse.osbp.runtime.common.annotations.Properties
import org.eclipse.osbp.runtime.common.annotations.Property
import org.eclipse.osbp.runtime.common.validation.ErrorSeverity
import org.eclipse.xtext.common.types.JvmAnnotationReference
import org.eclipse.xtext.common.types.JvmField
import org.eclipse.xtext.common.types.JvmGenericType
import org.eclipse.xtext.common.types.JvmMember
import org.eclipse.xtext.common.types.JvmOperation
import org.eclipse.xtext.common.types.util.TypeReferences
import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder
import org.eclipse.osbp.runtime.common.validation.InfoSeverity
import org.eclipse.osbp.runtime.common.validation.WarningSeverity

/** 
 * This class is responsible to generate the Annotations defined in the entity model
 */
class AnnotationCompiler {

	@Inject extension JvmTypesBuilder
	@Inject extension AnnotationExtension
	@Inject extension TypeReferences

	def processAnnotation(LAnnotationTarget annotationTarget, JvmMember jvmMember) {
		internalProcessAnnotation(annotationTarget, jvmMember)
	}

	def protected dispatch void internalProcessAnnotation(LType bean, JvmGenericType jvmType) {
		bean.resolvedAnnotations.filter([!exclude]).map([annotation]).translateAnnotationsTo(jvmType);
	}

	def protected dispatch void internalProcessAnnotation(LReference ref, JvmField jvmType) {
		ref.resolvedAnnotations.filter([!exclude]).map([annotation]).translateAnnotationsTo(jvmType);
	}

	def protected dispatch void internalProcessAnnotation(LAttribute att, JvmField jvmType) {
		att.resolvedAnnotations.filter([!exclude]).map([annotation]).translateAnnotationsTo(jvmType);
	}

	def void toDatatypeBasedConstraintAnnotations(LAttribute att, JvmField jvmType) {
		if (att.type instanceof LDataType) {
			val LDataType dt = att.type as LDataType;
			for (c : dt.constraints) {
				c.toConstraintAnnotation(jvmType)
			}
		}
	}

	def protected List<LKeyAndValue> mergeKeyAndValues(LAttribute att) {
		val keyAndValues = newArrayList()

		// add all datatype properties to the list
		att.addDatatypeKeyAndValues(keyAndValues)

		// add the attribute properties
		keyAndValues.addAll(att.properties)

		// remove duplicate keys
		keyAndValues.removeDuplicateKeys

		return keyAndValues
	}

	def protected List<LKeyAndValue> mergeKeyAndValues(LReference ref) {
		val keyAndValues = newArrayList()

		// add the attribute properties
		keyAndValues.addAll(ref.properties)

		// remove duplicate keys
		keyAndValues.removeDuplicateKeys

		return keyAndValues
	}

	def protected void removeDuplicateKeys(List<LKeyAndValue> result) {

		if (result.size == 0) {
			return
		}

		val keys = newArrayList()

		val ListIterator<LKeyAndValue> iter = result.listIterator(result.size - 1)
		while (iter.hasPrevious) {
			val LKeyAndValue temp = iter.previous
			if (keys.contains(temp.key)) {
				iter.remove
			} else {
				keys += temp.key
			}
		}
	}

	def protected addDatatypeKeyAndValues(LAttribute att, List<LKeyAndValue> result) {
		if (att.type instanceof LDataType) {
			val LDataType dt = att.type as LDataType
			result.addAll(dt.properties)
		}
	}

	def protected void toPropertiesAnnotation(EObject context, List<LKeyAndValue> keyValues, JvmField field) {
		if (keyValues == null || keyValues.size == 0) {
			return
		}
		val innerAnnotations = newArrayList()
		keyValues.forEach [
			val innerAnno = context.toAnnotation(typeof(Property))
			innerAnno.addAnnAttr(it, "key", key)
			innerAnno.addAnnAttr(it, "value", value)
			innerAnnotations += innerAnno
		]

		// now create the outer annotation and add the array of inner annotations
		val mainAnno = context.toAnnotation(typeof(Properties))
		mainAnno.addAnnAttr(context, "properties",
			innerAnnotations.toArray(<JvmAnnotationReference>newArrayOfSize(innerAnnotations.length)))
		field.annotations += mainAnno

	}

	/**
	 * Annotation to tell validator, that nested properties should be validated too
	 */
	def protected void toValidAnnotation(EObject context, JvmField field) {
		val anno = context.toAnnotation(typeof(Valid))
		field.annotations += anno
	}

	/**
	 * Annotation for the dirty state
	 */
	def void toDirtyAnnotation(EObject context, JvmField field) {
		val anno = context.toAnnotation(typeof(Dirty))
		field.annotations += anno
	}

	def dispatch boolean isValidAllowed(Void voidx) {
		return false
	}

	def dispatch boolean isValidAllowed(LDataType type) {
		if (type.asPrimitive) {
			return false
		}

		if (type.jvmTypeReference?.qualifiedName.isPrimitiveJvmType) {
			return false
		}

		return true
	}

	def dispatch boolean isValidAllowed(LScalarType type) {
		return false;
	}

	def boolean isPrimitiveJvmType(String value) {
		if (value == null) {
			return false
		}

		switch (value) {
			case (typeof(Integer).name ):
				return true
			case Integer.TYPE.name:
				return true
			case typeof(Boolean).name:
				return true
			case Boolean.TYPE.name:
				return true
			case typeof(Short).name:
				return true
			case Short.TYPE.name:
				return true
			case typeof(Long).name:
				return true
			case Long.TYPE.name:
				return true
			case typeof(Double).name:
				return true
			case Double.TYPE.name:
				return true
			case typeof(Float).name:
				return true
			case Float.TYPE.name:
				return true
			case typeof(Character).name:
				return true
			case Character.TYPE.name:
				return true
			case typeof(Byte).name:
				return true
			case Byte.TYPE.name:
				return true
			case typeof(Boolean).name:
				return true
			case Boolean.TYPE.name:
				return true
			case typeof(String).name:
				return true
		}
		return false
	}

	def protected dispatch void toConstraintAnnotation(LDtCAssertFalse constraint, JvmField field) {
		val anno = constraint.toAnnotation(typeof(AssertFalse))
		handlePayloadAndMessages(constraint, anno)
		field.annotations += anno
	}

	protected def handlePayloadAndMessages(LDatatypeConstraint constraint, JvmAnnotationReference anno) {

		// TODO OSBP right now vaadin does not support INFO and WARNING.
		switch (constraint.severity) {
			case INFO:
				anno.addAnnAttr(constraint, "payload", typeof(InfoSeverity).getTypeForName(constraint))
			case WARNING:
				anno.addAnnAttr(constraint, "payload", typeof(WarningSeverity).getTypeForName(constraint))
			case ERROR:
				anno.addAnnAttr(constraint, "payload", typeof(ErrorSeverity).getTypeForName(constraint))
		}
//		anno.addAnnAttr(constraint, "payload", typeof(ErrorSeverity).getTypeForName(constraint))

		val b = new StringBuilder
		if (!constraint.msgI18nKey.nullOrEmpty) {
			b.append(constraint.msgI18nKey)
		}

		if (!constraint.msgCode.nullOrEmpty) {
			b.append(":")
			b.append(constraint.msgCode)
		}

		if (!b.toString.nullOrEmpty) {
			anno.addAnnAttr(constraint, "message", "{" + b.toString + "}")
		}
	}

	def protected dispatch void toConstraintAnnotation(LDtCAssertTrue constraint, JvmField field) {
		val anno = constraint.toAnnotation(typeof(AssertTrue))
		handlePayloadAndMessages(constraint, anno)
		field.annotations += anno
	}

	def protected dispatch void toConstraintAnnotation(LDtCNotNull constraint, JvmField field) {
		val anno = constraint.toAnnotation(typeof(NotNull))
		handlePayloadAndMessages(constraint, anno)
		field.annotations += anno
	}

	def protected dispatch void toConstraintAnnotation(LDtCNull constraint, JvmField field) {
		val anno = constraint.toAnnotation(typeof(Null))
		handlePayloadAndMessages(constraint, anno)
		field.annotations += anno
	}

	def protected dispatch void toConstraintAnnotation(LDtCFuture constraint, JvmField field) {
		val anno = constraint.toAnnotation(typeof(Future))
		handlePayloadAndMessages(constraint, anno)
		field.annotations += anno
	}

	def protected dispatch void toConstraintAnnotation(LDtCPast constraint, JvmField field) {
		val anno = constraint.toAnnotation(typeof(Past))
		handlePayloadAndMessages(constraint, anno)
		field.annotations += anno
	}

	def protected dispatch void toConstraintAnnotation(LDtCSize constraint, JvmField field) {
		val anno = constraint.toAnnotation(typeof(Size))
		if (constraint.min >= 0) {
			anno.addAnnAttr(constraint, "min", constraint.min)
		}
		if (constraint.max > 0) {
			anno.addAnnAttr(constraint, "max", constraint.max)
		}

		handlePayloadAndMessages(constraint, anno)

		field.annotations += anno
	}

	def protected dispatch void toConstraintAnnotation(LDtCDigits constraint, JvmField field) {
		val anno = constraint.toAnnotation(typeof(Digits))
		if (constraint.intDigits >= 0) {
			anno.addAnnAttr(constraint, "integer", constraint.intDigits)
		}
		if (constraint.fractionDigits > 0) {
			anno.addAnnAttr(constraint, "fraction", constraint.fractionDigits)
		}

		handlePayloadAndMessages(constraint, anno)

		field.annotations += anno
	}

	def protected dispatch void toConstraintAnnotation(LDtCDecimalMax constraint, JvmField field) {
		val anno = constraint.toAnnotation(typeof(DecimalMax))
		anno.addAnnAttr(constraint, "value", constraint.max.toString)
		handlePayloadAndMessages(constraint, anno)
		field.annotations += anno
	}

	def protected dispatch void toConstraintAnnotation(LDtCDecimalMin constraint, JvmField field) {
		val anno = constraint.toAnnotation(typeof(DecimalMin))
		anno.addAnnAttr(constraint, "value", constraint.min.toString)
		handlePayloadAndMessages(constraint, anno)
		field.annotations += anno
	}

	def protected dispatch void toConstraintAnnotation(LDtCNumericMax constraint, JvmField field) {
		val anno = constraint.toAnnotation(typeof(Max))
		anno.addAnnAttr(constraint, "value", constraint.max)
		handlePayloadAndMessages(constraint, anno)
		field.annotations += anno
	}

	def protected dispatch void toConstraintAnnotation(LDtCNumericMin constraint, JvmField field) {
		val anno = constraint.toAnnotation(typeof(Min))
		anno.addAnnAttr(constraint, "value", constraint.min)
		handlePayloadAndMessages(constraint, anno)
		field.annotations += anno
	}

	def protected dispatch void toConstraintAnnotation(LDtCRegEx constraint, JvmField field) {
		if (constraint.pattern != null && !constraint.pattern.isEmpty) {
			val anno = constraint.toAnnotation(typeof(Pattern))
			anno.addAnnAttr(constraint, "regexp", constraint.pattern)
			handlePayloadAndMessages(constraint, anno)
			field.annotations += anno
		}
	}

	// def protected dispatch void toConstraintAnnotation(LDtCPast constraint, JvmField field) {
	// field.annotations += constraint.toAnnotation(typeof(Past))
	// }
	def protected dispatch void internalProcessAnnotation(LOperation member, JvmOperation jvmOperation) {
		member.resolvedAnnotations.filter([!exclude]).map([annotation]).translateAnnotationsTo(jvmOperation);
	}
}