/**
 *                                                                            
 * 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.i18n

//import com.google.api.GoogleAPI
//import com.google.api.translate.Language
//import com.google.api.translate.Translate
import java.util.Comparator
import java.util.HashMap
import java.util.Properties
import java.util.TreeMap
import org.apache.commons.lang3.StringEscapeUtils
import org.eclipse.emf.ecore.EObject
import org.eclipse.emf.ecore.resource.Resource
import org.eclipse.osbp.preferences.ProductConfiguration
import org.eclipse.osbp.xtext.addons.AdvancedJvmModelGenerator
import org.eclipse.osbp.xtext.addons.EObjectHelper
import org.eclipse.xtext.RuleCall
import org.eclipse.xtext.generator.AbstractFileSystemAccess2
import org.eclipse.xtext.generator.IFileSystemAccess
import org.eclipse.xtext.nodemodel.util.NodeModelUtils

class StringComparator implements Comparator<String> {
	override compare(String arg0, String arg1) {
		if (arg0 < arg1) {
			return -1
		} else if (arg0 > arg1) {
			return 1
		} else {
			return 0
		}
	}
}

class I18NModelGenerator extends AdvancedJvmModelGenerator {

	protected var properties = <String, String>newTreeMap(new StringComparator())
	protected var addedTranslatables = <String, String>newHashMap

	def addTranslatables(String additionals) {
		// additionals are expected as comma separated list, pairs in list are expected to be separated by "->"
		addedTranslatables.clear
		var pairs = additionals.split(",")
		for (pair : pairs) {
			if (pair.contains("->")) {
				var parts = pair.split("->")
				var iter = parts.iterator
				addedTranslatables.put(iter.next, iter.next)
			} else {
				addedTranslatables.put(pair, null)
			}
		}
	}

	def getTranslatables(Resource resource, TreeMap<String, String> translatables) {
		translatables.clear

		// add static translatables
		for (additional : addedTranslatables.keySet) {
			if (additional.contains(":")) {
				var complex = additional.split(":")
				translatables.put(I18NKeyGenerator.key(complex.get(1)), I18NKeyGenerator.value(complex.get(1)))
			} else {
				translatables.put(I18NKeyGenerator.key(additional), I18NKeyGenerator.value(additional))
			}
		}
		var EObject eobject = EObjectHelper.getSemanticElement(resource)
		var node = NodeModelUtils.getNode(eobject)
		var contentsIterator = node.asTreeIterable.iterator
		while (contentsIterator.hasNext) {
			var abstractNode = contentsIterator.next

			// find all translatables
			if (abstractNode.grammarElement instanceof RuleCall) {
				var rule = abstractNode.grammarElement as RuleCall
				if (rule.rule.name.startsWith(I18nUtil.TRANSLATABLE)) {
					var found = false
					while (contentsIterator.hasNext && !found) {
						abstractNode = contentsIterator.next
						if (abstractNode.grammarElement instanceof RuleCall) {
							var text = new StringBuffer();
							for (leaf : abstractNode.leafNodes) {
								text.append(leaf.text.trim)
							}
							if (text.toString.contains("extends") || text.toString.contains("mapped superclass")) {
								found = true;
							} else if (text.toString.length > 0 && !text.toString.equals("\"\"")) {
								translatables.put(I18NKeyGenerator.key(text.toString),
									I18NKeyGenerator.value(text.toString))
							}
							found = true
						}
					}
				}
			}
		}
	}

	def void generateI18n(IFileSystemAccess fsa, Resource input) {
		if (ProductConfiguration.willLanguagesAutocreate) {
			if (fsa instanceof AbstractFileSystemAccess2) {
				var erfsa = fsa as AbstractFileSystemAccess2
				var translations = <String, TreeMap<String, String>>newHashMap

				var supportedLanguages = ProductConfiguration.getLanguages()
				properties.clear
				getTranslatables(input, properties)

				for (localeId : supportedLanguages.keySet) {
					val Properties prop = new Properties()
					try {
						if (localeId.equals("default")) {
							prop.load(
								erfsa.readBinaryFile("I18N.properties",
									DSLOutputConfigurationProvider.DEFAULT_OUTPUT_I18N))
						} else {
							prop.load(
								erfsa.readBinaryFile("I18N_" + localeId + ".properties",
									DSLOutputConfigurationProvider.DEFAULT_OUTPUT_I18N))
						}
					} catch (Exception e) {
						e.stackTrace
					}
					var p = <String, String>newTreeMap(new StringComparator())
					translations.put(localeId, p);

					// remove untranslated entries
					for (props : prop.stringPropertyNames) {
						if (prop.getProperty(props).length > 0) {
							p.put(props, prop.getProperty(props))
						}
					}

					// add new key to default
					if (localeId.equals("default")) {
						for (props : properties.keySet) {
							translations.get("default").put(props, properties.get(props))
						}
					}
				}

				// try to translate it
				// identify to google's billing service for translations
//				GoogleAPI.setHttpReferrer(ProductConfiguration.languagesGoogleHttpReferrer)
//				GoogleAPI.setKey(ProductConfiguration.languagesGoogleApiKey)

				for (localeId : supportedLanguages.keySet) {
					if (!localeId.equals("default")) {

						// get google's language enumeration
//						var googleLanguage = Language.fromString(supportedLanguages.get(localeId).getLanguage())

						// insert new keys
						for (key : translations.get("default").keySet) {
							if (!findTranslation(localeId, key, translations)) {

								// auto translate
								var value = translations.get("default").get(key)

								// we split numbers from text for better translation results
								var payLoads = improveForTranslation(value)

								// as we use english model definitions, the original can be used as translation
								if (localeId.equals("en")) {
									translations.get(localeId).put(key, payLoads.join);
								} else if (ProductConfiguration.languagesAutotranslate) { // if auto translation is enabled
									var property = ""

									// rearrange text and numbers again
									for (payLoad : payLoads) {
										if (Character.isLetter(payLoad.charAt(0))) {
											// use java utf-8 escape sequences
											property = property + StringEscapeUtils.escapeJava(payLoad
//												Translate.DEFAULT.execute(payLoad, Language.ENGLISH, googleLanguage)
												)
										} else {
											property = property + payLoad
										}
									}

									translations.get(localeId).put(key, property)
								} else if (!ProductConfiguration.languagesAutotranslate) { // if auto translation is disabled, copy english to german as default
									// TODO (JCD): Only for test purposes. To avoid the auto creation of the german translation values.
//									if (localeId.equals("de")) {
//										translations.get(localeId).put(key, payLoads.join);
//									}
								}
							}
						}
					}
				}

				// write out
				for (localeId : supportedLanguages.keySet) {
					var output = new StringBuilder()
					output.append("#" + localeId + "\n")
					for (key : translations.get(localeId).keySet) {
						var value = translations.get(localeId).get(key)
						// only ISO8859-1 is allowed inside the property values, thus always escape the text!!!
						value = StringEscapeUtils.escapeJava(value)
						output.append(key + "=" + value).append("\n")
					}
					if (localeId.equals("default")) {
						erfsa.generateFile("I18N.properties", DSLOutputConfigurationProvider.DEFAULT_OUTPUT_I18N, output)
					} else {
						erfsa.generateFile("I18N_" + localeId + ".properties",
							DSLOutputConfigurationProvider.DEFAULT_OUTPUT_I18N, output)
					}
				}
			}
		}
	}

	def boolean findTranslation(String localeId, String key, HashMap<String, TreeMap<String, String>> translations) {
		// find translations recursive until base language is reached - 
		// assumption: variants and countries can fall back to base language
		// de_AT_X
		var splitter = localeId.split("_")
		if (splitter.length > 1) {
			var part = <String>newArrayList(splitter)
			part.remove(part.size - 1)
			if (findTranslation(part.join("_"), key, translations)) {
				return true
			}
		}
		if (translations.containsKey(localeId) && translations.get(localeId).containsKey(key)) {
			return true
		}
		return false
	}

	def splitTextAndNumbers(String text) {
		var array = <String>newArrayList
		if (text === null || text.length == 0) {
			return array
		}
		var current = ""
		var len = text.length
		var i = 1
		var lastChar = text.charAt(0)
		current = current + lastChar
		while (i < len) {

			// detect gap
			if (Character.isLetter(text.charAt(i)) && Character.isDigit(lastChar) ||
				Character.isDigit(text.charAt(i)) && Character.isLetter(lastChar)) {
				array.add(current)
				current = ""
			}
			lastChar = text.charAt(i)
			current = current + lastChar
			i = i + 1
		}
		if (current.length > 0) {
			array.add(current)
		}
		return array
	}

	def improveForTranslation(String key) {
		var payLoad = key.replace("_", " ")

		//payLoad = payLoad.replaceAll("^m ", "")
		var newArray = <String>newArrayList
		var array = splitTextAndNumbers(payLoad)
		for (element : array) {
			if (Character.isLetter(element.charAt(0))) {
				newArray.add(deAbbreviateTranslation(element))
			} else {
				newArray.add(element)
			}
		}
		// capitalize first letter in english
		if(newArray.size > 0) {
			newArray.set(0, newArray.get(0).toFirstUpper)
		}
		return newArray
	}

	def deAbbreviateTranslation(String text) {
		var payLoad = text

		// known abbreviations
		payLoad = payLoad.replaceAll("(^|\\s)abv(\\s|$)", " alcohol by volume ")
		payLoad = payLoad.replaceAll("(^|\\s)abw(\\s|$)", " alcohol by weight ")
		payLoad = payLoad.replaceAll("(^|\\s)accnt(\\s|$)", " account ")
		payLoad = payLoad.replaceAll("(^|\\s)addr(\\s|$)", " address ")
		payLoad = payLoad.replaceAll("(^|\\s)base id(\\s|$)", " identifier ")
		payLoad = payLoad.replaceAll("(^|\\s)base uuid(\\s|$)", " identifier ")
		payLoad = payLoad.replaceAll("(^|\\s)bsin(\\s|$)", " brand single identification number ")
		payLoad = payLoad.replaceAll("(^|\\s)cal(\\s|$)", " calories ")
		payLoad = payLoad.replaceAll("(^|\\s)carb(\\s|$)", " carbohydrate ")
		payLoad = payLoad.replaceAll("(^|\\s)chol(\\s|$)", " cholesterol ")
		payLoad = payLoad.replaceAll("(^|\\s)cd(\\s|$)", " code ")
		payLoad = payLoad.replaceAll("(^|\\s)desc(\\s|$)", " description ")
		payLoad = payLoad.replaceAll("(^|\\s)diet(\\s|$)", " dietary ")
		payLoad = payLoad.replaceAll("(^|\\s)dv(\\s|$)", " daily volume ")
		payLoad = payLoad.replaceAll("(^|\\s)exp(\\s|$)", " expiring ")
		payLoad = payLoad.replaceAll("(^|\\s)hdr(\\s|$)", " header ")
		payLoad = payLoad.replaceAll("(^|\\s)hier(\\s|$)", " hierarchy ")
		payLoad = payLoad.replaceAll("(^|\\s)id(\\s|$)", " identifier ")
		payLoad = payLoad.replaceAll("(^|\\s)img(\\s|$)", " image ")
		payLoad = payLoad.replaceAll("(^|\\s)lang(\\s|$)", " language ")
		payLoad = payLoad.replaceAll("(^|\\s)nm(\\s|$)", " name ")
		payLoad = payLoad.replaceAll("(^|\\s)num(\\s|$)", " number ")
		payLoad = payLoad.replaceAll("(^|\\s)pkg(\\s|$)", " package ")
		payLoad = payLoad.replaceAll("(^|\\s)ref(\\s|$)", " reference ")
		payLoad = payLoad.replaceAll("(^|\\s)sat(\\s|$)", " saturated ")
		payLoad = payLoad.replaceAll("(^|\\s)serv(\\s|$)", " serving ")
		payLoad = payLoad.replaceAll("(^|\\s)sod(\\s|$)", " sodium ")
		payLoad = payLoad.replaceAll("(^|\\s)sku(\\s|$)", " stock-keeping unit ")
		payLoad = payLoad.replaceAll("(^|\\s)srp(\\s|$)", " suggested retail price ")
		payLoad = payLoad.replaceAll("(^|\\s)tel(\\s|$)", " telephone ")
		payLoad = payLoad.replaceAll("(^|\\s)tot(\\s|$)", " total ")
		payLoad = payLoad.trim
		return payLoad
	}

	override doGenerate(Resource input, IFileSystemAccess fsa) {
		// create i18n property files
		fsa.generateI18n(input)
		super.doGenerate(input, fsa)
	}
}