import extend from 'just-extend';
import { action, autorun, computed, makeObservable, observable } from 'mobx';
import { createContext } from 'react';
import { toast } from 'react-toastify';
import { commonAGGridColumnTypes } from '../components/Commun/listes/commonAGGridColumnTypes';
import { ADMINISTRES, ADMINISTRES_POSTES, DECISIONS, POSTES, PROFILS, STATUTS_CALCUL, TAUX_ARMEMENT_FE } from '../constantes/constantes';
import AdministresManager from '../data-manager/AdministresManager';
import DecisionManager from '../data-manager/DecisionManager';
import DonneesReferenceFetcher from '../data-manager/DonneesReferenceFetcher';
import PostesManager from '../data-manager/PostesManager';
import UtilisateurManager from '../data-manager/UtilisateurManager';
import { donneesReferenceComplementaires } from '../data/donnees-reference-complementaires';
import ActionsMetierHelper from '../helpers/ActionsMetierHelper';
import { comparer } from '../helpers/comparators';
import { arrayToMap } from '../helpers/data-manipulation';
import { isPresent } from '../helpers/objects';

/**
 * Store contenant les éléments de configuration de l'application, notamment eux propres à l'utilisateur courant, notamment :
 * - utilisateur connecté
 * - données de référence
 * - paramétrage des vues
 * - éléments sélectionnés
 * - ...
 */
class AppConfigStore {
    // Indique si le store est complètement initialisé
    ready = false;

    error = false;

    // Indique si les données doit etre recharger
    donneesRecharger = false;

    // Vue sélectionnée pour l'écran "Mon périmètre"
    typeVuePerimetre = ADMINISTRES_POSTES;


    // Vue sélectionnée pour l'écran "Aide à la décision"
    vueDecision = POSTES;

    //vue sélectionn"e pour l'écran "PAM A + 1"
    vuePam = ADMINISTRES_POSTES;

    // Indicateurs sélectionnés pour l'écran "Indicateurs"
    typeIndicateurs = TAUX_ARMEMENT_FE;

    // Vue sélectionnée pour l'écran "Indicateurs : Suivi du PAM"
    vueIndicateursPAM = POSTES;

    //Selection d'administrés et de postes
    selectAdministreSelectifPamA = null;
    selectAdministreSelectifPamA1 = null;
 

    selectPosteSelectifPamA = null;
    selectPosteSelectifPamA1 = null;


    //Id du sous-vivier sélectionné
    idSousVivierSelectionne = null;

    //PAM sélectionné
    PAMSelectionne = null;

    /**
     * IDs des formations-emplois sélectionnées
     * @type {string[]}
     */
    idsFormationsEmploisSelectionnees = [];

    idsSousViviersSelectionnees = []

    //Liste des FE du sous-vivier sélectionné
    feSousVivierSelectionne = [];

    // FE (du sous-vivier actuel) sélectionnée dans la vue Postes
    feSelected = null;

    // Booléen pour afficher seulement les données du gestionnaire sur la vue Indicateurs
    affichagePCP = false;

    // Booléen pour savoir si l'application de l'affichage PCP a été fait
    loadingPCP = false;

    /**
     * Utilisateur connecté
     * @type {?import('../jsdoc/api').UtilisateurApi}
     */
    utilisateurConnecte = null;

    /**
     * profil sélectionné parmi les profils sélectionnables
     * @type {?import('../jsdoc/types').Profil}
     */
    profilSelectionne = null;

    /**
     * Données de référence
     * @type {import('../jsdoc/types').DonneesReference}
     */
    donneesReference = null;

    // Poste(s) sélectionné(s) dans la vue 'Mon périmètre' et dans la vue 'ITD'
    selectedPostesPerimetreEtITD = [];

    // Administré(s) sélectionné(s) dans la vue 'Mon périmètre'
    selectedAdministresPerimetre = [];

    // Poste sélectionné dans la vue 'Aide à la décision'
    selectedPosteDecision = null;

    // Administré sélectionné dans la vue 'Aide à la décision'
    selectedAdministreDecision = null;

    // Statut du calcul d'aide à la décision
    statutCalculAideDecision = STATUTS_CALCUL.AUCUN;

    // Administré dont il faut afficher la fiche détaillée
    administreFicheDetaillee = undefined;

    posteSureffectif = undefined;

