import fs from 'node-fs'
// list.map(folder => {
// 	getExifCreationDate(filepath)
// })
import exifr from 'exifr'
import moment from 'moment'

const pathFolder = '/home/poule/encrypted/stockage-syncable/photos/a_dispatcher'

// Replace with path to source directory

/**
 * obtenir une liste des dossiers uniquement dans le dossier courant
 * @param path
 * @returns {*}
 */
function getDirectories (path) {
	return fs.readdirSync(path).filter(function (file) {
		return fs.statSync(path + '/' + file).isDirectory()
	})
}

function convertDateToTimeInFileName (inputDate) {
	return inputDate.replace(' ', 'T')
}

function findFormattedDate (inputString) {
	return inputString.match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/ig)
}

function findScreenshot (inputString) {
	return inputString.match(/screenshot/i) || inputString.match(/capture d'écran/i)
}

function getExifCreationDate (filepath) {

	console.log('filepath', filepath)
	let dateAlreadyInFileName = findFormattedDate(filepath)
	console.log('------ dateAlreadyInFileName', dateAlreadyInFileName)

	exifr.parse(filepath).then(exifData => {

		if (exifData) {

			let moments = []

			// console.log('exif data : ', exifData) // Do something with your data!
			if (exifData.DateTimeOriginal) {

				// console.log('image créée le : DateTimeOriginal : ', exifData.DateTimeOriginal) // Do something with your data!
				moments.push(exifData.DateTimeOriginal)
			}
			if (exifData.ModifyDate) {

				// console.log('image modifiée le : ModifyDate : ', exifData.ModifyDate) // Do something with your data!
				moments.push(exifData.ModifyDate)
			}
			if (exifData.FileModificationDateTime) {

				// console.log('image créée le : FileModificationDateTime : ', exifData.FileModificationDateTime) // Do something with your data!
				moments.push(exifData.FileModificationDateTime)
			}
			if (exifData.CreateDate) {

				// console.log('image créée le : CreateDate : ', exifData.CreateDate) // Do something with your data!
				moments.push(exifData.CreateDate)
			}

			moments = moments.map(d => {
				let newdate = moment(d)
				return newdate
			})
			let minDate = moment.min(moments)

			return minDate
		} else {
			console.log('pas de exif data')
			return null
		}
	}).catch(error => console.log('Error: ' + error.message))

}

const tagSeparator = ' '
const tagSectionSeparator = '--'
let fileSectionsName

function findFileExtension (inputString) {
	let match = inputString.match(/\.\w{3,4}$/i)
	// console.log('match', match)
	return match
}

function findTagSectionInString (inputString) {
	let listOfTags = []
	// remove extension
	let extensionFile = findFileExtension(inputString)

	if (extensionFile) {

		extensionFile = extensionFile[0]
	} else {

		console.log('no extensionFile', extensionFile, inputString)
		extensionFile = ''
	}

	inputString = inputString.replace(extensionFile, '')

	console.log('extensionFile', extensionFile)
	if (inputString.includes(tagSectionSeparator)) {
		console.log('inputString', inputString)
		if (inputString.length) {

			let boom = inputString.split(tagSectionSeparator)
			console.log('boom', boom)
			if (boom.length) {
				fileSectionsName = boom.splice(tagSeparator)
				listOfTags = [...fileSectionsName[1].trim().split(tagSeparator)]
				console.log('listOfTags', listOfTags)
			} else {
				console.log('no boom', boom)
			}
		}
	}
	return listOfTags
}

function renameFile (originalFileName, fileMixedNewName) {
	fs.rename(originalFileName, fileMixedNewName, function (err) {
		if (err) console.log('rename ERROR: ' + err)
	})
}

// let list = getDirectories(pathFolder)
// console.log('list', list)

let originalFileName = '2023-06-23T08.55.05.jpg'
let formattedDatePIMBefore = findFormattedDate(originalFileName)
console.log('formattedDatePIMBefore', formattedDatePIMBefore)

let creationDateFound = getExifCreationDate(pathFolder + '/' + originalFileName)
let convertedToName = ''
if (creationDateFound) {
	convertedToName = convertDateToTimeInFileName(creationDateFound)
}
console.log('convertedToName', convertedToName)
let fileMixedNewName = mixDateNameWithFileName(convertedToName, originalFileName)

console.log('new name', fileMixedNewName)

if (fileMixedNewName !== originalFileName) {
	console.log('renommage =>', fileMixedNewName)
	// renameFile(originalFileName, fileMixedNewName)
}

/**
 * find the section of file name which contains the free text to describe the picture
 * @param fileName
 * @returns {*|string}
 */
function findFileNameFreeTextPart (fileName) {
	fileName = fileName.replace(findFileExtension(fileName), '')
	let boom = fileName.split(tagSectionSeparator)
	if (boom.length) {
		let freeTextPart = boom[0].trim()
		console.log('freeTextPart', freeTextPart)
		return freeTextPart
	}
	return fileName.trim()
}

function addTagInFileName (tagName, fileName) {

	let tags = findTagSectionInString(fileName)
	let firstPart = findFileNameFreeTextPart(fileName)

	tags.push(tagName)
	let uniqueArray = [...new Set(tags)]

	let newFileName = firstPart + ' ' + tagSectionSeparator + ' ' + tags.join(tagSeparator)
	newFileName = newFileName.replace(/ {*}/, '')  + findFileExtension(fileName)
	return cleanSpaces( newFileName)
}

const patternsFiles = {
	'downloaded_pic': '', // FyB8cZnWIAc21rw.jpg
	'telegram_pic': '', // -4900281569878475578_1109.jpg
	'open_camera': '^IMG_OC', // IMG_OC_20230617_092120_3.jpg
	'screenshot': '^Screenshot', // Screenshot 2023-06-15 at 15-26-04 Instance Panoramax OSM-FR.png
}
const fileDefinition = {
	dateStamp: '',
	freeText: '',
	tags: [],
	extension: '',
}

function destructurateFileName (fileName) {
	return {
		dateStamp: findFormattedDate(fileName),
		freeText: findFileNameFreeTextPart(fileName),
		tags: findTagSectionInString(fileName),
		extension: findFileExtension(fileName),
	}
}

function cleanSpaces (inputString) {

	return inputString.trim().replace(/  *g/, ' ')
}

function makeFileNameFromProperties (fileProperties) {
	return cleanSpaces(fileProperties.dateStamp + ' ' + fileProperties.freeText + ' ' + tagSectionSeparator + ' ' + fileProperties.tags.join(tagSeparator) + fileProperties.extension)
}

function appendFileName (fileProperties, newText) {
	fileProperties.freeText = cleanSpaces(fileProperties.freeText + ' ' + newText)
	return fileProperties
}

function prependFileName (fileProperties, newText) {
	fileProperties.freeText = cleanSpaces(newText + ' ' + fileProperties.freeText)
	return fileProperties
}

function searchAndReplaInFileName (searchString, replaceString, fileName) {
	return cleanSpaces(fileName.replace(searchString, replaceString))
}

// getExifCreationDate('/home/poule/encrypted/stockage-syncable/photos/a_dispatcher/2023-06-23T18.36.47 -- machin bidule.jpg')
// findTagSectionInString('2023-06-23T18.36.47 -- machin bidule.jpg')

function searchAndRenameScreenshots(fileName){
	if (findScreenshot(fileName)) {
		let tags = findTagSectionInString(fileName)
		console.log('tags', tags)
		if (!tags.includes('screenshot')) {

			fileName = addTagInFileName('screenshot', fileName)
			fileName = searchAndReplaInFileName('Screenshot', '', fileName)
			console.log('screenShotMockFileName:', fileName)
			return cleanSpaces( fileName)
		}
		console.log('is a screenshot, remove screenshot in name, and add tag screenshot')
	}else{
		return null
	}
}
function TestScreenShotIsFoundAndRenamed () {

	let screenShotMockFileName = 'Screenshot 2023-06-15 at 15-28-21 Instance Panoramax OSM-FR.png'
	let screenShotMockFileNameExpected = '2023-06-15 at 15-28-21 Instance Panoramax OSM-FR -- screenshot.png'
	let found = searchAndRenameScreenshots(screenShotMockFileName)
	console.log('found', found)
	if(found == screenShotMockFileNameExpected){
		console.log('TestScreenShotIsFoundAndRenamed : test succès')
	}else{
		console.log('TestScreenShotIsFoundAndRenamed : FAIL:')
		console.log(found)
		console.log(screenShotMockFileNameExpected)
	}
}
TestScreenShotIsFoundAndRenamed()

/**
 * work in progress
 *
 */


function TestDateIsDetectedInFileName () {
	let mockFileName = 'Capture d\'écran 2023-06-15T10:11:12.png'
	let expectedFileNameAfterRename = '2023-06-15T10:11:12 -- screeenshot.png'
	let foundDate = findFormattedDate(mockFileName)
	console.log('foundDate', foundDate)
}

// run tests
TestDateIsDetectedInFileName()



/**
 ----------------------- parties non réalisées -----------------------
 	// TODO
 ---------------------------------------------------------------------
 **/

function TestDownloadedTelegramPictureRename (fileName) {
	let fileProperties = destructurateFileName(fileName)
}

function hasDifferentDateInNameThanExif () {

}

function moveToArchive (targetDirectory, fileFullPath) {
	// find current directory,
	// rename file to move it
}

/**
 * écrit un nouveau nom de fichier formatté
 * @param convertedToName
 * @param originalFileName
 * @returns {*}
 */
function mixDateNameWithFileName (convertedToName, originalFileName) {
	// enlever l'ancien timestamp si il existe
	// ajouter en début de nom le nouveau timestamp avec un espace et conserver le reste du nom
	return originalFileName
}