import fs from "node:fs";
import path from "path";

// @ts-ignore
import minimist from 'minimist';
import * as childProcess from 'child_process';

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

let enable_batch_move_assembled_files = false;

let should_exec_geovisio_upload = false;

const reallyMoveFiles = false;

let folder = `/home/poule/encrypted/stockage-syncable/photos/imageries/gopro/INBOX_a_assembler/`
let subfolder = ``

if (mini_arguments['folder']) {
    subfolder = mini_arguments['folder']
}

/**
 * trouver les valeux min et max de numéros de séquence gopro dans un dossier contenant des photos jpg
 * @param dirPath
 */
function findMinMaxNumberOfPhotos(dirPath: string): { min: number, max: number } {

    console.log('dirPath', dirPath)

    let minNumber: number = 0;
    let maxNumber: number = 0;

    let previousFileName = 0
    // Boucler sur chaque fichier JPG dans le dossier
    fs.readdirSync(dirPath).forEach(file => {

        let currentFileName = path.extname(file)
        // Vérifier si le fichier est un fichier JPG
        if (currentFileName === '.jpg' || currentFileName === '.JPG') {
            // Éxtraire le nombre du nom de fichier
            let matches: any = file.match(/(\d+)/);
            if (matches && matches.length && matches[0]) {
                let number = parseInt(matches[0]);

                if ((previousFileName + 1) !== number) {
                    console.log('saut de nombre / séquence à ', previousFileName, number)
                }
                // Sauver le nombre minimal et maximal trouvé jusqu'à présent
                if (minNumber === 0 && number > 0) {
                    minNumber = number;
                }
                if (number > maxNumber) {
                    maxNumber = number;
                }

                previousFileName = number
            }
        }
    });

    return {
        min: minNumber,
        max: maxNumber,
    }
}

let result = findMinMaxNumberOfPhotos(folder + subfolder)
console.log('result', result)
console.log("script à lancer:\n", `
  # création des fichiers d'assemblage PTO et du script d'exécution en batch
  ts-node /home/poule/encrypted/stockage-syncable/www/development/html/scripts/hugin-gopro-fusion/main.ts --goproSubFolder=INBOX_a_assembler/${subfolder}

  # invocation de l'éxécution de la séquence d'assemblage
  bash /home/poule/encrypted/stockage-syncable/photos/imageries/gopro/INBOX_PTO_hugin/hugin_executor_from_${result.min}_to_${result.max}.sh

  # application des informations exif
  bash /home/poule/encrypted/stockage-syncable/www/development/html/scripts/hugin-gopro-fusion/exif_batch.sh ${result.min} ${result.max} INBOX_a_assembler/${subfolder}

  # envoi vers panoramax
  geovisio_cli upload --api-url https://panoramax.openstreetmap.fr /home/poule/encrypted/stockage-syncable/photos/imageries/gopro/PANORAMAX_envois_todo/${subfolder}

`)

const hugin_assemblages_script_output_path = '/home/poule/encrypted/stockage-syncable/photos/imageries/gopro/hugin_assemblages_script_output';
const envois_todo_panoramax = '/home/poule/encrypted/stockage-syncable/photos/imageries/gopro/PANORAMAX_envois_todo/' + subfolder;
const startNumber = result.min;
const endNumber = result.max;


function renameFile(fileName: string): void {
    const filePath = path.join(hugin_assemblages_script_output_path, fileName);

    if (fs.existsSync(filePath)) {
        const newFileName = `assemblage_0${startNumber}.jpg`;
        const newFilePath = path.join(envois_todo_panoramax, newFileName);

        // console.log('rename: ', filePath, newFilePath)

        if (reallyMoveFiles) {
            fs.renameSync(filePath, newFilePath);
        }
    } else {
        console.log('ce fichier est inexistant', filePath)
    }
    console.log('fin de déplacement des fichiers assemblés')
}


function createDirectory(folderName: string): void {
    console.log('createDirectory', folderName)
    if (!fs.existsSync(folderName)) {
        fs.mkdirSync(folderName, { recursive: true });
    }else{
        console.log('folder already existing', folderName)
    }
}

function getFileNames(): string[] {
    const files = fs.readdirSync(hugin_assemblages_script_output_path);
    const fileNames = files.filter((fileName) => {
        const regex = /^assemblage_\d+(\.\d+)?\.jpg$/;
        return regex.test(fileName);
    });

    return fileNames;
}


/**
 * déplacer des imageries assemblées en masse dans  un dossier "à envoyer"
 * @param startNumber
 * @param endNumber
 */
function batch_move_assembled_files(startNumber: number, endNumber: number) {
    const fileNames = getFileNames();
    console.log('fileNames', fileNames)

    for (let i = startNumber; i <= endNumber; i++) {
        const fileName = `assemblage_0${i}.jpg`;

        renameFile(fileName);

    }
}



function executeCommand(command: string, folderName: string): void {
    const fullCommand = `${command} "${folderName}"`;

    childProcess.exec(fullCommand, (error, stdout, stderr) => {
        if (error) {
            console.error(`Error executing command: ${fullCommand}`);
            console.error(error);
        } else {
            console.log(`Output of command: ${fullCommand}`);
            console.log(stdout);
        }
    });
}

function exec_geovisio(envois_todo_panoramax: string): void {
    const folderName = envois_todo_panoramax;
    const command = 'geovisio upload --api-url https://panoramax.openstreetmap.fr';

    executeCommand(command, folderName);
}

if (should_exec_geovisio_upload) {
    exec_geovisio(envois_todo_panoramax);
} else {
    console.log(' l envoi vers geovisio automatique est désactivé ')
}

console.log("exécuter geovisio upload")

createDirectory(envois_todo_panoramax);

if (enable_batch_move_assembled_files) {

    console.log(' déplacer les assemblages dans ' + envois_todo_panoramax, startNumber, endNumber)
    batch_move_assembled_files(startNumber, endNumber)
}