    actionsMetierHelper = new ActionsMetierHelper(this);

    managers = {
        administres: new AdministresManager(this),
        decisions: new DecisionManager(this),
        postes: new PostesManager(this)
    }

    constructor() {
        makeObservable(this, {
            utilisateurConnecte: observable,
            setUtilisateurConnecte: action,

            ready: observable,
            setReady: action,

            error: observable,
            setError: action,

            donneesRecharger: observable,
            toggleDonneesRecharger: action,

            donneesReference: observable,
            setDonneesReference: action,

            selectAdministreSelectifPamA : observable,
            setAdministreSelectifPamA : action,

            selectAdministreSelectifPamA1 : observable,
            setAdministreSelectifPamA1 : action,

            selectPosteSelectifPamA : observable,
            setPosteSelectifPamA : action,

            selectPosteSelectifPamA1 : observable,
            setPosteSelectifPamA1 : action,

            typeVuePerimetre: observable,
            setTypeVuePerimetre: action,

            vuePam: observable,
            setVuePam: action,

            vueDecision: observable,
            setVueDecision: action,

            typeIndicateurs: observable,
            setTypeIndicateurs: action,

            vueIndicateursPAM: observable,
            setVueIndicateursPAM: action,

            idSousVivierSelectionne: observable,
            setIdSousVivierSelectionne: action,

            idsSousViviersSelectionnees: observable,
            setIdsSousViviersSelectionnees: action,

            PAMSelectionne: observable,
            setPAMSelectionne: action,

            idsFormationsEmploisSelectionnees: observable,
            setIdsFormationsEmploisSelectionnees: action,

            feSousVivierSelectionne: observable,
            setFeSousVivierSelectionne: action,

            sousViviersUtilisateurConnecte: computed,

            feSelected: observable,
            setFeSelected: action,

            groupeFePCP: computed,

            profilsSelectionnables: computed,
            profilSelectionne: observable,
            setProfilSelectionne: action,

            affichagePCP: observable,
            setAffichagePCP: action,

            loadingPCP: observable,
            setLoadingPCP: action,

            selectedPosteDecision: observable,
            setSelectedPosteDecision: action,

            selectedAdministreDecision: observable,
            setSelectedAdministreDecision: action,

            hasSelectedAdministreDecision: computed,
            hasSelectedPosteDecision: computed,

            selectedPostesPerimetreEtITD: observable,
            setSelectedPostesPerimetreEtITD: action,

            selectedAdministresPerimetre: observable,
            setSelectedAdministresPerimetre: action,

            hasSelectedPostesPerimetreEtITD: computed,
            hasSelectedAdministresPerimetre: computed,

            statutCalculAideDecision: observable,
            setStatutCalculAideDecision: action,

            administreFicheDetaillee: observable,
            setAdministreFicheDetaillee: action
        });

        autorun(() => console.log('store report:', this.report));

        // Initialisation asynchrone des données de référence
        this.initAppData();
    }

    /**
     * Initialisation des données de l'application : utilisateur et données de référence.
     */
    async initAppData() {
        // --- Chargement des données de l'utilisateur

        const utilisateurManager = new UtilisateurManager();
        let authResponse;
        let utilisateurData = null;
        try {
            authResponse = await utilisateurManager.fetch().catch((reason) => {
                console.error(reason);
                toast.error("Une erreur est survenue lors du chargement des données de l'utilisateur. Veuillez contacter un administrateur.", {
                    autoClose: false
                });
            });
            //console.log('auth response', authResponse);
            utilisateurData = authResponse?.data;
            //console.log(utilisateurData);
            if (utilisateurData) {
                // --- Tri des sous-viviers de l'utilisateur par ordre alphabétique
                if (utilisateurData.sous_viviers) {
                    utilisateurData.sous_viviers.sort((a, b) => a.sv_libelle.localeCompare(b.sv_libelle));
                }

                // --- Chargement des données de référence
                /** @type {import('../jsdoc/api').DonneesReferenceApi} */
                let donneesRef = donneesReferenceComplementaires;

                const donneesReferenceFetcher = new DonneesReferenceFetcher();

                let response;
                try {
                    response = await donneesReferenceFetcher.fetchAll({});

                    //console.log('fetchDonneesReference', response);

                    // Fusion des donnes de référence chargées avec celles "en dur"
                    extend(true, donneesRef, response?.data);
                    //extend(true, donneesRef, donneesReferenceStub);

                    // Tri et indexation des données de référence
                    this.triEtIndexeDonneesReference(donneesRef);

                    // Les données de référence sont prêtes => on les stocke dans le store
                    this.setDonneesReference(donneesRef);

                    // Stockage de l'utilisateur connecté dans le store
                    this.setUtilisateurConnecte(utilisateurData);

                    this.setError(false);
                } catch (error) {
                    toast.error('Erreur de chargement des données de référence.', { autoClose: false });
                    console.error(error);
                    this.setError(true);
                }
                ((refs, col) => {
                    if (refs?.length && col) {
                        col.cellClassRules = refs.reduce((rules, decision) => {
                            const d = decision.code;
                            d && d !== DECISIONS.AUCUNE && (rules[d] = (params) => params.value === d);
                            return rules;
                        }, col.cellClassRules ?? []);
                    }
                })(donneesRef.decisions, commonAGGridColumnTypes.decisionColumn);
            }
        } catch (error) {
            console.error(error);
            this.setError(true);
        }

        // Le store est enfin prêt !
        this.setReady(true);
    }

