import debugLog from './utils.mjs'

export default class {
	config = {}

	constructor (mappingConfig) {

		this.setConfig(mappingConfig)
	}

	setConfig (mappingConfig) {
		this.config = mappingConfig
	}

	mapFeaturePoint (featurePointGeoJson) {

		let geoJSONConvertedPoint = {}
		geoJSONConvertedPoint.properties = { ...this.config.default_properties_of_point }
		geoJSONConvertedPoint.type = featurePointGeoJson.type
		geoJSONConvertedPoint.geometry = featurePointGeoJson.geometry

		let props = featurePointGeoJson.properties

		props.forEach((key, value) => {

		})

		return geoJSONConvertedPoint
	}

	isBooleanKey (pointKeyName) {

		return listOfBooleanKeys.indexOf(pointKeyName) !== -1
	}

	truthyValues = ['true', 'True', 'TRUE', '1', 1]
	falsyValues = ['false', 'False', 'FALSE', '0', 0]

	/**
	 * retuns the converted element from mapping config if present, null otherwise
	 */
	mapElementFromConf (featurePoint, mappingConfig) {
		let mappingKeys = Object.keys(mappingConfig)
		let featurePointPropertiesKeys = Object.keys(featurePoint.properties)

		debugLog('keys', mappingKeys, featurePointPropertiesKeys)

		let newProperties = defaultPropertiesOfPoint

		// reinit properties of current point
		let basePoint = Object.create(featurePoint)
		basePoint.type = featurePoint.type
		basePoint.geometry = featurePoint.geometry
		basePoint.properties = newProperties

		// apply new properties if found in mapping config
		featurePointPropertiesKeys.forEach(pointKeyName => {

			if (mappingKeys.indexOf(pointKeyName) !== -1) {
				debugLog('found element', pointKeyName, '=>', mappingConfig[pointKeyName], 'value : ', featurePoint.properties[pointKeyName])
				let convertedValue = ''

				let valueConvertedFromMapping = featurePoint.properties[pointKeyName]
				let typeofValue = typeof valueConvertedFromMapping
				let isStringValue = typeofValue === 'string'
				console.log('typeof featurePoint.properties[pointKeyName] === \'string\'', typeofValue)

				let isConfigMappingObject = typeofValue === 'string'

				if (isStringValue) {
					if (isBooleanKey(pointKeyName)) {
						convertedValue = (valueConvertedFromMapping + '').toLowerCase() == 'true' ? 'yes' : 'no'
					} else {
						convertedValue = valueConvertedFromMapping
					}

					if (convertedValue) {
						newProperties[mappingConfig[pointKeyName]] = convertedValue
					}
				} else if (isConfigMappingObject) {
					let newKey = ''
					let configObject = valueConvertedFromMapping

					if (configObject.key_converted) {
						newKey = configObject.key_converted
					}

					/**
					 * gestion des valeurs conditionnelles
					 * nous pouvons renseigner une string ou un objet décrivant les transformations à réaliser
					 */
					if (configObject.conditional_values) {
						let keysConditionnalValues = Object.keys(configObject.conditional_values)
						let isFoundValue = keysConditionnalValues.indexOf(valueConvertedFromMapping)
						if (isFoundValue !== -1) {
							let conditionnalConfig = keysConditionnalValues[isFoundValue]

							if (conditionnalConfig.tags_to_add) {
								// on peut définir un ensemble de tags à rajouter
								newProperties.push(...conditionnalConfig.tags_to_add)
							}
							if (conditionnalConfig.truthy_value) {
								// convertir la valeur, si elle est truthy, la transformer en ce que donne la propriété truthy_value
								// exemple: le jeu de données dit que la colonne cable_t2_attache vaut "True", mais on veut le convertir en "1".
								// on met donc truthy_value: '1'
								if (this.truthyValues.indexOf( valueConvertedFromMapping) !== -1) {
									convertedValue = conditionnalConfig.truthy_value
								}
							}
							if (conditionnalConfig.falsy_value) {
								if (this.falsyValues.indexOf( valueConvertedFromMapping) !== -1) {
									convertedValue = conditionnalConfig.falsy_value
								}
							}
							if (conditionnalConfig.transform_function) {
								// une transformation de la valeur
								// apply transformation to value
								convertedValue = conditionnalConfig.transform_function(valueConvertedFromMapping)
							}
							// use the value converted
							else if (conditionnalConfig.value_converted) {
								convertedValue = conditionnalConfig.value_converted
							}
						}
					}

					if (newKey && !configObject.ignore_this_data) {
						newProperties[newKey] = convertedValue
					}
				}
			}
		})

		debugLog('basePoint', basePoint)
		return basePoint
	}

}