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

// @ts-ignore
import minimist from 'minimist';

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

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;

    // Boucler sur chaque fichier JPG dans le dossier
    fs.readdirSync(dirPath).forEach(file => {
        // Vérifier si le fichier est un fichier JPG
        if (path.extname(file) === '.jpg' || path.extname(file) === '.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]);

                // Sauver le nombre minimal et maximal trouvé jusqu'à présent
                if (minNumber === 0 && number > 0) {
                    minNumber = number;
                }
                if (number > maxNumber) {
                    maxNumber = number;
                }
            }
        }
    });

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

let result = findMinMaxNumberOfPhotos(folder + subfolder)
console.log('result', result)
console.log("script :\n", `
ts-node /home/poule/encrypted/stockage-syncable/www/development/html/scripts/hugin-gopro-fusion/main.ts --goproSubFolder=INBOX_a_assembler/${subfolder}
bash /home/poule/encrypted/stockage-syncable/photos/imageries/gopro/INBOX_PTO_hugin/hugin_executor_from_${result.min}_to_${result.max}.sh
bash /home/poule/encrypted/stockage-syncable/www/development/html/scripts/hugin-gopro-fusion/exif_batch.sh ${result.min} ${result.max} INBOX_a_assembler/${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;

// const startNumber = 1;
// const endNumber = 5;

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)

        
        fs.renameSync(filePath, newFilePath);
    }else{
        console.log('ce fichier est inexistant', filePath)
    }
}


function createDirectory(folderName: string): void {
    if (!fs.existsSync(folderName)) {
        fs.mkdirSync(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();

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

        console.log('fileName', fileName)
            // renameFile(fileName);

    }
}

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

createDirectory(envois_todo_panoramax);
batch_move_assembled_files(startNumber,endNumber)


import * as childProcess from 'child_process';

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);
}

exec_geovisio(envois_todo_panoramax);

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