// Imposition-04-Decoupe.js
// ---------------------------------------------------------------------------
// Suite d'imposition professionnelle - Folder-Level Script pour Adobe Acrobat Pro
// Module 4 : Decoupe et reassemblage de pages
//
// Depend de Imposition-00-Core.js (doit etre charge avant).
//
// Repose sur CDImp.Util.extraireRegionPage() / placerPageDansRect() (voir
// avertissement dans Imposition-00-Core.js). A tester dans Acrobat Pro reel
// avant usage en production.
// ---------------------------------------------------------------------------

if (typeof CDImp === "undefined") {
    throw new Error("Imposition-04-Decoupe.js : CDImp.Core doit etre charge avant ce fichier.");
}

CDImp.Decoupe = CDImp.Decoupe || {};

// -----------------------------------------------------------------------
// Couper les pages en deux (Split)
// -----------------------------------------------------------------------
/**
 * Coupe chaque page de srcDoc en deux moities independantes et retourne un
 * nouveau document contenant 2x plus de pages.
 *
 * @param {Doc} srcDoc
 * @param {String} axe "vertical" (gauche/droite) | "horizontal" (haut/bas)
 * @returns {Doc} nouveau document
 */
CDImp.Decoupe.couperPages = function (srcDoc, axe) {
    var destDoc;
    CDImp.Util.avecPrivileges(function () {
        destDoc = new Doc();
    });

    var nDestPage = 0;
    for (var s = 0; s < srcDoc.numPages; s++) {
        var box = srcDoc.getPageBox({ nPage: s, cBox: "Crop" });
        var w = Math.abs(box[2] - box[0]);
        var h = Math.abs(box[3] - box[1]);

        var demis; // [{rect, largeur, hauteur}, ...] dans l'ordre de lecture
        if (axe === "horizontal") {
            demis = [
                { rect: [0, h / 2, w, h], largeur: w, hauteur: h / 2 },     // haut
                { rect: [0, 0, w, h / 2], largeur: w, hauteur: h / 2 }      // bas
            ];
        } else {
            demis = [
                { rect: [0, 0, w / 2, h], largeur: w / 2, hauteur: h },     // gauche
                { rect: [w / 2, 0, w, h], largeur: w / 2, hauteur: h }      // droite
            ];
        }

        for (var d = 0; d < demis.length; d++) {
            CDImp.Util.avecPrivileges(function () {
                destDoc.newPage({ nPage: nDestPage, width: demis[d].largeur, height: demis[d].hauteur });
            });
            CDImp.Util.extraireRegionPage(srcDoc, s + 1, demis[d].rect, destDoc, nDestPage);
            nDestPage++;
        }
    }

    return destDoc;
};

// -----------------------------------------------------------------------
// Inversion de l'ordre des pages
// -----------------------------------------------------------------------
/**
 * Retourne un nouveau document avec les pages de srcDoc dans l'ordre inverse.
 */
CDImp.Decoupe.inverserOrdre = function (srcDoc) {
    var n = srcDoc.numPages;
    var destDoc;
    CDImp.Util.avecPrivileges(function () {
        destDoc = new Doc();
    });

    for (var i = 0; i < n; i++) {
        var nSrcPage = n - i; // 1-based, en partant de la derniere page
        var box = srcDoc.getPageBox({ nPage: nSrcPage - 1, cBox: "Crop" });
        var w = Math.abs(box[2] - box[0]);
        var h = Math.abs(box[3] - box[1]);

        CDImp.Util.avecPrivileges(function () {
            destDoc.newPage({ nPage: i, width: w, height: h });
        });
        CDImp.Util.placerPageDansRect(srcDoc, nSrcPage, destDoc, i, [0, 0, w, h]);
    }

    return destDoc;
};

// -----------------------------------------------------------------------
// Reassemblage par motif (mélange par blocs)
// -----------------------------------------------------------------------
/**
 * Reordonne les pages de srcDoc par blocs, selon un motif comme "1,3,2,4"
 * (1-based, a l'interieur de chaque bloc). La taille de bloc est la longueur
 * du motif ; le nombre de pages doit en etre un multiple exact.
 *
 * @param {Doc} srcDoc
 * @param {String} motifStr ex: "1,3,2,4"
 * @returns {Doc} nouveau document reordonne
 */