    /**
     * Tri et indexation des données de référence
     * @param {import('../jsdoc/types').DonneesReference} donneesRef
     */
    triEtIndexeDonneesReference(donneesRef) {
        // Tri des avis sur un poste par ordre déterminé
        donneesRef.avisPoste.sort((() => {
            const ordre = ['P1', 'P2', 'P3', 'P4', 'GELE', 'NON_ETUDIE'];
            const indexMap = new Map(ordre.map((elem, idx) => [elem, idx]));
            return (a, b) => comparer(indexMap.get(a?.code), indexMap.get(b?.code)) || comparer(a?.code, b?.code);
        })());

        // Création d'une Map des avis sur les postes
        donneesRef.avisPosteById = arrayToMap(donneesRef.avisPoste, 'code');
        donneesRef.avisPosteDefaut = donneesRef.avisPoste.find((v) => v.code === 'NON_ETUDIE')?.code;

        // Création d'une Map des statuts de décisions
        donneesRef.decisionsById = arrayToMap(donneesRef.decisions, 'code');

        donneesRef.domaines.sort(function (a, b) {
            return (a.code || '').localeCompare(b.code);
        });

        // Création d'une hashmap des domaines
        donneesRef.domainesById = arrayToMap(donneesRef.domaines, 'id');

        // Tri des filières par domaine puis par ordre alphabétique sur le code
        donneesRef.filieres.sort(function (a, b) {
            return a.domaineId - b.domaineId || (a.code || '').localeCompare(b.code);
        });

        // Création d'une hashmap des filières
        donneesRef.filieresById = arrayToMap(donneesRef.filieres, 'id');

        // Tri des niveaux fonctionnels par ordre alphabétique sur le code
        donneesRef.NF.sort(function (a, b) {
            return (a.code || '').localeCompare(b.code);
        });

        // Création d'une hashmap des NF
        donneesRef.NFById = arrayToMap(donneesRef.NF, 'id');

        // Tri des grades par ordre
        donneesRef.grades.sort(function (a, b) {
            return a.ordre - b.ordre;
        });

        // TODO : voir si nécessaire de conserver la liste de toutes les FE dans les données de références étant donné qu'on a celles par sous-vivier
        // Tri des FEs par ordre alphabétique sur le code
        donneesRef.FEs.sort(function (a, b) {
            return (a.code || '').localeCompare(b.code);
        });

        // Création d'une hashmap des FEs
        donneesRef.FEsById = arrayToMap(donneesRef.FEs, 'id');

        // Création d'une hashmap des grades
        donneesRef.gradesById = arrayToMap(donneesRef.grades, 'id');

        // Tri des avis sur un administré par ordre déterminé
        donneesRef.avisAdministre.sort((() => {
            const ordre = ['A_TRAITER', 'NON_ETUDIE', 'A_MAINTENIR', 'PARTANT', 'NON_DISPONIBLE', 'A_ETUDIER_REC', 'A_MUTER', 'A_ETUDIER'];
            const indexMap = new Map(ordre.map((elem, idx) => [elem, idx]));
            return (a, b) => comparer(indexMap.get(a?.code), indexMap.get(b?.code)) || comparer(a?.code, b?.code);
        })());

        // Création d'une hashmap des avis sur un administré
        donneesRef.avisAdministreById = arrayToMap(donneesRef.avisAdministre, 'code');

        // Création d'une hashmap des groupes de marques
        donneesRef.groupesMarquesById = arrayToMap(donneesRef.groupesMarques, 'id');

        // Création d'une hashmap des priorité FE
        donneesRef.prioriteFeById = arrayToMap(donneesRef.prioriteFE, 'id');

        // Création d'une hashmap des priorité DRHAT
        donneesRef.prioriteDrhatById = arrayToMap(donneesRef.prioriteDRHAT, 'id');

        // Création d'une hashmap des marques
        donneesRef.marquesById = arrayToMap(donneesRef.marques, 'id');

        // Création d'une map des statuts futurss
        donneesRef.statutFuturById = arrayToMap(donneesRef.statutFutur, 'code');

        //Création d'un map direct/commissionné
        donneesRef.directCommissionneById = arrayToMap(donneesRef.directCommissionne, 'id');

        //Création d'un map CIAT
        donneesRef.CIATById = arrayToMap(donneesRef.CIAT, 'id');

        //Création d'un map CIAT
        donneesRef.PAMByStatut = arrayToMap(donneesRef.pams, 'pam_statut');

        //Création d'un map des données spécifiques (PPE/SHM/ITD)
        donneesRef.SpecifiqueById = arrayToMap(donneesRef.Specifique, 'id');

        //Création d'un map suvi/prévisionnel
        donneesRef.suiviPrevisionnelMilitaireById = arrayToMap(donneesRef.suiviPrevisionnelMilitaire, 'id');

        // Association des marques à leur groupe
        for (let groupeMarques of donneesRef.groupesMarques) {
            groupeMarques.marques = [];
        }
        for (let marque of donneesRef.marques) {
            donneesRef.groupesMarquesById.get(marque.groupeMarquesId).marques.push(marque);
        }

        // Tri des groupes de marques, par ordre croissant
        donneesRef.groupesMarques.sort(function (gm1, gm2) {
            return gm1.ordre - gm2.ordre;
        });

        // Tri des marques au sein des groupes, par ordre croissant
        for (let groupeMarques of donneesRef.groupesMarques) {
            groupeMarques.marques.sort(function (m1, m2) {
                return m1.ordre - m2.ordre;
            });
        }

        // Tri des compétences par ordre alphabétique sur le libellé
        donneesRef.competences.sort(function (a, b) {
            return (a.libelle || '').localeCompare(b.libelle);
        });

        donneesRef.competencesById = arrayToMap(donneesRef.competences, 'id');

        donneesRef.departementsById = arrayToMap(donneesRef.departements, 'id');
    }

