import { observer } from 'mobx-react';
import React, { useContext, useEffect, useState } from 'react';
import useSWR from 'swr';
import { LISTE_TYPE_SUGGESTIONS } from '../../../constantes/constantes';
import AppConfigStore, { AppConfigContext } from '../../../stores/AppConfigStore';
import { Chargement } from '../../Commun/Chargement';
import { Erreur } from '../../Commun/Erreur';
import AGGridConfigurationPostes from '../../Commun/listes/configuration/AGGridConfigurationPostes';
import ListeAffectations from '../Commun/ListeAffectations';

/**
 * Composant présentant la liste des affectations (postes) suggérées par les algorithmes de classement et de matching pour l'administré sélectionné
 * dans la vue d'aide à la décision sous forme d'une liste présentant à la fois le matching parfait éventuel et le top N.
 *
 * @component
 */
export const ListeAffectationsSuggereesAdministre = observer(({ context, idPosteDejaAffecte }) => {
    /** @type {AppConfigStore} */
    const appConfig = useContext(AppConfigContext);

    const agGridConfigurationPostes = new AGGridConfigurationPostes(appConfig.donneesReference);

    /* Génération du paramétrage des groupes de colonnes et colonnes pour AG Grid */
    const affectationsSuggereesFields = agGridConfigurationPostes.buildAffectationAdministresColumnDefs([
        'rang',
        {
            groupId: 'organisme',
            columns: [
                {
                    colId: 'organisme_departement',
                    override: { width: 60 }
                },
                {
                    colId: 'organisme_FE'
                },
                {
                    colId: 'organisme_libelle'
                },
                {
                    colId: 'organisme_lieu'
                }
            ]
        },
        {
            groupId: 'poste_NonEditable',
            columns: [
                {
                    colId: 'poste_id',
                    override: { filter: false }
                },
                {
                    colId: 'poste_domaine',
                    override: { filter: false }
                },
                {
                    colId: 'poste_filiere',
                    override: { filter: false }
                },
                {
                    colId: 'poste_NF',
                    override: { filter: false }

                },
                {
                    colId: 'poste_ETR',
                    override: { filter: false }
                },
                {
                    colId: 'PAMEnCours_marques',
                    override: {
                        filter: false,
                        columnGroupShow: 'open'
                    }
                },
                {
                    colId: 'poste_CIAT',
                    override: {
                        filter: false,
                        columnGroupShow: 'open'
                    }
                },
                {
                    colId: 'poste_specifique',
                    override: {
                        filter: false,
                        columnGroupShow: 'open'
                    }
                },
                {
                    colId: 'poste_competences',
                    override: { width: 100, filter: false, type: ['competencesColumn'] }
                },
            ]
        },
        'avis_NonEditable',
        'classement',
    ]);

    const annee = appConfig.PAMSelectionne;
    const params = {};
    annee && (params.pam__in = annee);
    const getKey = () => appConfig.managers.administres.buildRankingFetchKey(appConfig.selectedAdministreDecision.id_pam, params);
    const { data, error } = useSWR(getKey);

    const [mpEtTopN, setMpEtTopN] = useState(undefined);

    useEffect(() => {
        if (data) {
            // Construction de la liste du MP éventuel + suggestions de postes
            const tmpMpEtTopN = [];

            // Matching parfait éventuel
            const mpIndex = data.findIndex((d) => d.no_flag_cple_ideal === true);
            const mpData = mpIndex >= 0 ? data[mpIndex] : null;
            if (mpData) {
                const mp = agGridConfigurationPostes.adapteAffectationPosteSuggereePourAdministre(
                    mpData,
                    mpIndex + 1 + ' ★',
                    appConfig.selectedAdministreDecision.id
                );
                mp.coupleIdealEnTeteDeListe = true;
                tmpMpEtTopN.push(mp);
            }

            // Postes du top N
            data.forEach((pData, index) => {
                if (index != 0 || mpIndex != 0) {
                    tmpMpEtTopN.push(
                        agGridConfigurationPostes.adapteAffectationPosteSuggereePourAdministre(
                            pData,
                            index + 1 + (index == mpIndex ? ' ★' : ''),
                            appConfig.selectedAdministreDecision.id
                        )
                    );
                }
            });

            // On flag l'éventuel poste déjà affecté à l'administré dans la liste (faute d'avoir reçu l'info dans les data)
            if (idPosteDejaAffecte) {
                const pda = tmpMpEtTopN.find((p) => p.id == idPosteDejaAffecte);
                if (pda) {
                    pda.isPosteAffecteAAdministreSelectionne = true;
                }
            }

            setMpEtTopN(tmpMpEtTopN);
        }
    }, [data, idPosteDejaAffecte]);

    return (
        <>
            {!mpEtTopN ? (
                error ? (
                    <Erreur />
                ) : (
                    <Chargement />
                )
            ) : (
                <>
                    <h3 className="AffectationSuggereesHeader">Affectations suggérées par les algorithmes de classement et de matching</h3>
                    <ListeAffectations
                        columnDefs={affectationsSuggereesFields}
                        data={mpEtTopN}
                        nbItems={mpEtTopN.length}
                        label={'affectation'}
                        context={{ ...context, ...{ listeType: LISTE_TYPE_SUGGESTIONS } }}
                    />
                </>
            )}
        </>
    );
});
