import axios from 'axios';
import { POSTES } from '../constantes/constantes';
import AppConfigStore from '../stores/AppConfigStore';
import AbstractDataManager from './AbstractDataManager';
import AdministresManager from './AdministresManager';
import PostesManager from './PostesManager';

/**
 * Classe effectuant les opérations spécifiques à l'aide à la décision, via l'API REST.
 *
 * @class
 */
export default class DecisionManager extends AbstractDataManager {
    //
    static DECISION_ENDPOINT = 'decisions';
    static SCORING_ENDPOINT = 'scoring';
    static ARRET_ENDPOINT = 'arret';

    /**
     * Constructeur
     * @constructor
     * @param {?AppConfigStore} appConfig
     */
    constructor(appConfig) {
        super(appConfig);
    }

    /**
     * Lance les calculs (ranking et matching) nécessaires à l'aide à la décision, pour un sous-vivier donné.
     *
     * @param {number} idSousVivier - Id du sous-vivier sur lequel lancer les calculs.
     * @param {*} params - Paramètres éventuels de lancement
     * @returns {Promise<any>} - Promesse de résultats
     */
    async lanceCalculs(idSousVivier, idPam, params = {}) {
        const url = this.buildFetchURL(DecisionManager.SCORING_ENDPOINT, params);
        return axios.post(url, { sous_vivier_id: idSousVivier, pam_id: idPam});
    }

    /**
     * Lance les calculs (ranking et matching) nécessaires à l'aide à la décision, pour un sous-ensemble de postes et d'administrés donné
     *
     * @param {string} administreId - Id administre
     * @param {string} posteId - Id du poste
     * @param {Number} sousVivierId
     * @param {*} params - Paramètres éventuels de lancement
     * @returns {Promise<any>} - Promesse de résultats
     */
    async lanceCalculSelectif(sousVivierId, administreId, posteId, pamId, params = {}) {
        const url = this.buildFetchURL(DecisionManager.SCORING_ENDPOINT, params);
        let data = { sous_vivier_id: sousVivierId, administre_id: administreId, poste_id: posteId, pam_id: pamId};
        return axios.post(url, data);
    }


     /**
     * Arrêter les calculs (ranking et matching) nécessaires à l'aide à la décision, pour un sous-vivier donné.
     *
     * @param {number} idSousVivier - Id du sous-vivier sur lequel arrêter les calculs.
     * @param {*} params - Paramètres éventuels de l'arret
     * @returns {Promise<any>} - Promesse de résultats
     */
    async arretCalcul(idSousVivier, pamId, params = {}) {
        const url = this.buildFetchURL(DecisionManager.ARRET_ENDPOINT, params);
        return axios.post(url, { sous_vivier_id: idSousVivier, pam_id: pamId });
    }

    /**
     * Arrêter les calculs (ranking et matching) nécessaires à l'aide à la décision, pour un sous-vivier donné.
     *
     * @param {string} administreId - Id administre
     * @param {string} posteId - Id du poste
     * @param {Number} sousVivierId
     * @param {*} params - Paramètres éventuels de l'arret
     * @returns {Promise<any>} - Promesse de résultats
     */
    async arretCalculSelectif(sousVivierId, administreId, posteId, pamId, params = {}) {
        const url = this.buildFetchURL(DecisionManager.ARRET_ENDPOINT, params);
        let data = { sous_vivier_id: sousVivierId, administre_id: administreId, poste_id: posteId, pam_Id: pamId};
        return axios.post(url, data);
    }

    /**
     * Retourne une clé associé à la vue aide à la décision pour les postes ou administés sur un sous-vivier donné
     *
     * @param sous_vivier - ID du sous_vivier
     * @param by - vue aide à la décision by poste ou by administrés
     * @param {*} params - Paramètres éventuels de lancement
     * @returns {string} - Promesse de résultats
     */
    buildCallKey(sous_vivier, by, params) {
        let endpoint = AdministresManager.ENDPOINT_DEFAUT;
        let baseParams = {
            // a_statut_pam__in: this.appConfig.donneesReference?.avisAdministre
            //     ?.filter((ap) => ap.inclusAlgo)
            //     .map((avis) => avis.code)
            //     .join(','),
            aide_a_la_decision: this.appConfig.PAMSelectionne,
            
        };
        if (by == POSTES) {
            endpoint = PostesManager.ENDPOINT_DEFAUT;
            baseParams = { aide_a_la_decision: this.appConfig.PAMSelectionne }; // OK
        }
        const url = this.buildFetchURL(endpoint, { ...params, ...baseParams, ...{ sous_vivier: sous_vivier } });
        return url.toString();
    }

    /**
     * Retourne une clé associé à la vue aide à la décision pour les postes ou administés sur un sous-vivier donné
     *
     * @param sous_vivier - ID du sous_vivier
     * @param annee - ID du pam
     * @param by - vue aide à la décision by poste ou by administrés
     * @param {*} params - Paramètres éventuels de lancement
     * @returns {string} - Promesse de résultats
     */
    buildCalculStatusKey(sous_vivier, pam) {
        return this.buildFetchURL(DecisionManager.SCORING_ENDPOINT, { sous_vivier_id: sous_vivier, pam_id: pam });
    }

    /**
     * Retourne une clé associé à la vue aide à la décision pour les postes ou administés sur un sous-vivier donné
     *
     * @param administreId
     * @param posteId
     * @param sous_vivierId
     * @param by - vue aide à la décision by poste ou by administrés
     * @param {*} params - Paramètres éventuels de lancement
     * @returns {string} - Promesse de résultats
     */
    buildCalculSelectifStatusKey(sous_vivierId, administreId, posteId, pamId) {
        let data =  {sous_vivier_id: sous_vivierId, administre_id: administreId, poste_id: posteId, pam_id: pamId};
        return this.buildFetchURL(DecisionManager.SCORING_ENDPOINT, data);
    }

    /**
     * Met à jour une décision
     *
     * @param {string} posteId - Id du poste
     * @param {*} data
     */
    async update(administreId, data, params) {
        console.log('DecisionManager update', administreId, data);
        const url = this.buildPatchURL(DecisionManager.DECISION_ENDPOINT, administreId, params);
        return axios.patch(url, data);
    }

    /**
     * Crèe une décision
     *
     * @param {string}  administreId    - Id administre
     * @param {string}  posteId         - Id du poste
     * @param {string}  decision        - statut de décision
     * @param {boolean} supprimerAncien - true pour supprimer la décision actuelle de l'administré (si elle existe)
     */
    async decide(administreId, posteId, decision, supprimerAncien, params) {
        console.log('DecisionManager decide', { administreId, posteId, decision, supprimerAncien });
        const url = this.buildFetchURL(DecisionManager.DECISION_ENDPOINT, params);
        let data = { administre_id: administreId, poste_id: posteId, de_decision: decision, delete_former: supprimerAncien};
        return axios.post(url, data);
    }

    /**
     * Supprime une décision
     *
     * @param {string} administreId - Id administre (id de décision)
     */
    async destroy(administreId) {
        console.log('DecisionManager destroy', administreId);
        const url = this.buildFetchURL(DecisionManager.DECISION_ENDPOINT + '/' + administreId, {});
        return axios.delete(url);
    }

}
