/**
 * convertisseur de données de bornes de recharge électrique à partir de données Chargemap et open data Etalab
 */
import fs from 'node-fs'
import minimist from 'minimist'
import mappingConfigIRVE from 'mappings/configIRVE'

let mini_arguments = minimist(process.argv.slice(2))

let show_debug = 0

// wip filter
let filterOnBoundingBox = true
filterOnBoundingBox = false

let boundingBoxCoordinates = {
	xMin: 1.91,
	xMax: 2.38,
	yMin: 48.7,
	yMax: 48.4,
}

let filterCoordinates = true
let enableFilterOnDepartment = true
let filterDepartment = 91
if (mini_arguments['department']) {
	filterDepartment = mini_arguments['department']
}

let filterZipCode = new RegExp(`^${filterDepartment}`)
let filterZipCodeAdresse = new RegExp(` ${filterDepartment}`)
let filteredName = ''

if (enableFilterOnDepartment) {
	filteredName = '_filtered_zipcode_' + filterDepartment
} else if (filterOnBoundingBox) {
	filteredName = '_filtered_bbox_' + boundingBoxCoordinates.xMin + '-' + boundingBoxCoordinates.xMax + '_' + boundingBoxCoordinates.yMin + '-' + boundingBoxCoordinates.yMax
}
let pointCounterMax = 1000000

let limitConversionToFirstPoint = false
// limitConversionToFirstPoint = true;
if (limitConversionToFirstPoint) {
	pointCounterMax = 1
}

// let sourceFileChargemapJson = './chargemap_data/hurepoix.json'
let sourceFileIRVEGeoJson = './etalab_data/latest.json'
let defaultPropertiesOfPoint = {
	'amenity': 'charging_station'
}


let listOfBooleanKeys = Object.keys({
	prise_type_ef: 'socket:typee',
	prise_type_2: 'socket:type2',
	prise_type_combo_ccs: 'socket:type2_combo',
	prise_type_chademo: 'socket:chademo',
	gratuit: 'fee',
	paiement_acte: 'authentication:none',
	paiement_cb: 'payment:credit_cards',
	cable_t2_attache: 'socket:type2_cable',
})

function debugLog (message) {
	if (!show_debug) {
		return
	}
	console.log('debug: ', ...message)
}

function convertDataForIRVE (sourceFilePath, mapping, pointCounterMax, boundingBoxCoordinates) {
	debugLog('convertDataFromChargemap from ', sourceFilePath)

	let convertedGeoJson = {
		type: 'FeatureCollection',
		features: []
	}

	fs.readFile(sourceFilePath, 'utf8', function (err, data) {
		let pointcounter = 0
		if (err) {
			return debugLog(err)
		}
		let dataTransformed = JSON.parse(data)
		// debug('data keys ', Object.keys(dataTransformed))

		debugLog('debug: properties of point 0', dataTransformed.features[0])
		if (dataTransformed.features) {

			debugLog('data found, features:', dataTransformed.features.length)

			// find interesting list of points to use
			let listOfPoints = dataTransformed.features
			// for each point from the data source, convert with the mapping

			console.log('listOfPoints.length', listOfPoints.length)
			listOfPoints.forEach(featurePoint => {

				let regextestresult = true

				if (enableFilterOnDepartment) {
					console.log('filtre sur les départements activé')
					regextestresult = (
						filterZipCode.test(featurePoint.properties.consolidated_code_postal)
						||
						filterZipCodeAdresse.test(featurePoint.properties.adresse_station)
					)
				} else if (filterOnBoundingBox) {
					console.log('filtre sur les coordonnées activé')

					let x = featurePoint.properties.coordonneesXY[0]
					let xMin = boundingBoxCoordinates.xMin
					let xMax = boundingBoxCoordinates.xMax
					let yMin = boundingBoxCoordinates.yMin
					let yMax = boundingBoxCoordinates.yMax

					let y = featurePoint.properties.coordonneesXY[1]
					regextestresult = (
						(x >= xMin && x <= xMax)
						&&
						(y >= yMin && y <= yMax)
					)

				}

				// filter points depending on zipcode
				if (filterCoordinates && regextestresult) {

					debugLog('featurePoint.properties.consolidated_code_postal', featurePoint.properties.consolidated_code_postal)

					// limit results number of points
					// if (pointcounter < pointCounterMax) {

					debugLog('add point')

					debugLog('featurePoint', featurePoint)

					let mappedPoint = mapElementFromConf(featurePoint, mapping)
					debugLog('map one point', featurePoint, mappedPoint)
					if (mappedPoint) {
						convertedGeoJson.features.push(mappedPoint)
					}
				}
				// }
				pointcounter++

			})
			// output new geojson
			console.log('convertedGeoJson.features.length', convertedGeoJson.features.length)
			// write file on disk
			let fileNameToWrite = 'my_converted_data_set' + filteredName + '.json'
			console.log('write file ', fileNameToWrite)
			writeJsonFile(fileNameToWrite, JSON.stringify(convertedGeoJson, null, 2))

			debugLog('mapped output:', convertedGeoJson.features)

			return convertedGeoJson
		}
	})
}

function isBooleanKey (pointKeyName) {

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

/**
 * retuns the converted element from mapping config if present, null otherwise
 */

function 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 = ''
			if (isBooleanKey(pointKeyName)) {

				convertedValue = featurePoint.properties[pointKeyName].toLowerCase() == 'true' ? 'yes' : 'no'
			} else {
				convertedValue = featurePoint.properties[pointKeyName]
			}

			if (convertedValue) {
				newProperties[mappingConfig[pointKeyName]] = convertedValue
			}
		}
	})

	debugLog('basePoint', basePoint)
	return basePoint
}

function writeJsonFile (fileName, fileContent) {
	debugLog('write file ', fileName)

	return fs.writeFile(
		`./output/${fileName}`,
		fileContent,
		'utf8',
		(err) => {
			if (err) {
				debugLog(`Error writing file: ${err}`)
			} else {
				debugLog(`File ${fileName} is written successfully!`)
			}
		}
	)
}

console.log('pointCounterMax', pointCounterMax)
convertDataForIRVE(sourceFileIRVEGeoJson, mappingConfigIRVE, pointCounterMax, boundingBoxCoordinates)

// convertDataFromChargemap(sourceFileChargemapJson, mappingConfigIRVE)