/**
 *                                                                            
 *  Copyright (c) 2011, 2016 - 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
 * 
 * 
 *  This copyright notice shows up in the generated Java code
 *
 */
package org.eclipse.osbp.xtext.messagedsl.jvmmodel

import com.google.common.base.CaseFormat
import java.util.Locale
import javax.annotation.PostConstruct
import javax.inject.Inject
import org.eclipse.osbp.ui.api.metadata.IDSLMetadataService
import org.eclipse.osbp.ui.api.user.IUser
import org.eclipse.osbp.xtext.messagedsl.MessageCategory
import org.eclipse.osbp.xtext.messagedsl.MessageItem
import org.eclipse.osbp.xtext.messagedsl.MessageModel
import org.eclipse.osbp.xtext.messagedsl.MessagePackage
import org.eclipse.osbp.xtext.messagedsl.MessageText
import org.eclipse.osbp.xtext.messagedsl.common.IMessageCategory
import org.eclipse.osbp.xtext.messagedsl.common.Message
import org.eclipse.xtext.common.types.JvmDeclaredType
import org.eclipse.xtext.common.types.JvmField
import org.eclipse.xtext.common.types.JvmGenericType
import org.eclipse.xtext.common.types.JvmOperation
import org.eclipse.xtext.common.types.JvmVisibility
import org.eclipse.xtext.xbase.jvmmodel.AbstractModelInferrer
import org.eclipse.xtext.xbase.jvmmodel.IJvmDeclaredTypeAcceptor
import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder
import org.slf4j.Logger

