import dayjs from 'dayjs';
import extend from 'just-extend';
import { COMPETENCES_ADMINISTRES_MAX_ITEMS, COMPETENCES_SEPARATEUR, DEPARTEMENTS_SOUHAITES_MAX_ITEMS, DEPARTEMENTS_SOUHAITES_SEPARATEUR, MARQUES_SEPARATEUR, PROFILS, ZONES_SEPARATEUR, ZONE_GEO_SHM_ADMINISTRES_MAX_ITEMS } from '../../../../constantes/constantes';
import { getDecisionLabel, getLibelleAvisAdministre, getLibelleEtatFeFmob } from '../../../../helpers/i18n-helper';
import { createConstantsFrom, deepFreeze } from '../../../../helpers/objects';
import i18n from '../../../../i18n/i18n';
import { commonColTypes, commonCssClasses, FILTER_PARAMS_EXCEL_MODE } from '../commonAGGridColumnTypes';
import { creerColDefDonneesFormatees, creerColDefDonneesRef, creerFormateurParams, customizeEditorAndStopEditing, getFalse, getRefs, hasProfilLocal, toStartOfDayOrDefault } from '../commonAGGridFunctions';
import { createMarquesComparator, getAvisAdministre } from '../helpers/business-data-helpers';
import { buildAndAddColGroupDefVariant, buildColumnDefs } from './AGGridConfigurationCommun';
import { nameComparator } from '../../../../helpers/comparators';

const now = dayjs();
const anneeCourante = now.toDate().getUTCFullYear();

/** @type {{administre: string, avis: string, decision: string, etatFe: string, probleme: string, valeurModifiee: string}} */
const cssClasses = deepFreeze({
    ...createConstantsFrom(['administre', 'avis', 'decision', 'probleme', 'valeurModifiee']),
    etatFe: 'etat-fe'
});

/**
 * Classe de fonctions de paramétrage des colonnes à afficher dans les listes AG Grid d'administrés et de mapping des données issues de l'API.
 *
 * @class
 */
class AGGridConfigurationAdministres {
    /**
     * Constructeur
     * @param {import('../../../../jsdoc/types').DonneesReference} donneesReference - Données de référence
     */
    constructor(donneesReference) {
        this.donneesReference = donneesReference;
        this.completeColumnDefs = this.buildCompleteColumnDefs();
    }

    /**
     * Génère l'objet columnDefs pour l'affichage d'une liste d'administrés.
     * @param {(string|import('../../../../jsdoc/types').ColGroupDefConstruction)[]} groupsAndColumns - Liste des groupes de colonnes et des colonnes à générer
     * @returns {import('../../../../jsdoc/types').AppColGroupDef[]} - Object columnDefs de définition des groupes de colonnes et colonnes à ajouter à la liste
     * @param {?import('./AGGridConfigurationCommun').BuildColumnDefs_Selecteur} [selecteur] - filtre de sélection, uniquement utilisé quand un groupe ne spécifie pas les colonnes
     */
    
    buildAdministresColumnDefs(groupsAndColumns, selecteur) {
        return buildColumnDefs(groupsAndColumns, this.completeColumnDefs, selecteur);
    }

    /**
     * Adapte les données des administrés reçues du backend pour l'affichage dans AG Grid.
     *
     * @param {?import('../../../../jsdoc/api').AdministreApi[]} administres - Liste des administrés
     * @returns {Object[]} liste mappée des administrés adaptés
     */
    adapteAdministres(administres) {
        return administres?.map((a) => this.adapteAdministre(a)) ?? [];
    }

    /**
     * Convertir une date reçues du backend a une Anciennete pour l'affichage dans AG Grid.
     *
     * @param {Array.<Object>} date - La date
     * @returns {Array.<Object>} Un string contenant la date modifié
     */
    DatetoAnciennete(date) {
        const CHAMP_VIDE = i18n.global.donnees.vide;
        const date_fromatee = dayjs(date).format('DD/MM/YYYY');
        const date_temps = dayjs(now).diff(date, 'year');
        const jourPluriel = date_temps !== '' ? (date_temps > 1 ? ' ans' : ' an') : '? ans';
        const temps = parseInt(date_temps, 10) < 0 ? 0 : date_temps;
        const toDisplay = (date_fromatee && date_fromatee != CHAMP_VIDE ? ' depuis ' + temps + jourPluriel : '');

        return toDisplay
    }