    /**
     * Renvoie un objet avec toutes les données du store
     * returns {Object} objet avec toutes les données du store
     */
    get report() {
        return {
            ready: this.ready,
            error: this.error,
            typeVuePerimetre: this.typeVuePerimetre,
            vueDecision: this.vueDecision,
            utilisateurConnecte: this.utilisateurConnecte,
            idSousVivierSelectionne: this.idSousVivierSelectionne,
            idsFormationsEmploisSelectionnees: this.idsFormationsEmploisSelectionnees,
            donneesReference: this.donneesReference,
            vuePam: this.vuePam,
        };
    }

    setReady(val) {
        this.ready = val;
    }

    setError(val) {
        this.error = val;
    }

    setAdministreSelectifPamA(val){
        this.selectAdministreSelectifPamA = val;
    }

    setAdministreSelectifPamA1(val){
        this.selectAdministreSelectifPamA1 = val;
    }

    setPosteSelectifPamA(val){
        this.selectPosteSelectifPamA = val;
    }

    setPosteSelectifPamA1(val){
        this.selectPosteSelectifPamA1 = val;
    }
    toggleDonneesRecharger() {
        this.donneesRecharger = !this.donneesRecharger;
    }

    setDonneesReference(val) {
        this.donneesReference = val;
    }

    setTypeVuePerimetre(val) {
        this.typeVuePerimetre = val;

        // Si la vue est ADMINISTRES ou POSTES, on synchronise la vue de l'écran "Aide à la décision" avec ce choix
        if (val == ADMINISTRES || val == POSTES) {
            this.setVueDecision(val);
        }
    }

