import React, { useContext, useEffect, useState } from 'react';
import { observer } from 'mobx-react';

import { AppConfigContext } from '../../../stores/AppConfigStore';
import AGGridConfigurationAdministres from '../../Commun/listes/configuration/AGGridConfigurationAdministres';
import ListeGestionGlobaleEtPerimetre from '../Commun/ListeGestionGlobaleEtPerimetre';
import { createContext } from '../../Commun/listes/gridContext';
import { ADMINISTRES } from '../../../constantes/constantes';
import AdministresManager from '../../../data-manager/AdministresManager';
import { Chargement } from '../../Commun/Chargement';
import { useSWRInfinite } from 'swr';

/**
 * Composant générique permettant d'afficher une liste d'administrés du vivier global ou d'un sous-vivier.
 *
 * @component
 * @param {boolean} props.isVivierGlobal - Indique si on doit afficher la liste pour un vivier global (sinon c'est qu'il s'agit d'un sous-vivier)
 *
 * @example
 * return (
 * <ListeAdministres isVivierGlobal={true} />
 * )
 */
const ListeAdministres = observer((props) => {
    const appConfig = useContext(AppConfigContext);
    let administresManager = new AdministresManager();

    const [administresAdaptes, setAdministresAdaptes] = useState(undefined);

    //TODO à instancier une fois pour toute au niveau de l'application
    const agGridConfigurationAdministres = new AGGridConfigurationAdministres(appConfig.donneesReference);

    /*
     * Chargement des données du vivier global ou du sous-vivier sélectionné
     */
    const getKey = (index) => {
        return administresManager.buildCallKey(props.isVivierGlobal ? 0 : appConfig.idSousVivierSelectionne, { pageSize: 1000, page: index + 1 });
    };
    const { data, error, mutate, size, setSize } = useSWRInfinite(getKey, { refreshInterval: 0 });
    const fullData = data ? [].concat(...data.map((d) => d.results)) : [];

    // Permet de charger la page suivante de données s'il reste des données à charger
    useEffect(() => {
        if (data && data[data.length - 1].next) {
            setSize(size + 1);
        }
    }, [data]);

    useEffect(() => {
        if (typeof data !== 'undefined') {
            setAdministresAdaptes(agGridConfigurationAdministres.adapteAdministres(fullData || []));
        } else {
            //TODO: error handling ici
            if (typeof error == 'undefined') {
                console.info('Chargement des données des administrés...');
            } else {
                console.error(error);
            }
        }
    }, [data, error]);
    // Mise à jour des données suite au choix d'un autre sous-vivier

    useEffect(() => {
        // Lorsque les données ont été mises à jour, il faut mettre à jour aussi la sélection éventuelle
        if (administresAdaptes !== undefined && appConfig.hasSelectedAdministresGlobalEtPerimetre) {
            // On reconstruit la sélection
            const selectedIds = appConfig.selectedAdministresGlobalEtPerimetre.map((a) => a.id);
            const newSelection = administresAdaptes.flatMap((a) => (selectedIds.includes(a.id) ? a : []));
            appConfig.setSelectedAdministresGlobalEtPerimetre(newSelection);
        }
    }, [administresAdaptes]);

    // Revalidation des donnees par un button dans l'entete page
    useEffect(() => {
        mutate()
    }, [appConfig.donneesRecharger])

    /* Génération du paramétrage des groupes de colonnes et colonnes pour AG Grid */
    const administresFields = agGridConfigurationAdministres.buildAdministresColumnDefs((() => {
        if (props.isVivierGlobal) {
            return [
                'identite',
                'EIPFutur_NonEditable',
                'affectationActuelle',
                'competences_NonEditable',
                {
                    groupId: 'decision_NonEditable',
                    columns: ['PAMEnCours_avis', 'decision_decision']
                },
                'affectationFuture',
                'FORMOB_NonEditable',
                'EIPActuel',
                'matrimonial',
                'service',
                'perimetre'
            ];
        }
        const gestionnairePcp = appConfig.isPCP;
        return [
            'identite',
            gestionnairePcp ? 'EIPFutur_NonEditable' : 'EIPFutur',
            'affectationActuelle',
            'fonction', // TODO intégrér dans 'affectationActuelle'
            gestionnairePcp ? 'competences_NonEditable' : 'competences',
            gestionnairePcp ? {
                groupId: 'PAMEnCours_NonEditable',
                columns: ['PAMEnCours_marques', 'PAMEnCours_anneePrevisibleMutation']
            } : 'PAMEnCours',
            gestionnairePcp ? 'decision_PCP' : 'decision',
            gestionnairePcp ? 'affectationFuture' : 'affectationFuture_NonEditable',
            gestionnairePcp ? 'situationFuture_NonEditable': 'situationFuture',
            gestionnairePcp ? 'FORMOB_NonEditable': 'FORMOB',
            'EIPActuel',
            'matrimonial',
            'service'
        ];
    })());

    return (
        <div className={'d-flex flex-column h-100'}>
            {data ? (
                <ListeGestionGlobaleEtPerimetre
                    columnDefs={administresFields}
                    data={administresAdaptes ?? []}
                    nbItems={fullData.length}
                    reqData={fullData}
                    mutator={mutate}
                    title="Administrés"
                    itemLabel="administré"
                    itemsLabel="administrés"
                    context={createContext(appConfig, ADMINISTRES)}
                    isVivierGlobal={props.isVivierGlobal}
                    isLoadingData={administresAdaptes ? data[0].count > administresAdaptes.length : true}
                />
            ) : (
                <Chargement />
            )}
        </div>
    );
});

export default ListeAdministres;