    /**
     * Adapte les données d'UN administré reçues du backend, pour l'affichage dans AG Grid :
     * - Mapping des champs
     * - Ajout de valeur par défaut pour les données manquantes (généralement '')
     * - Ajout de certains champs calculés (ex : identite_age, service_temps)
     *
     * @param {import('../../../../jsdoc/api').AdministreApi} a - Objet contenant les données issues du backend pour un administré
     * @returns {Object} Objet normalisé et complété, pour affichage dans AG Grid
     */
    adapteAdministre(a) {
        try {

        const administreAdapte = {
            // Id unique
            id: a.a_id_sap || '',

            id_pam : a.id || '',

            // Identité
            identite_matricule: a.a_id_sap || '',
            identite_grade: a.grade ? a.grade.gr_code : '',
            identite_nom: a.a_nom || '',
            identite_prenom: a.a_prenom || '',
            identite_anciennete_grade : a.a_grade_date_debut ? this.DatetoAnciennete(a.a_grade_date_debut) : '',
            identite_date_naissance: a.a_date_naissance ? dayjs(a.a_date_naissance).format('DD/MM/YYYY') : '',
            identite_age: a.a_date_naissance ? anneeCourante - new Date(a.a_date_naissance).getUTCFullYear() : '',
            identite_sexe: a.a_sexe || '',
            identite_grade_nom_prenom: (a.grade ? a.grade.gr_code + ' ' : '') + (a.a_nom || '') + ' ' + (a.a_prenom || ''),

            // EIP actuel
            EIPActuel_domaine: a.a_domaine || '',
            EIPActuel_filiere: a.a_filiere || '',
            EIPActuel_NF: a.a_nf ? a.a_nf.toUpperCase() : '',
            EIPActuel_domaine_gestion: a.a_domaine_gestion || '',

            // EIP futur
            EIPFutur_domaine: a.a_domaine_futur || '',
            EIPFutur_filiere: a.a_filiere_futur || '',
            EIPFutur_NF: a.a_nf_futur ? a.a_nf_futur.toUpperCase() : '',

            // Matrimonial
            matrimonial_situation: a.a_situation_fam || '',
            matrimonial_emploiConjoint: a.a_profession_conjoint || '',
            matrimonial_nbEnfants: a.a_nombre_enfants || '',
            matrimonial_sexeConjoint: a.a_sexe_conjoint || '',

            // Service
            service_temps: a.a_date_entree_service ? dayjs(now).diff(a.a_date_entree_service, 'year') : '',
            service_dateRDC: toStartOfDayOrDefault(a.a_date_rdc),
            service_dernierACR: a.a_date_dernier_acr ? new Date(a.a_date_dernier_acr) : '',  //a.a_date_naissance ? dayjs(a.a_date_naissance).format('DD/MM/YYYY') : '', 
            service_arme: a.a_arme || '',
            service_origine_recrutement: a.a_origine_recrutement || '',

            // Affectation actuelle
            affectationActuelle_FE: a.formation_emploi?.fe_code,
            affectationActuelle_libelle: a.formation_emploi?.fe_libelle,
            affectationActuelle_lieu: a.formation_emploi?.fe_garnison_lieu,
            affectationActuelle_zoneDefense: a.formation_emploi?.zone_defense,
            affectationActuelle_codeFeMere: a.formation_emploi?.mere?.fe_code,
            affectationActuelle_libelleFeMere: a.formation_emploi?.mere?.fe_libelle,
            affectationActuelle_etatFeBmob: a.etat_fe_bmob,

            // a.decision?.de_decision !== DECISIONS.PROPOSITION_FE
            //     ? null
            //     : decoder(a.a_id_sap, a.formation_emploi?.fe_code, a.decision?.poste?.formation_emploi?.fe_code, a.profils?.lecture),

            // Fonction
            fonction: a.a_fonction || '',

            // Affectation future (s'il n'y a pas de décision on affiche l'affectation actuelle)
            ...(formation_emploi => ({
                affectationFuture_FE: formation_emploi?.fe_code,
                affectationFuture_libelle: formation_emploi?.fe_libelle,
                affectationFuture_lieu: formation_emploi?.fe_garnison_lieu,
                affectationFuture_codeFeMere: formation_emploi?.mere?.fe_code,
                affectationFuture_libelleFeMere: formation_emploi?.mere?.fe_libelle,
                affectationFuture_notes_FE: a.a_situationfuture_notes_fe || '',
                affectationFuture_dateAffectationFuture: toStartOfDayOrDefault(a.a_date_affectation),
            }))(a.decision?.poste?.formation_emploi ?? a.formation_emploi),

            // situation future
            situationFuture_statutFutur: a.statut_futur,
            situationFuture_dateStatutFutur: toStartOfDayOrDefault(a.date_statut_futur),
            situationFuture_statutConcerto: a.a_statut_concerto,
            situationFuture_dateStatutConcerto: toStartOfDayOrDefault(a.a_date_statut_concerto),
            situationFuture_statutConcertoFutur: a.a_statut_concerto_futur,
            situationFuture_dateStatutConcertoFutur: toStartOfDayOrDefault(a.a_date_statut_concerto_futur),
            situationFuture_fud: a.a_fud,
            situationFuture_dateFud: toStartOfDayOrDefault(a.a_date_fud),
            situationFuture_suiviPrevisionnel: a.suivi_previsionnel_situation,
            situationFuture_dateSuiviPrevisionnel: toStartOfDayOrDefault(a.date_suivi_previsionnel_situation),

            // Compétences
            //competences_competences: a.a_liste_id_competences[0]?.comp_id ? a.a_liste_id_competences[0]?.comp_id : 'Aucune comp',//a.a_liste_id_competences || [], //[],//.split(COMPETENCES_SEPARATEUR) : [],
            competences_competences: a.a_liste_id_competences ? a.a_liste_id_competences :[],//.split(',') : [],

            // FORMOB
            FORMOB_id: a.fmobs?.length ? a.fmobs[0].fmob_id : '',
            FORMOB_motif: a.fmobs?.length ? a.fmobs[0].fmob_motif_edition_la : '',
            FORMOB_date_validation : a.fmobs?.length ? a.fmobs[0].fmob_date_visa_militaire ? dayjs(a.fmobs[0].fmob_date_visa_militaire).format('DD/MM/YYYY') : '' : '',
            FORMOB_remarques: a.fmobs?.length ? a.fmobs[0].fmob_remarques_eventuelles_administres : '',
            FORMOB_avisCdF: a.fmobs?.length ? a.fmobs[0].fmob_avis_commandant_formation : '',
            FORMOB_departements_souhaites: a.a_liste_depts_souhaites_pam ? a.a_liste_depts_souhaites_pam.split(DEPARTEMENTS_SOUHAITES_SEPARATEUR) : [],
            FORMOB_zones_geographiques: a.a_liste_zones_geographiques_shm_pam ? a.a_liste_zones_geographiques_shm_pam.split(ZONES_SEPARATEUR) : [],
            FORMOB_statut: a.fmobs?.length ? a.fmobs[0].fmob_statut : '',

            // Périmètre
            perimetre_sousVivier_id: (a.sous_vivier && a.sous_vivier.sv_id) || '',
            perimetre_sousVivier_libelle: (a.sous_vivier && a.sous_vivier.sv_libelle) || '',

            // Commentaires à conserver
            PAMEnCours_notesUtilisateur: a.a_notes_gestionnaire || '',
            PAMEnCours_avis: a.a_statut_pam,
            PAMEnCours_marques: a.a_liste_id_marques ? a.a_liste_id_marques.split(MARQUES_SEPARATEUR) : [],
            PAMEnCours_anneePrevisibleMutation: a.a_annee_previsible_mutation,

            // Décisions nouvellement PAM en cours
            decision_decision: a.decision?.de_decision,
            decision_dateDecision: toStartOfDayOrDefault(a.decision?.de_date_decision),
            decision_administreId: a.decision ? a.decision?.administre || a.a_id_sap : '',
            decision_posteId: a.decision?.poste?.p_id,
            notes_pam: a.notes_pam,
            decision_ciat: a.a_ciat_pam ? true : false,
            decision_specifique: a.a_specifique_pam || '',

            decisions_possibles: a.decisions_possibles,
            profils: a.profils
        };

        return administreAdapte;
    }
    catch (e) {
        console.error('pb avec admin', a)
        throw e;
    }
    }