/**
 * <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 MessageDslJvmModelInferrer extends AbstractModelInferrer {

	/**
     * convenience API to build and initialize JVM types and their members.
     */
	@Inject extension JvmTypesBuilder

	/**
	 * The dispatch method {@code infer} is called for each instance of the
	 * given element's type that is contained in a resource.
	 * 
	 * @param element
	 *            the model to create one or more
	 *            {@link JvmDeclaredType declared
	 *            types} from.
	 * @param acceptor
	 *            each created
	 *            {@link JvmDeclaredType type}
	 *            without a container should be passed to the acceptor in order
	 *            get attached to the current resource. The acceptor's
	 *            {@link IJvmDeclaredTypeAcceptor#accept(org.eclipse.xtext.common.types.JvmDeclaredType)
	 *            accept(..)} method takes the constructed empty type for the
	 *            pre-indexing phase. This one is further initialized in the
	 *            indexing phase using the closure you pass to the returned
	 *            {@link IPostIndexingInitializing#initializeLater(org.eclipse.xtext.xbase.lib.Procedures.Procedure1)
	 *            initializeLater(..)}.
	 * @param isPreIndexingPhase
	 *            whether the method is called in a pre-indexing phase, i.e.
	 *            when the global index is not yet fully updated. You must not
	 *            rely on linking using the index if isPreIndexingPhase is
	 *            <code>true</code>.
	 */
	def dispatch void infer(MessageModel model, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase) {
		model.pckg.categories.forEach [ category |
			acceptor.accept(model.toClass('''«category.getFQMessageClass»''')) [
				superTypes += _typeReferenceBuilder.typeRef(IMessageCategory)
				// @see org.eclipse.osbp.utils.constants.GeneratorConstants.GeneratorConstants
				documentation = '''<b>This class was auto generated! Leave it unmodified to avoid unpredictable results!</b><br>
				«category.documentation»
				'''
				final = true
				it.fileHeader = model.pckg.documentation
				category.items.forEach [ item |
					it.members += toMethod(false, model, category, item, acceptor)
					it.members += toMethod(true, model, category, item, acceptor)
				]
			]
		]
	}

	/**
	 * return the simple generated class name for the message category
	 */
	public def static String getSimpleMessageClass(MessageCategory category) {
		return '''«category.name»Message'''
	}

	/**
	 * return the fully qualified generated class name for the message category
	 */
	public def static String getFQMessageClass(MessageCategory category) {
		return '''«(category.eContainer as MessagePackage).name».«category.getSimpleMessageClass»'''
	}

	/**
	 * return the fully qualified generated class name for the message item
	 */
	public def static String getFQMessageClass(MessageItem item) {
		return (item.eContainer as MessageCategory).getFQMessageClass
	}

	/**
	 * return the generated method name for the message item
	 */
	public def static String getMethodName(MessageItem item) {
		return item.name
	}

	def JvmOperation toMethod(boolean withLogger, MessageModel model, MessageCategory category,
		MessageItem item, IJvmDeclaredTypeAcceptor acceptor) {
		return model.toMethod('''«item.name.toFirstLower»''', _typeReferenceBuilder.typeRef(Message)) [
			val fqMessageClass = item.FQMessageClass
			var docCompiled = "" as String
			if (item.documentation instanceof String) {
				docCompiled = '''«docCompiled»
                «item.documentation»<br>
                '''
			}
			if (!item.severities.empty) {
				docCompiled = '''«docCompiled»
                Severity of this message as<ul>
                '''
			}
			for (severity : item.severities) {
				docCompiled = '''«docCompiled»
                <li>«severity»</li>
                '''
			}
			if (!item.severities.empty) {
				docCompiled = '''«docCompiled»
                </ul>
                '''
			}
			var logger = "" as String
			if (withLogger) {
				docCompiled = '''«docCompiled»
                @param logger set the slf4j logger used when logging this message
                '''
				parameters += model.toParameter("logger", _typeReferenceBuilder.typeRef(Logger))
				logger = "logger"
			} else {
				docCompiled = '''«docCompiled»
                the default logger «fqMessageClass» will be used
                '''
			}
			var bodyCompiled = '''
			return (
			    new Message(«logger»'''
			if (item.logOutput !== null) {
				bodyCompiled = '''«bodyCompiled»
                «IF withLogger», «ENDIF»"«item.logOutput.escapedFormat»"
                , ""
                '''
			}
			if (item.showOutput !== null) {
				bodyCompiled = '''«bodyCompiled»
                «IF withLogger», «ENDIF»""
                , "«item.showOutput.escapedFormat»"
                '''
			}
			if (item.allOutput !== null) {
				bodyCompiled = '''«bodyCompiled»
                «IF withLogger», «ENDIF»"«item.allOutput.escapedFormat»"
                , "«item.allOutput.escapedFormat»"
                '''
			}
			for (parameter : item.parameters) {
				var typeRef = _typeReferenceBuilder.typeRef(String)
				switch (parameter.oftype) {
					case BOOLEAN: typeRef = _typeReferenceBuilder.typeRef(typeof(boolean))
					case CLASS: typeRef = _typeReferenceBuilder.typeRef(typeof(Class))
					case DOUBLE: typeRef = _typeReferenceBuilder.typeRef(typeof(double))
					case EXCEPTION: typeRef = _typeReferenceBuilder.typeRef(Exception)
					case INTEGER: typeRef = _typeReferenceBuilder.typeRef(typeof(int))
					case OBJECT: typeRef = _typeReferenceBuilder.typeRef(typeof(Object))
					default: _typeReferenceBuilder.typeRef(String)
				}
				parameters += model.toParameter(parameter.name, typeRef)
				docCompiled = '''«docCompiled»
                @param «parameter.name» «parameter.documentation»
                '''
				bodyCompiled = '''«bodyCompiled»
                , "«parameter.name»", «parameter.name»
                '''
			}
			bodyCompiled = '''«bodyCompiled»))
				'''
			for (severity : item.severities) {
				bodyCompiled = '''«bodyCompiled»
                .«CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, severity.toString.replace('-', '_'))»()
                '''
			}
			bodyCompiled = '''«bodyCompiled»;'''
			if (item.documentation instanceof String) {
				docCompiled = '''«docCompiled»
                @return instance of Message, which can be used any further
                '''
			}
			static = true
			final = true
			visibility = JvmVisibility.PUBLIC
			documentation = docCompiled.trim
			val theBody = bodyCompiled
			body = [append('''«theBody»''')]
		]
	}

	def String escapedFormat(MessageText msg) {
		return msg.text.replaceAll('''\n''', '''\\n''').replaceAll('''\t''', '''\\t''');
	}
}