    setIdSousVivierSelectionne(val) {
        this.idSousVivierSelectionne = val;
        this.setFeSelected(null);
    }

    setIdsSousViviersSelectionnees(val) {
        this.idsSousViviersSelectionnees = val ?? [];
        // this.setFeSelected(null);
    }

    setPAMSelectionne(val) {
        this.PAMSelectionne = val;
    }
    
    setIdsFormationsEmploisSelectionnees(val) {
        this.idsFormationsEmploisSelectionnees = val ?? [];
    }

    setFeSousVivierSelectionne(val) {
        this.feSousVivierSelectionne = val;
    }

    setFeSelected(val) {
        this.feSelected = val;
    }

    
    setVuePam(val) {
        //const vueDecisionPrecedente = this.vueDecision;
        this.vuePam = val;
    }

    /**
     * Profils sélectionnables parmi les profils de l'utilisateur
     * @returns {import('../jsdoc/types').Profil[]} profils
     */
    get profilsSelectionnables() {
        const valides = [PROFILS.BVT, PROFILS.FILIERE, PROFILS.ITD, PROFILS.PCP, PROFILS.SUPER];
        return this.getProfils().filter((p) => valides.includes(p));
    }

    /**
     * Renvoie les profils de l'utilisateur.
     * @param {boolean} ecriture - true : mode écriture, false (défaut) : mode lecture
     * @returns {import('../jsdoc/types').Profil[]} profils
     */
    getProfils(ecriture = false) {
        const profils = this.utilisateurConnecte?.profils;
        return (ecriture ? profils?.ecriture : profils?.lecture) ?? [];
    }

    /**
     * Indique si l'utilisateur a le profil demandé ou au moins un profil demandé.
     * @param {(import('../jsdoc/types').Profil|import('../jsdoc/types').Profil[])} profil - profil(s) à tester
     * @param {boolean} ecriture - true : mode écriture, false (défaut) : mode lecture
     * @returns {boolean}
     */
    hasProfil(profil, ecriture = false) {
        const profils = this.getProfils(ecriture);
        return Array.isArray(profil) ? profil.some((p) => profils.includes(p)) : profils.includes(profil);
    }

    /**
     * Modifie le profil sélectionné s'il est disponible à l'utilisateur.
     * @param {?import('../jsdoc/types').Profil} val
     */
    setProfilSelectionne(val) {
        (!isPresent(val) || this.profilsSelectionnables.includes(val)) && (this.profilSelectionne = val);
    }

    setAffichagePCP(val) {
        this.affichagePCP = val;
    }

    setLoadingPCP(val) {
        this.loadingPCP = val;
    }

    setVueDecision(val) {
        //const vueDecisionPrecedente = this.vueDecision;
        this.vueDecision = val;

        /*
        // Si la vue de l'écran "Mon périmètre" était la même que la vue "Aide à la décision", on garde les 2 synchronisée
        if (vueDecisionPrecedente == this.typeVuePerimetre) {
        this.setTypeVuePerimetre(val);
        }
        */
    }


    setUtilisateurConnecte(val) {
        this.utilisateurConnecte = val;
        if (!this.utilisateurConnecte) {
            this.profilSelectionne = null;
            this.setIdSousVivierSelectionne(null);
        } else if (!this.profilSelectionne || !this.profilsSelectionnables.includes(val)) {
            // profil sélectioné par défaut
            const profils = this.profilsSelectionnables;
            this.setProfilSelectionne(profils.find((p) => p === PROFILS.FILIERE) ?? profils[0] ?? null);
            this.setIdSousVivierSelectionne(this.sousViviersUtilisateurConnecte[0]?.sv_id ?? null);
            this.setPAMSelectionne(this.donneesReference.pams[1]?.pam_id ?? null)
        }
        // pas de FE sélectionnée au départ
        this.setIdsFormationsEmploisSelectionnees([]);
        this.setIdsSousViviersSelectionnees([]);
    }

    setSelectedPosteDecision(val) {
        this.selectedPosteDecision = val;
    }

    setTypeIndicateurs(val) {
        this.typeIndicateurs = val;
    }

    setVueIndicateursPAM(val) {
        this.vueIndicateursPAM = val;
    }