    /**
     * Génère l'objet columnDefs pour l'affichage d'une liste d'administrés.
     * @param {(string|import('../../../../jsdoc/types').ColGroupDefConstruction)[]} groupsAndColumns - Liste des groupes de colonnes et des colonnes à générer
     * @returns {import('../../../../jsdoc/types').AppColGroupDef[]} - Object columnDefs de définition des groupes de colonnes et colonnes à ajouter à la liste
     */
    buildAffectationPostesColumnDefs(groupsAndColumns) {
        return buildColumnDefs(groupsAndColumns, this.completeColumnDefs);
    }

    /**
     * Adapte les données des administrés reçues du backend pour l'affichage dans AG Grid.
     *
     * @param {Array.<Object>} notations - Liste des affectations pour un administré
     * @returns {Array.<Object>} liste mappée des administrés adaptés
     */
    adapteAffectationAdministresSuggereesPourPoste(notations) {
        return notations.map((a, index) => this.adapteAffectationAdministreSuggereePourPoste(a, index + 1));
    }

    /**
     * Adapte les données d'une affectation d'un poste reçue du backend, pour l'affichage dans AG Grid :
     * - Mapping des champs
     * - Ajout de valeur par défaut pour les données manquantes (généralement '')
     * - Ajout de certains champs calculés (ex : identite_age, service_temps)
     *
     * @param {<Object>} notation - Objet contenant les données issues du backend pour un administré
     * @param {<Number>} rang - rang
     * @returns {<Object>} Objet normalisé et complété, pour affichage dans AG Grid
     */
    adapteAffectationAdministreSuggereePourPoste(notation, rang = 0) {
        let administre = notation.administre;
        let grade = this.donneesReference.gradesById.get(administre.grade_id);

        return {
            // Id unique
            id: administre.a_id_sap || '',

            // Rang
            administre_rang: rang,

            // Identité
            identite_matricule: administre.a_id_sap || '',
            identite_grade: grade ? grade.code : '',
            identite_nom: administre.a_nom || '',
            identite_prenom: administre.a_prenom || '',
            identite_grade_nom_prenom: (grade ? grade.code + ' ' : '') + (administre.a_nom || '') + ' ' + (administre.a_prenom || ''),

            // Fonction
            fonction: administre.a_fonction || '',

            // Compétences
            competences_competences: administre.a_liste_id_competences ? administre.a_liste_id_competences.split(COMPETENCES_SEPARATEUR) : [],

            // Commentaires à conserver
            PAMEnCours_notesUtilisateur: administre.a_notes_gestionnaire || '',
            PAMEnCours_avis: administre.a_statut_pam_annee || '',
            PAMEnCours_marques: (administre.a_liste_id_marques && administre.a_liste_id_marques.split(MARQUES_SEPARATEUR)) || [],
            PAMEnCours_anneePrevisibleMutation: administre.a_annee_previsible_mutation,

            // Décisions nouvellement PAM en cours
            decision_decision: administre.decision__de_decision || '',
            decision_dateDecision: toStartOfDayOrDefault(administre.decision__de_date_decision),
            decision_administreId: administre?.decision__administre_id || administre.a_id_sap || '',
            decision_posteId: administre.decision__poste_id || '',
            notes_pam : administre.notes_pam || '',
            decision_ciat: administre.a_ciat_pam ? true : false,

            // PdV
            classement_administre: notation.no_score_administre,
            classement_poste: administre.nb_top || '',
            classement_coupleIdeal: !!notation.no_flag_cple_ideal
        };
    }

