import axios from 'axios'
import jwt from "jsonwebtoken";
//import Service from "@/service/Service";

// adresse du web service en local
//const urlBase = "http://127.0.0.1:5000/"
// adresse du web service distant
const urlBase = "http://193.70.2.155/api/"
const users = "utilisateurs/"
const contenus = "contenus/"
const en_cours = "en_cours/"
const demande_pub = "demande_pub/"
//const evaluation = "evaluation/


export default {

    // Fonction qui doit permettre de demander le rafraichissement du token si expiré
    verifierToken: function (token){
        //const jwt = require('jsonwebtoken')
        try {
            let decoded = jwt.verify(token, 'l\'ordinateur-c\'est-magique')
            let tempsRestant = new Date(1000 * decoded.exp - Date.now())
            if (tempsRestant.getHours() === 0 && tempsRestant.getMinutes() < 15){
                console.log ("heures : " + tempsRestant.getHours() + "minutes " + tempsRestant.getMinutes())
                this.refreshToken().then(function (response) {
                    localStorage.token = response.data.access_token
                }) .catch(function (error) {
                    if (error.response) {
                        console.log(error.response.data)
                        console.log(error.response.status)
                        console.log(error.response.headers)
                    }
                });
            }
        }
        catch (JsonWebTokenError) {
            this.refreshToken().then(function (response) {
                localStorage.token = response.data.access_token
            })
        }
    },

    getHeader(){

        //console.log ("Access token : " + localStorage.token)
        //console.log ("Refresh token : " + localStorage.refreshToken)

        this.verifierToken(localStorage.token)


        return   {
            headers:
                {
                    Authorization: "Bearer " + localStorage.token
                }
        }
        //console.log("headon : " + header)
    },

    getSpecialHeader(){
        this.verifierToken(localStorage.token)
        return   {
            responseType: 'blob',
            headers: {
                'Content-Type': 'application/json'
            }
        }

    },

    getRefreshHeader(token){
        return   {
            headers:
                {
                    Authorization: "Bearer " + token,
                }
        }
    },

    // gestion des utilisateurs
    login(data) {
        let login = data[0]
        let motDePasse = data[1]
        /*      let reponse = ""
              axios.get(urlBase + "checkUser?login=" + login + "&password=" + motDePasse).then(function (response) {
                   reponse =  response.data
              })*/
        return axios.get(urlBase + users + "checkUser?login=" + login + "&password=" + motDePasse)
    },
    // récupération d'un nouveau token
    refreshToken(){
        return axios.get(urlBase + "refreshToken", this.getRefreshHeader(localStorage.refreshToken))
    },
    // gestion des utilisateurs
    /*    logout() {
            return axios.get(urlBase + users + "logout", this.getHeader())
        },*/
    recupererAuteursExistants(){
        return axios.get(urlBase + users + "auteursExistants", this.getHeader())
    },

    // gestion des contenus

    creerContenuPerso(data) {
        return axios.post(urlBase + contenus + "addContenu", data, this.getHeader())
    },
    uploaderContenuPerso(data, auteur, tags){
        return axios.post(urlBase + contenus + "uploadContenu/" + auteur + "?tags=" + tags, data, {
            headers: {
                'Content-Type': 'multipart/form-data',
                Authorization: "Bearer " + localStorage.token,
            }
        })
    },
    uploaderContenuPersoNonXml(data, auteur, tags, descriptif, type, titre){
        return axios.post(urlBase + contenus + "uploadContenuNonXml/" + auteur + "?tags=" + tags +
            "&descriptif="+ descriptif + "&type=" + type + "&titre=" + titre, data, {
            headers: {
                'Content-Type': 'multipart/form-data',
                Authorization: "Bearer " + localStorage.token,
            }
        })
    },
    creerContenuTiers(data) {
        return axios.patch(urlBase + contenus + "ajouterTiers", data, this.getHeader())
    },
    /*    getContenuById(idContenu) {
            return axios.get(urlBase + contenus + "getContenu/" + idContenu)
        },*/

    getPanierAuteur(auteur) {
        return axios.get(urlBase + contenus + "getContenuPanier/" + auteur + "?perso=True&tiers=True&enCours=true", this.getHeader())
        /*        return axios({method: 'get', url: urlBase + contenus + "getContenuPanier/" + auteur + "?perso=True&tiers=True&enCours=true",
                    headers: { 'Authorization': 'Bearer ' + localStorage.token } })*/

    },

    getBanqueAuteur(auteur) {
        return axios.get(urlBase + contenus + "getContenuBanque/" + auteur, this.getHeader())
    },
    supprimerContenu(idContenu) {
        return axios.delete(urlBase + contenus + "deletePerso/" + idContenu, this.getHeader())
    },

    supprimerTiers(auteur, id_tiers, note) {
        return axios.delete(urlBase + contenus + "deleteTiers?auteur=" + auteur + "&id_tiers=" + id_tiers + "&note=" + note, this.getHeader())
    },

    creerNouveauContenu(data) {
        return axios.post(urlBase + contenus + "newContenu", data, this.getHeader())
    },

    majContenu(data) {
        return axios.patch(urlBase + contenus + "majContenu", data, this.getHeader())

    },    gererDemandePublication(data) {
        return axios.patch(urlBase + contenus + "gererDemandePub", data, this.getHeader())
    },
    isMajTiersDisponible(auteur) {
        return axios.get(urlBase + contenus + "isMajTiersDisponible/" + auteur, this.getHeader())
    },
    listeMajTiers(auteur) {
        return axios.get(urlBase + contenus + "listeMajTiers/" + auteur, this.getHeader())
    },
    gererMajTiers(data) {
        return axios.patch(urlBase + contenus + "gererMajTiers", data, this.getHeader())
    },
    changerTexte(data, id) {
        return axios.patch(urlBase + contenus + "changerTexte/" + id, data, this.getHeader())
    },
    recupererTexteContenu(idContenu){
        return axios.get(urlBase + contenus + "getTexteContenu/" + idContenu, this.getHeader())
    },
    recupererTexteVersionContenu(idContenu, version){
        return axios.get(urlBase + contenus + "getTexteVersionContenu/" + idContenu + "/" + version, this.getHeader())
    },
    incrementerPopularite(data){
        return axios.patch(urlBase + contenus + "incrementerPopularite", data, this.getHeader())
    },
    noterContenu(data){
        return axios.patch(urlBase + contenus + "noterContenu", data, this.getHeader())
    },
    recupererNoteContenu(idContenu, auteur, version){
        return axios.get(urlBase + contenus + "recupererNote?auteur=" + auteur + "&version=" + version + "&id_contenu=" + idContenu, this.getHeader())
    },
    modifierXML(data){
        return axios.patch(urlBase + contenus + "modifierXML", data, this.getHeader())
    },
    // gestion des contenus - fonctions spéciales tags
    ajouterTagLibre(data){
        return axios.patch(urlBase + contenus + "newTagLibre", data, this.getHeader())
    },
    recupererTagLibre(auteur){
        return axios.get(urlBase + contenus + "getTagLibre/" + auteur, this.getHeader())
    },
    recupererTagLibreContenu(idContenu, auteur){
        return axios.get(urlBase + contenus + "getTagLibreContenu/" + idContenu + "/" + auteur, this.getHeader())
    },
    associerTagLibre(data){
        return axios.patch(urlBase + contenus + "associerTagLibre", data, this.getHeader())
    },
    dissocierTagLibre(data){
        return axios.patch(urlBase + contenus + "dissocierTagLibre", data, this.getHeader())
    },
    supprimerTagLibre(auteur, tag){
        return axios.delete(urlBase + contenus + "supprimerTagLibre?auteur=" + auteur + "&tag=" + tag, this.getHeader())
    },
    modifierTagsFixes(data) {
        return axios.patch(urlBase + contenus + "modifierTags", data, this.getHeader())
    },
    parserTexte(id_contenu) {
        return axios.get(urlBase + contenus + "parserContenu/" + id_contenu, this.getHeader())
    },
    parserTexteVersion(id_contenu, version) {
        return axios.get(urlBase + contenus + "parserContenuVersion/" + id_contenu + "?version=" + version, this.getHeader())
    },
    exporterXML(id_contenu) {
        return axios.get(urlBase + contenus + "exporterContenuXml/" + id_contenu, this.getSpecialHeader())
    },
    recalibrerGit(data){
        return axios.patch(urlBase + contenus + "recalibrerGit", data, this.getHeader())
    },
    // gestion des en-cours
    exporterXMLEnCours(id_contenu){
        return axios.get(urlBase + en_cours + "exporterContenuXmlEnCours/" + id_contenu, this.getSpecialHeader())
    },
    modifierXMLEnCours(data){
        return axios.patch(urlBase + en_cours + "modifierXMLEnCours", data, this.getHeader())
    },
    parserTexteEnCours(id_contenu) {
        return axios.get(urlBase + en_cours + "parserContenuEnCours/" + id_contenu, this.getHeader())
    },
    parserTexteEnCoursVersion(id_contenu, version) {
        return axios.get(urlBase + en_cours + "parserContenuEnCoursVersion/" + id_contenu + "&version=" + version, this.getHeader())
    },
    creerEnCours(data) {
        return axios.post(urlBase + en_cours + "newEnCours", data, this.getHeader())
    },

    creerEnCoursRefuse(data) {
        return axios.patch(urlBase + en_cours + "newEnCoursRefuse", data, this.getHeader())
    },
    supprimerEnCoursParLid(idEnCours) {
        return axios.delete(urlBase + en_cours + "supprimerEnCoursParId/" + idEnCours, this.getHeader())
    },
    recupererTexteContenuEnCours(idContenu){
        return axios.get(urlBase + en_cours + "getTexteContenuEnCours/" + idContenu, this.getHeader())
    },


    // gestion des demandes de publication

    getPublicationsRecues(auteur) {
        return axios.get(urlBase + demande_pub + "demandePublication/" + auteur + "/False", this.getHeader())
    },

    getPublicationsProposees(auteur) {
        return axios.get(urlBase + demande_pub + "demandePublication/" + auteur + "/True", this.getHeader())
    },

    creerDemandePublication(data) {
        return axios.post(urlBase + demande_pub + "demandePublication", data, this.getHeader())

    },
    supprimerDemandePublication(idDemandePublication) {
        return axios.delete(urlBase + demande_pub + "demandePublication/" + idDemandePublication, this.getHeader())
    }

}