import fs from 'node-fs'
import finders from './finders.mjs'

// list.map(folder => {
// 	getExifCreationDate(filepath)
// })
import exifr from 'exifr'
import moment from 'moment'
import {tagSectionSeparator, tagSeparator, enableTestsLocally} from "./configs.mjs";

const pathFolder = '/home/poule/encrypted/stockage-syncable/photos/a_dispatcher/tout'
const sortingFolder = '/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 getExifCreationDate(filepath) {

    console.log('filepath', filepath)
    let dateAlreadyInFileName = finders.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))

}

let fileSectionsName


function findTagSectionInString(inputString) {
    let listOfTags = []
    // remove extension
    let extensionFile = finders.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 = '2015-04-30T09.09.02 -- scan papier.jpg'
let formattedDatePIMBefore = finders.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)
}


function addTagInFileName(tagName, fileName) {

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

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

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

const fileDefinition = {
    dateStamp: '',
    freeText: '',
    tags: [],
    extension: '',
}

function destructurateFileName(fileName) {
    return {
        dateStamp: finders.findFormattedDate(fileName),
        freeText: finders.findFileNameFreeTextPart(fileName),
        tags: findTagSectionInString(fileName),
        extension: finders.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 (finders.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 TestTagsAreDetectedInFileName() {
    let mockFileName = '2023-06-15T10:11:12 -- screeenshot festival.png'
    let expectedResult = ['screeenshot', 'festival']
    let found = findTagSectionInString(mockFileName)
    if (found === expectedResult) {
        console.info('Succès')
    }
}


function TestFindFormattedDate() {
    let mockFileName = 'Capture d\'écran 2023-06-15T10:11:12.png'
    let expectedResult = '2023-06-15T10:11:12'
    let found = finders.findFormattedDate(mockFileName)
    console.log('foundDate', found, expectedResult)
    console.log('foundDate', found)
    if (found === expectedResult) {
        console.info('Succès')
    }
}

// run tests
if (enableTestsLocally) {

    TestTagsAreDetectedInFileName()
    TestFindFormattedDate()
}

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

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

function hasDifferentDateInNameThanExif(fileName) {
    let foundDate = finders.findFormattedDate(fileName);

    if (foundDate && foundDate != getExifCreationDate(fileName)) {
        return true;
    }
    return false;
}

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

function moveToSortingFolder(fileFullPath) {

}

/**
 * é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
}