    setSelectedAdministreDecision(val) {
        this.selectedAdministreDecision = val;
    }

    get hasSelectedPosteDecision() {
        return !!this.selectedPosteDecision;
    }

    get hasSelectedAdministreDecision() {
        return !!this.selectedAdministreDecision;
    }

    setSelectedPostesPerimetreEtITD(val) {
        this.selectedPostesPerimetreEtITD = val;
    }

    setSelectedAdministresPerimetre(val) {
        this.selectedAdministresPerimetre = val;
    }

    get hasSelectedPostesPerimetreEtITD() {
        return this.selectedPostesPerimetreEtITD && this.selectedPostesPerimetreEtITD.length;
    }

    get hasSelectedAdministresPerimetre() {
        return this.selectedAdministresPerimetre && this.selectedAdministresPerimetre.length;
    }

    setStatutCalculAideDecision(val) {
        this.statutCalculAideDecision = val;
    }

    /**
     * Groupe FE du PCP
     * @returns {Object[]}
     */
    get groupeFePCP() {
        const groupe = this.utilisateurConnecte?.fe_groupe?.pcp_fe_groupe;
        return !groupe ? [] : this.donneesReference?.FEs?.filter((val) => val.groupe_fe === groupe) ?? [];
    }

    /**
     * Retourne la liste des sous-viviers affectés à l'utilisateur connecté.
     * @returns {Array.<Object>} liste des sous-viviers ou []
     */
    get sousViviersUtilisateurConnecte() {
        var sousViviers = this.utilisateurConnecte?.sous_viviers ?? [];
        if (this.profilSelectionne === PROFILS.BVT) {
            sousViviers = sousViviers.filter((val) => val.sv_id == 'BVT')
        } else {
            sousViviers = sousViviers.filter((val) => val.sv_id != 'BVT')
        }
        return !this.profilSelectionne && this.hasProfil(PROFILS.SUPER) ? sousViviers : sousViviers.filter((val) => !val.admin);
    }

    /**
     * Retourne la liste des formation-emplois affectés à l'utilisateur connecté.
     * @returns {import('../jsdoc/api').FormationEmploiUtilisateurApi[]} liste des formation-emplois ou []
     */
     get formationEmploisUtilisateurConnecte() {
        const formationEmplois = this.utilisateurConnecte?.formation_emplois ?? [];
        return !this.profilSelectionne && this.hasProfil(PROFILS.SUPER) ? formationEmplois : formationEmplois.filter((val) => !val.admin);
    }

    /**
     * Indique si un sous-vivier d'id donné fait partie de la liste des sous-viviers affectés à l'utilisateur connecté.
     * @param {number} svId - Id du sous-vivier
     * @returns {boolean} true si le sous-vivier d'id donné fait partie de la liste des sous-viviers affectés à l'utilisateur connecté
     */
    isSousVivierUtilisateurConnecte(svId) {
        return !!this.sousViviersUtilisateurConnecte?.find((sv) => sv.sv_id === svId);
    }

    /**
     * Indique si une liste de sous-vivier d'id donné fait partie de la liste des sous-viviers affectés à l'utilisateur connecté.
     * @param {number} ListesvId - Liste Id du sous-vivier
     * @returns {boolean} true si la liste de sous-vivier d'id donné fait partie de la liste des sous-viviers affectés à l'utilisateur connecté
     */
    isPosteSousVivierUtilisateurConnecte(ListesvId) {
        return !!this.sousViviersUtilisateurConnecte?.find((sv) => ListesvId.includes(sv.sv_id));
    }

    /**
     * Indique si une liste de formations-emplois d'id donné fait partie de la liste des formation-emplois affectés à l'utilisateur connecté.
     * @param {number} ListefeId - Liste Id de la formation-emploi
     * @returns {boolean} true si la liste de formation-emplois d'id donné fait partie de la liste des fotmation-emplois affectés à l'utilisateur connecté
     */
    isPosteFormationEmploiUtilisateurConnecte(ListefeId) {
        return !!this.formationEmploisUtilisateurConnecte?.find((fe) => ListefeId.fe_mere_credo.includes(fe.fe_mere_credo));
    }

    setAdministreFicheDetaillee(val) {
        this.administreFicheDetaillee = val;
    }
}

export const AppConfigContext = createContext();

export default AppConfigStore;