CDImp.Decoupe.reassembler = function (srcDoc, motifStr) {
    var motif = motifStr.split(",").map(function (s) { return parseInt(s.trim(), 10); });
    var taille = motif.length;
    if (taille === 0 || motif.some(function (m) { return isNaN(m) || m < 1 || m > taille; })) {
        throw new Error("Motif invalide : \"" + motifStr + "\". Attendu une liste de positions 1-based, ex: 1,3,2,4");
    }
    if (srcDoc.numPages % taille !== 0) {
        throw new Error("Le document (" + srcDoc.numPages + " pages) n'est pas un multiple de la taille de bloc (" + taille + ").");
    }

    var nBlocs = srcDoc.numPages / taille;
    var destDoc;
    CDImp.Util.avecPrivileges(function () {
        destDoc = new Doc();
    });

    var nDestPage = 0;
    for (var b = 0; b < nBlocs; b++) {
        for (var k = 0; k < taille; k++) {
            var nSrcPage = b * taille + motif[k]; // 1-based
            var box = srcDoc.getPageBox({ nPage: nSrcPage - 1, cBox: "Crop" });
            var w = Math.abs(box[2] - box[0]);
            var h = Math.abs(box[3] - box[1]);

            CDImp.Util.avecPrivileges(function () {
                destDoc.newPage({ nPage: nDestPage, width: w, height: h });
            });
            CDImp.Util.placerPageDansRect(srcDoc, nSrcPage, destDoc, nDestPage, [0, 0, w, h]);
            nDestPage++;
        }
    }

    return destDoc;
};

// -----------------------------------------------------------------------
// Point d'entree du module
// -----------------------------------------------------------------------
CDImp.Decoupe.lancer = function (doc) {
    try {
        doc = CDImp.Util.getDocActif(doc);
    } catch (e) {
        CDImp.Util.erreur(e.toString());
        return;
    }

    var action = app.popUpMenu(
        { cName: "Couper les pages en deux (Split)", cReturn: "split" },
        { cName: "Inverser l'ordre des pages", cReturn: "reverse" },
        { cName: "Reassembler par motif (Shuffle)", cReturn: "shuffle" }
    );
    if (!action) { return; }

    var destDoc, params;
    try {
        switch (action) {
            case "split":
                var axe = app.popUpMenu(
                    { cName: "Vertical (gauche / droite)", cReturn: "vertical" },
                    { cName: "Horizontal (haut / bas)", cReturn: "horizontal" }
                );
                if (!axe) { return; }
                params = { action: "split", axe: axe };
                destDoc = CDImp.Decoupe.couperPages(doc, axe);
                break;

            case "reverse":
                params = { action: "reverse" };
                destDoc = CDImp.Decoupe.inverserOrdre(doc);
                break;

            case "shuffle":
                var motifStr = app.response({
                    cQuestion: "Motif de reassemblage par bloc (positions 1-based separees par des virgules) :",
                    cTitle: "Reassembler par motif",
                    cDefault: "1,3,2,4"
                });
                if (motifStr === null) { return; }
                params = { action: "shuffle", motif: motifStr };
                destDoc = CDImp.Decoupe.reassembler(doc, motifStr);
                break;
        }
    } catch (e) {
        CDImp.Util.erreur("Erreur : " + e.toString());
        return;
    }

    if (CDImp.Auto && CDImp.Auto.enregistrerDerniereAction) {
        CDImp.Auto.enregistrerDerniereAction("Decoupe.executer", params);
    }

    CDImp.Util.info("Operation terminee (" + destDoc.numPages + " page(s)).\nPensez a l'enregistrer (Ctrl+S) sous un nouveau nom.");
};

/**
 * Variante directe sans dialogues (Module 7 - Automatisation).
 */
CDImp.Decoupe.executerAvecParams = function (doc, params) {
    doc = CDImp.Util.getDocActif(doc);
    var destDoc;
    switch (params.action) {
        case "split":
            destDoc = CDImp.Decoupe.couperPages(doc, params.axe);
            break;
        case "reverse":
            destDoc = CDImp.Decoupe.inverserOrdre(doc);
            break;
        case "shuffle":
            destDoc = CDImp.Decoupe.reassembler(doc, params.motif);
            break;
        default:
            throw new Error("Action inconnue : " + params.action);
    }
    CDImp.Util.info("Operation recreee avec succes (" + destDoc.numPages + " page(s)).");
    return destDoc;
};