    /**
     * Création de la définition de tous les groupes de colonnes et de toutes les colonnes
     * @returns {import('../../../../jsdoc/types').AppColGroupDef[]}
     */
    buildCompleteColumnDefs = () => {
        const colDefs = [
            // ---------------------------------------------------------------------------------------------
            // IDENTITE
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'identite',
                headerName: 'Identité',
                children: [
                    {
                        colId: 'identite_matricule',
                        field: 'identite_matricule',
                        headerName: 'Matricule',
                        type: commonColTypes.textColumn,
                        width: 130,
                        filterParams: {
                            //filterOptions: ['contains', 'startsWith', 'endsWith'],
                            defaultOption: 'equals',
                            newRowsAction: 'keep'
                        }
                    },
                    {
                        colId: 'identite_grade',
                        field: 'identite_grade',
                        headerName: 'Grade',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 75
                    },
                    {
                        colId: 'identite_nom',
                        field: 'identite_nom',
                        headerName: 'Nom',
                        type: commonColTypes.textColumn,
                        comparator: nameComparator,
                        filterParams: { newRowsAction: 'keep'},
                        width: 120
                    },
                    {
                        colId: 'identite_prenom',
                        field: 'identite_prenom',
                        headerName: 'Prénom',
                        type: commonColTypes.textColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 100
                    },
                    {
                        colId: 'identite_age',
                        field: 'identite_age',
                        headerName: 'Âge',
                        type: commonColTypes.numberColumn,
                        filterParams: { newRowsAction: 'keep'},
                        columnGroupShow: 'open',
                        width: 68
                    },
                    {
                        colId: 'identite_sexe',
                        field: 'identite_sexe',
                        headerName: 'Se\u00ADxe',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        columnGroupShow: 'open',
                        width: 68
                    },
                    {
                        colId: 'identite_anciennete_grade',
                        field: 'identite_anciennete_grade',
                        headerName: 'Ancienneté grade',
                        type: commonColTypes.textColumn,
                        filterParams: { newRowsAction: 'keep'},
                        columnGroupShow: 'open',
                        width: 100
                    }
                ]
            },

            // ---------------------------------------------------------------------------------------------
            // EIP actuel
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'EIPActuel',
                headerName: 'EIP actuel',
                children: [
                    {
                        colId: 'EIPActuel_domaine',
                        field: 'EIPActuel_domaine',
                        headerName: 'Domaine',
                        type: commonColTypes.domaineColumn,
                        filterParams: { newRowsAction: 'keep'},
                    },
                    {
                        colId: 'EIPActuel_filiere',
                        field: 'EIPActuel_filiere',
                        headerName: 'Filière',
                        type: commonColTypes.filiereColumn,
                        filterParams: { newRowsAction: 'keep'},

                    },
                    {
                        colId: 'EIPActuel_NF',
                        field: 'EIPActuel_NF',
                        headerName: 'NF',
                        type: commonColTypes.NFColumn,
                        filterParams: { newRowsAction: 'keep'},
                    },
                    {
                        colId: 'EIPActuel_domaine_gestion',
                        field: 'EIPActuel_domaine_gestion',
                        headerName: 'Domaine de gestion (BVT)',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 200
                    }
                ]
            },
            // ---------------------------------------------------------------------------------------------
            // EIP futur (éditable)
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'EIPFutur',
                headerName: 'EIP futur',
                children: [
                    {
                        colId: 'EIPFutur_domaine',
                        field: 'EIPFutur_domaine',
                        headerName: 'Domaine',
                        type: [commonColTypes.domaineColumn],
                        editableIf: (params) => hasProfilLocal(params, [PROFILS.FILIERE, PROFILS.BVT], true),
                        filterParams: { newRowsAction: 'keep'},
                        cellClassRules: {
                            // Mise en valeur des changements entre EIP actuel et EIP futur
                            [cssClasses.valeurModifiee]: (params) => {
                                return params?.data && params.value !== params?.data?.EIPActuel_domaine;
                            }
                        }
                    },
                    {
                        colId: 'EIPFutur_filiere',
                        field: 'EIPFutur_filiere',
                        headerName: 'Filière',
                        type: [commonColTypes.filiereColumn],
                        editableIf: (params) => hasProfilLocal(params, [PROFILS.FILIERE, PROFILS.BVT], true),
                        filterParams: { newRowsAction: 'keep'},
                        cellClassRules: {
                            // Mise en valeur des changements entre EIP actuel et EIP futur
                            [cssClasses.valeurModifiee]: (params) => {
                                return params?.data && params.value !== params?.data?.EIPActuel_filiere;
                            }
                        }
                    },
                    {
                        colId: 'EIPFutur_NF',
                        field: 'EIPFutur_NF',
                        headerName: 'NF',
                        type: [commonColTypes.NFColumn],
                        editableIf: (params) => hasProfilLocal(params, [PROFILS.FILIERE, PROFILS.BVT], true),
                        filterParams: { newRowsAction: 'keep'},
                        cellClassRules: {
                            // Mise en valeur des changements entre EIP actuel et EIP futur
                            [cssClasses.valeurModifiee]: (params) => {
                                return params?.data && params.value !== params?.data?.EIPActuel_NF;
                            }
                        }
                    },
                    // {
                    //     colId: 'EIPFutur_domaine_filiere_NF',
                    //     field: 'EIPFutur_domaine_filiere_NF',
                    //     headerName: 'Dom. / Fil. / NF',
                    //     type: commonColTypes.setColumn,
                    //     filterParams: { newRowsAction: 'keep'},
                    //     width: 110,
                    //     valueGetter: (params) => {
                    //         return (
                    //             (params?.data?.EIPActuel_domaine || i18n.global.donnees.vide) +
                    //             ' / ' +
                    //             (params?.data?.EIPActuel_filiere || i18n.global.donnees.vide) +
                    //             ' / ' +
                    //             (params?.data?.EIPActuel_NF || i18n.global.donnees.vide)
                    //         );
                    //     },
                    //     notDisplayedByDefault: true
                    // }
                ]
            },

            // ---------------------------------------------------------------------------------------------
            // MATRIMONIAL
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'matrimonial',
                headerName: 'Matrimonial',
                children: [
                    {
                        colId: 'matrimonial_situation',
                        field: 'matrimonial_situation',
                        headerName: 'Situation',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 90
                    },
                    {
                        colId: 'matrimonial_emploiConjoint',
                        field: 'matrimonial_emploiConjoint',
                        headerName: 'Emploi du conjoint',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        columnGroupShow: 'open',
                        width: 150
                    },
                    {
                        colId: 'matrimonial_nbEnfants',
                        field: 'matrimonial_nbEnfants',
                        headerName: 'Nb enfants',
                        type: commonColTypes.numberColumn,
                        filterParams: { newRowsAction: 'keep'},
                        columnGroupShow: 'open',
                        width: 110
                    }
                ]
            },

            // ---------------------------------------------------------------------------------------------
            // AFFECTATION ACTUELLE
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'affectationActuelle',
                headerName: 'Affectation actuelle',
                children: [
                    {
                        colId: 'affectationActuelle_FE',
                        field: 'affectationActuelle_FE',
                        tooltipValueGetter: (params) =>
                            params?.data?.affectationActuelle_FE
                                ? params?.data?.affectationActuelle_FE + ' (' + params?.data?.affectationActuelle_libelle + ')'
                                : '',
                        headerName: 'Co\u00ADde FE fil\u00ADle',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 90
                    },
                    {
                        colId: 'affectationActuelle_libelle',
                        field: 'affectationActuelle_libelle',
                        headerName: 'FE fil\u00ADle',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 120
                    },
                    {
                        colId: 'affectationActuelle_lieu',
                        field: 'affectationActuelle_lieu',
                        headerName: 'Li\u00ADeu',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 120
                    },
                    {
                        colId: 'affectationActuelle_zoneDefense',
                        field: 'affectationActuelle_zoneDefense',
                        headerName: 'Zo\u00ADne de dé\u00ADfen\u00ADse',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        columnGroupShow: 'open',
                        width: 120
                    },
                    {
                        colId: 'affectationActuelle_codeFeMere',
                        field: 'affectationActuelle_codeFeMere',
                        headerName: 'Co\u00ADde FE mè\u00ADre',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        columnGroupShow: 'open',
                        width: 90
                    },
                    ,
                    {
                        colId: 'affectationActuelle_libelleFeMere',
                        field: 'affectationActuelle_libelleFeMere',
                        headerName: 'FE mè\u00ADre',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        columnGroupShow: 'open',
                        width: 120
                    },
                    extend(true, creerColDefDonneesFormatees(creerFormateurParams(params => getLibelleEtatFeFmob(params.value, getRefs(params)))), {
                        colId: 'affectationActuelle_etatFeBmob',
                        field: 'affectationActuelle_etatFeBmob',
                        headerName: 'Etat FE BMOB',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        cellClass: cssClasses.etatFe,
                        cellClassRules: this.donneesReference?.etatsFeBmob?.reduce((rules, val) => {
                            rules[val] = (params) => params.value === val;
                            return rules;
                        }, {}),
                        selecteur: { profils: [PROFILS.PCP, PROFILS.BVT] }
                    }),
                ]
            },
            
            // ---------------------------------------------------------------------------------------------
            // FONCTION
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'fonction',
                headerName: 'Fonction',
                children: [
                    {
                        colId: 'fonction_fonction',
                        field: 'fonction',
                        headerName: 'Fonc\u00ADtion',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 120
                    },
                ]
            },
            // ---------------------------------------------------------------------------------------------
            // AFFECTATION FUTURE
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'affectationFuture',
                headerName: 'Affectation future',
                children: [
                    {
                        colId: 'affectationFuture_libelleFeMere',
                        field: 'affectationFuture_libelleFeMere',
                        headerName: 'Libellé FE mère future',
                        type: commonColTypes.setColumn,
                        columnGroupShow: 'open',
                        filterParams: { newRowsAction: 'keep'},
                        width: 120
                    },
                    {
                        colId: 'affectationFuture_codeFeMere',
                        field: 'affectationFuture_codeFeMere',
                        tooltipValueGetter: (params) =>
                            params?.data?.affectationFuture_codeFeMere
                                ? params?.data?.affectationFuture_codeFeMere + ' (' + params?.data?.affectationFuture_libelleFeMere + ')'
                                : '',
                        headerName: 'Co\u00ADde FE mère future',
                        type: commonColTypes.setColumn,
                        columnGroupShow: 'open',
                        filterParams: { newRowsAction: 'keep'},
                        width: 90
                    },
                    {
                        colId: 'affectationFuture_FE',
                        field: 'affectationFuture_FE',
                        tooltipValueGetter: (params) =>
                            params?.data?.affectationFuture_FE
                                ? params?.data?.affectationFuture_FE + ' (' + params?.data?.affectationFuture_libelle + ')'
                                : '',
                        headerName: 'Co\u00ADde FE fille future',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 90
                    },
                    {
                        colId: 'affectationFuture_libelle',
                        field: 'affectationFuture_libelle',
                        headerName: 'Libellé FE fille future',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 120
                    },
                    {
                        colId: 'affectationFuture_lieu',
                        field: 'affectationFuture_lieu',
                        headerName: 'Li\u00ADeu',
                        type: commonColTypes.setColumn,
                        columnGroupShow: 'open',
                        filterParams: { newRowsAction: 'keep'},
                        width: 150
                    },
                    {
                        colId: 'affectationFuture_notes_FE',
                        field: 'affectationFuture_notes_FE',
                        headerName: 'No\u00ADtes FE',
                        type: [commonColTypes.editableColumn, commonColTypes.notesColumnNonEditable],
                        columnGroupShow: 'open',
                        filterParams: { newRowsAction: 'keep'},
                        width: 90
                    }
                    ,
                    {
                        colId: 'affectationFuture_dateAffectationFuture',
                        field: 'affectationFuture_dateAffectationFuture',
                        headerName: 'Da\u00ADte aff. Fu\u00ADtu\u00ADre',
                        type: [commonColTypes.BLANK, commonColTypes.dateColumn],
                        cellEditorParams: { nullable: true },
                        filterParams: { newRowsAction: 'keep'},
                        cellClassRules: {
                            [cssClasses.probleme]: (params) =>
                                params.value instanceof Date &&
                                params.value >= toStartOfDayOrDefault(dayjs()) &&
                                params.data?.affectationActuelle_FE !== params.data?.affectationFuture_FE
                        }
                    },
                ]
            },

            // ---------------------------------------------------------------------------------------------
            // SITUATION FUTURE
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'situationFuture',
                headerName: 'Situation future',
                children: [
                    extend(true, creerColDefDonneesRef((params) => getRefs(params)?.statutFuturById, { editeur: { valeurVide: null } }), {
                        colId: 'situationFuture_statutFutur',
                        field: 'situationFuture_statutFutur',
                        headerName: 'Sta\u00ADtut fu\u00ADtur',
                        type: [commonColTypes.editableColumn, commonColTypes.setColumn],
                        editableIf: (params) => hasProfilLocal(params, [PROFILS.FILIERE, PROFILS.BVT], true),
                        filterParams: { newRowsAction: 'keep'},
                    }),
                    {
                        colId: 'situationFuture_dateStatutFutur',
                        field: 'situationFuture_dateStatutFutur',
                        headerName: 'Da\u00ADte sta\u00ADtut fu\u00ADtur',
                        type: [commonColTypes.editableColumn, commonColTypes.dateColumn],
                        editableIf: (params) => hasProfilLocal(params, [PROFILS.FILIERE, PROFILS.BVT], true),
                        cellEditorParams: { nullable: true },
                        filterParams: { newRowsAction: 'keep'},
                    },
                    {
                        colId: 'service_dateRDC',
                        field: 'service_dateRDC',
                        headerName: 'Date RDC',
                        type: commonColTypes.dateColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 100
                    },
                    {
                        colId: 'situationFuture_statutConcerto',
                        field: 'situationFuture_statutConcerto',
                        headerName: 'Sta\u00ADtut ac\u00ADtu\u00ADel',
                        type: commonColTypes.setColumn,
                        columnGroupShow: 'open',
                        filterParams: { newRowsAction: 'keep'},
                    },
                    {
                        colId: 'situationFuture_dateStatutConcerto',
                        field: 'situationFuture_dateStatutConcerto',
                        headerName: 'Da\u00ADte sta\u00ADtut ac\u00ADtu\u00ADel',
                        type: commonColTypes.dateColumn,
                        columnGroupShow: 'open',
                        filterParams: { newRowsAction: 'keep'},
                    },
                    {
                        colId: 'situationFuture_statutConcertoFutur',
                        field: 'situationFuture_statutConcertoFutur',
                        headerName: 'Sta\u00ADtut CON\u00ADCER\u00ADTO fu\u00ADtur',
                        type: commonColTypes.setColumn,
                        columnGroupShow: 'open',
                        filterParams: { newRowsAction: 'keep'},
                    },
                    {
                        colId: 'situationFuture_dateStatutConcertoFutur',
                        field: 'situationFuture_dateStatutConcertoFutur',
                        headerName: 'Da\u00ADte sta\u00ADtut CON\u00ADCER\u00ADTO fu\u00ADtur',
                        type: commonColTypes.dateColumn,
                        columnGroupShow: 'open',
                        filterParams: { newRowsAction: 'keep'},
                    },
                    {
                        colId: 'situationFuture_fud',
                        field: 'situationFuture_fud',
                        headerName: 'FUD de dé\u00ADpart',
                        columnGroupShow: 'open',
                        filterParams: { newRowsAction: 'keep'},
                    },
                    {
                        colId: 'situationFuture_dateFud',
                        field: 'situationFuture_dateFud',
                        headerName: 'Da\u00ADte du FUD',
                        type: commonColTypes.dateColumn,
                        filterParams: { newRowsAction: 'keep'},
                        columnGroupShow: 'open',
                    },
                    extend(true, creerColDefDonneesRef((params) => getRefs(params)?.suiviPrevisionnelMilitaireById, { editeur: { valeurVide: null } }), {
                        colId: 'situationFuture_suiviPrevisionnel',
                        field: 'situationFuture_suiviPrevisionnel',
                        headerName: 'Sui\u00ADvi pré\u00ADvi\u00ADsion\u00ADnel de la si\u00ADtu\u00ADa\u00ADtion du mi\u00ADli\u00ADtai\u00ADre',
                        type: [commonColTypes.editableColumn, commonColTypes.setColumn],
                        editableIf: (params) => hasProfilLocal(params, [PROFILS.PCP, PROFILS.PCP_ACTUEL, PROFILS.PCP_FUTUR], true),
                        columnGroupShow: 'open',
                        filterParams: { newRowsAction: 'keep'},
                    }),
                    {
                        colId: 'situationFuture_dateSuiviPrevisionnel',
                        field: 'situationFuture_dateSuiviPrevisionnel',
                        headerName: 'Da\u00ADte du sui\u00ADvi pré\u00ADvi\u00ADsion\u00ADnel de la si\u00ADtu\u00ADa\u00ADtion du mi\u00ADli\u00ADtai\u00ADre',
                        type: [commonColTypes.editableColumn, commonColTypes.dateColumn],
                        editableIf: (params) => hasProfilLocal(params, [PROFILS.PCP, PROFILS.PCP_ACTUEL, PROFILS.PCP_FUTUR], true),
                        cellEditorParams: { nullable: true },
                        columnGroupShow: 'open',
                        filterParams: { newRowsAction: 'keep'},
                    },
                ]
            },

            // ---------------------------------------------------------------------------------------------
            // COMPETENCES DETENUES (non modifiable)
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'competences',
                headerName: 'Compétences détenues',
                children: [
                    {
                        colId: 'competences_competences',
                        field: 'competences_competences',
                        headerName: 'Compétences',
                        type: [commonColTypes.editableColumn, commonColTypes.competencesColumn],
                        editableIf: (params) => hasProfilLocal(params, [PROFILS.FILIERE, PROFILS.BVT], true),
                        cellEditorParams: {
                            maxSelectedItems: COMPETENCES_ADMINISTRES_MAX_ITEMS
                        },
                        filterParams: { newRowsAction: 'keep'},
                        width: 300
                    }
                ]
            },

            // ---------------------------------------------------------------------------------------------
            // SERVICE
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'service',
                headerName: 'Service',
                children: [
                    {
                        colId: 'service_temps',
                        field: 'service_temps',
                        headerName: 'Tem\u00ADps',
                        type: commonColTypes.numberColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 75
                    },
                    {
                        colId: 'service_dernierACR',
                        field: 'service_dernierACR',
                        headerName: 'Dernier ACR',
                        type: commonColTypes.dateColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 110
                    },
                    {
                        colId: 'service_arme',
                        field: 'service_arme',
                        headerName: 'Ar\u00ADme',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 70
                    },
                    {
                        colId: 'service_origine_recrutement',
                        field: 'service_origine_recrutement',
                        headerName: 'Origine de Recrutement',
                        type: commonColTypes.setColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 70
                    }
                ]
            },
            // ---------------------------------------------------------------------------------------------
            // FORMOB
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'FORMOB',
                headerName: 'FOR\u00ADMOB',
                children: [
                    {
                        colId: 'FORMOB_departements_souhaites',
                        field: 'FORMOB_departements_souhaites',
                        headerName: 'Départements souhaités',
                        type: [commonColTypes.editableColumn, commonColTypes.departementsColumn],
                        filterParams: { newRowsAction: 'keep'},
                        cellEditorParams: {
                            maxSelectedItems: DEPARTEMENTS_SOUHAITES_MAX_ITEMS
                        }
                    },
                    {
                        colId: 'FORMOB_zones_geographiques',
                        field: 'FORMOB_zones_geographiques',
                        headerName: 'Zones géographiques SHM',
                        type: ['editableColumn', 'zonegeographiqueColumn'],
                        filterParams: { newRowsAction: 'keep'},
                        cellEditorParams: {
                            maxSelectedItems: ZONE_GEO_SHM_ADMINISTRES_MAX_ITEMS
                        }
                    },
                    {
                        colId: 'FORMOB_motif',
                        field: 'FORMOB_motif',
                        headerName: 'Mo\u00ADtif',
                        type: 'setColumn',
                        filterParams: { newRowsAction: 'keep'},
                        width: 90
                    },
                    {
                        colId: 'FORMOB_date_validation',
                        field: 'FORMOB_date_validation',
                        headerName: 'Date validation FORMOB par administré',
                        type: 'setColumn',
                        filterParams: { newRowsAction: 'keep'},
                        width: 120
                    },
                    {
                        colId: 'FORMOB_remarques',
                        field: 'FORMOB_remarques',
                        headerName: 'Remarques',
                        type: [commonColTypes.editableColumn, commonColTypes.notesColumnNonEditable],
                        filterParams: { newRowsAction: 'keep'},
                    },
                    {
                        colId: 'FORMOB_avisCdF',
                        field: 'FORMOB_avisCdF',
                        headerName: 'Av\u00ADis CdF',
                        type: [commonColTypes.editableColumn, commonColTypes.notesColumnNonEditable],
                        filterParams: { newRowsAction: 'keep'},
                    },
                    {
                        colId: 'FORMOB_statut',
                        field: 'FORMOB_statut',
                        headerName: 'Statut FORMOB',
                        // type: [commonColTypes.editableColumn, commonColTypes.notesColumnNonEditable],
                        filterParams: { newRowsAction: 'keep'},
                    }
                ]
            },

            // ---------------------------------------------------------------------------------------------
            // Commentaires à conserver
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'PAMEnCours',
                headerName: 'Com\u00ADmen\u00ADtai\u00ADres à con\u00ADser\u00ADver',
                children: [
                    {
                        colId: 'PAMEnCours_notesUtilisateur',
                        field: 'PAMEnCours_notesUtilisateur',
                        headerName: 'No\u00ADtes',
                        type: [commonColTypes.editableColumn, commonColTypes.notesColumn],
                        filterParams: { newRowsAction: 'keep'},
                        selecteur: { profils: [PROFILS.FILIERE, PROFILS.BVT] }
                    },
                    {
                        colId: 'PAMEnCours_marques',
                        field: 'PAMEnCours_marques',
                        tooltipValueGetter: () => '',
                        headerName: 'Mar\u00ADques',
                        type: [commonColTypes.editableColumn, commonColTypes.setColumn],
                        cellRenderer: 'marquesCellRenderer',
                        cellEditor: 'marquesCellEditor',
                        width: 100,
                        filterParams: {
                            excelMode: FILTER_PARAMS_EXCEL_MODE,
                            cellRenderer: 'marquesCellRenderer',
                            suppressMiniFilter: true,
                            comparator: createMarquesComparator(this.donneesReference),
                            newRowsAction: 'keep',
                        }
                    },
                    {
                        colId: 'PAMEnCours_anneePrevisibleMutation',
                        field: 'PAMEnCours_anneePrevisibleMutation',
                        headerName: 'An\u00ADnée pré\u00ADvi\u00ADsi\u00ADble de mu\u00ADta\u00ADtion',
                        type: [commonColTypes.editableColumn, commonColTypes.numberColumn],
                        filterParams: { newRowsAction: 'keep'},
                        cellEditorParams: {
                            min: dayjs().year() - 20,
                            max: dayjs().year() + 20,
                            step: 1,
                            placeholder: 'AAAA',
                            nullable: true
                        }
                    },
                ]
            },

            // ---------------------------------------------------------------------------------------------
            // PAM en cours
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'decision',
                headerName: 'PAM en cours',
                children: [
                    extend(true,
                        creerColDefDonneesRef((params) => getRefs(params)?.avisAdministreById, {
                            formateurBase: creerFormateurParams(params => getLibelleAvisAdministre(params.value, getRefs(params))),
                        }),
                        {
                            colId: 'PAMEnCours_avis',
                            field: 'PAMEnCours_avis',
                            headerName: 'A\u00ADvis',
                            type: [commonColTypes.editableColumn, commonColTypes.setColumn],
                            cellClass: [cssClasses.administre, cssClasses.avis],
                            filterParams: { newRowsAction: 'keep'},
                            /* Attention : cellClass ne peut pas être utilisé car impossible d'effacer les anciennes classes appliquées. Cf. https://www.ag-grid.com/javascript-grid/cell-styles/#refresh-of-styles */
                            cellClassRules: this.donneesReference.avisAdministre.reduce((rules, ref) => {
                                rules[ref.code] = (params) => params.value === ref.code;
                                return rules;
                            }, {}),
                            //TODO gestion des undos lors de l'édition et/ou MAJ des données en backend
                            //TODO gestion des erreurs/exceptions lors de l'édition et/ou MAJ des données en backend
                            cellEditorParams: (params) => {
                                const refs = getRefs(params);
                                return {
                                    ...params.colDef.refDataCellEditorParams?.(params),
                                    stopEditing: customizeEditorAndStopEditing(params, (params, editor) => {
                                        const _isCancelAfterEnd = editor.isCancelAfterEnd.bind(editor);
                                        editor.isCancelAfterEnd = () => {
                                            const decision = params?.data?.decision_decision;
                                            const nouvelAvis = getAvisAdministre(refs, editor.getValue());
                                            if (decision && (!nouvelAvis || !nouvelAvis.affectationManuellePossible)) {
                                                alert(
                                                    `Cet administré est actuellement lié à un poste par la décision « ${getDecisionLabel(decision, refs)} ».\n\n`
                                                        + `Vous devez préalablement annuler cette liaison avant de pouvoir changer l'avis à « ${nouvelAvis?.libelle ?? ''} ».`
                                                );
                                                return true;
                                            }
                                            return _isCancelAfterEnd()
                                        }
                                    }),
                                }
                            },
                            width: 120
                        },
                    ),
                    {
                        colId: 'decision_decision',
                        field: 'decision_decision',
                        type: commonColTypes.decisionColumn,
                        filterParams: { newRowsAction: 'keep'},
                    },
                    {
                        colId: 'decision_dateDecision',
                        field: 'decision_dateDecision',
                        type: commonColTypes.dateDecisionColumn,
                        filterParams: { newRowsAction: 'keep'},
                    },
                    {
                        colId: 'notes_pam',
                        field: 'notes_pam',
                        headerName: 'Notes PAM',
                        type: [commonColTypes.editableColumn, commonColTypes.notesColumn],
                        filterParams: { newRowsAction: 'keep'},
                    },
                    {
                        colId: 'decision_ciat',
                        field: 'decision_ciat',
                        headerName: 'CIAT',
                        width: 70,
                        type: [commonColTypes.editableColumn, commonColTypes.setColumn],
                        tooltipValueGetter: (params) => {
                            if (!params.value) {
                                return '';
                            }
                            const choix = getRefs(params)?.CIATById?.get(params.value);
                            return choix ? choix.libelle : '[' + params.value + ']';
                        },
                        filterParams: {
                            newRowsAction: 'keep',
                            excelMode: FILTER_PARAMS_EXCEL_MODE,
                            valueFormatter: (params) => {
                                if (!params.value) {
                                    return '';
                                }
                                var isTrueSet = (params.value === 'true');
                                const choix = getRefs(params)?.CIATById?.get(isTrueSet);
                                return choix ? choix.libelle : '[' + params.value + ']';
                            }
                        },
                        cellRenderer: 'ciatCellRenderer',
                        cellEditor: 'agRichSelectCellEditor',
                        cellEditorParams: (params) => ({
                            values: [...this.donneesReference.CIAT.map((c) => c.id)],
                            formatValue: (value) => {
                                const choix = this.donneesReference.CIATById.get(value);
                                return choix ? choix.libelle : '';
                            },
                        }),
                    },
                    {
                        colId: 'decision_specifique',
                        field: 'decision_specifique',
                        headerName: 'PPE / SHM / ITD',
                        type: [commonColTypes.editableColumn, commonColTypes.setColumn],
                        width: 140,
                        tooltipValueGetter: (params) => {
                            if (!params.value) {
                                return '';
                            }
                            const choix = getRefs(params)?.SpecifiqueById?.get(params.value);
                            return choix ? choix.libelle : '[' + params.value + ']';
                        },
                        filterParams: {
                            newRowsAction: 'keep',
                            excelMode: FILTER_PARAMS_EXCEL_MODE,
                            valueFormatter: (params) => {
                                if (!params.value) {
                                    return '';
                                }
                                const choix = getRefs(params)?.SpecifiqueById?.get(params.value);
                                return choix ? choix.libelle : '[' + params.value + ']';
                            }
                        },
                        cellRenderer: 'specifiqueCellRenderer',
                        cellEditor: 'agRichSelectCellEditor',
                        cellEditorParams: (params) => ({
                            values: [...this.donneesReference.Specifique.map((c) => c.id)],
                            formatValue: (value) => {
                                const choix = this.donneesReference.SpecifiqueById.get(value);
                                return choix ? choix.libelle : '';
                            },
                        }),
                    },
                ]
            },

            // ---------------------------------------------------------------------------------------------
            // Rang (vue "Top N" seulement)
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'rang',
                headerName: 'Rang',
                children: [
                    {
                        colId: 'administre_rang',
                        field: 'administre_rang',
                        headerName: 'Rang',
                        type: commonColTypes.numberColumn,
                        filterParams: { newRowsAction: 'keep'},
                        pinned: 'left',
                        width: 60
                    }
                ]
            },

            // ---------------------------------------------------------------------------------------------
            // Classement (vue "Top N" seulement)
            // ---------------------------------------------------------------------------------------------
            {
                groupId: 'classement',
                headerName: 'Classement',
                children: [
                    {
                        colId: 'classement_administre',
                        field: 'classement_administre',
                        headerName: 'Administré',
                        type: commonColTypes.classementPourcentageColumn,
                        filterParams: { newRowsAction: 'keep'},
                        width: 65,
                        menuTabs: []
                    },
                    // {
                    //     colId: 'classement_poste',
                    //     field: 'classement_poste',
                    //     headerName: 'Nb top',
                    //     type: commonColTypes.positiveIntegerColumn,
                    //     filterParams: { newRowsAction: 'keep'},
                    //     width: 65,
                    //     menuTabs: []
                    // }
                ]
            }
        ];

        // --------
        // Ajout des versions non modifiables de certains groupes

        buildAndAddColGroupDefVariant(colDefs, 'EIPFutur', 'EIPFutur_NonEditable', {
            children: [
                {},
                {},
                {}
            ]
        });

        buildAndAddColGroupDefVariant(colDefs, 'FORMOB', 'FORMOB_NonEditable', {
            children: [
                {
                    // FORMOB_departements_souhaites
                    type: ['BLANK', 'departementsColumn'] // non éditable
                },
                {
                    // FORMOB_zones_geographiques
                    type: ['BLANK', 'zonegeographiqueColumn'] // non éditable
                },
                {
                    // FORMOB_motif
                },
                {
                    // FORMOB_date_validation
                },
                {
                    // FORMOB_remarques
                },
                {
                    // FORMOB_avisCdF
                },
                {
                    // FORMOB_statut
                }
            ]
        });

        buildAndAddColGroupDefVariant(colDefs, 'PAMEnCours', 'PAMEnCours_NonEditable', {
            children: [
                {
                    // PAMEnCours_notesUtilisateur
                    type: [commonColTypes.BLANK, commonColTypes.notesColumn]
                },
                {
                    // PAMEnCours_marques
                    type: [commonColTypes.BLANK, commonColTypes.setColumn]
                },
                {
                    // PAMEnCours_anneePrevisibleMutation
                    type: [commonColTypes.BLANK, commonColTypes.numberColumn]
                },
            ]
        });

        buildAndAddColGroupDefVariant(colDefs, 'decision', 'decision_NonEditable', {
            children: [
                {
                    // PAMEnCours_avis
                    type: [commonColTypes.BLANK, commonColTypes.setColumn]
                },
                {
                    // decision_decision
                    editable: false,
                    cellClassRules: { [commonCssClasses.editable]: getFalse }
                },
                {}, // decision_dateDecision
                {
                    // notes_pam
                    editable: false,
                    cellClassRules: { [commonCssClasses.editable]: getFalse }
                },
                {
                    // decision_ciat
                    type: [commonColTypes.BLANK, commonColTypes.setColumn]
                },
                {
                    // decision_specifique
                    type: [commonColTypes.BLANK, commonColTypes.setColumn]
                },
            ]
        });

        buildAndAddColGroupDefVariant(colDefs, 'decision', 'decision_PCP', {
            children: [
                {
                    // PAMEnCours_avis
                    type: [commonColTypes.BLANK, commonColTypes.setColumn]
                },
                {}, // decision_decision
                {}, // decision_dateDecision
                {}, // notes_pam
                {
                    // decision_ciat
                    type: [commonColTypes.BLANK, commonColTypes.setColumn]
                },
                {
                    // decision_specifique
                    type: [commonColTypes.BLANK, commonColTypes.setColumn]
                },
            ]
        });

        buildAndAddColGroupDefVariant(colDefs, 'affectationFuture', 'affectationFuture_PCP', {
            children: [
                {}, // affectationFuture_libelleFeMere
                {}, // affectationFuture_codeFeMere
                {}, // affectationFuture_FE
                {}, // affectationFuture_libelle
                {}, // affectationFuture_lieu
                {
                    // Notes Fe
                    type: [commonColTypes.editableColumn, commonColTypes.notesColumn]
                },
                {
                    // affectationFuture_dateAffectationFuture
                    type: [commonColTypes.editableIfDecisionColumn, commonColTypes.dateColumn]
                },
            ]
        });

        // --------
        return colDefs;
    };
}

export default AGGridConfigurationAdministres;
