// pour "configurer" le lecteur nfc
// ouvrir le fichier:  sudo nano /usr/lib/pcsc/drivers/ifd-ccid.bundle/Contents/Info.plist (pour pi)
// localiser la ligne  <key>ifdDriverOptions</key>,
// la ligne suivante vaux <string>0x0000</string>,
// modifier la <string>0x0001</string>,
// sauvegarder le fichier et redémarer pcscd(sudo service pcscd restart)
// même action pour le fichier sudo nano /usr/lib/pcsc/drivers/ifd-acsccid.bundle/Contents/Info.plist (pour desktop)

let script, ip, memSudoMdp = '', etatUrl = 0
let TAB = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '!', '#', '$', '%', '&', '?', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
let max_TAB = TAB.length - 1
let donneesFichierConfiguration = {}
// type de lecteur nfc
const typeLecteurNfc = 'vma405'
// dev = 1 = mode développement
let dev = 1

// nfc
const vma405Emitter = require('./vma405.js')

const os = require('os')
const hostname = os.hostname()

const {spawn, exec} = require('child_process')
const IP = require('ip')
const path = require('path')
const fs = require('fs')
// serveur http
const http = require('http')
// const ADR = '192.168.1.32'
const ADR = '127.0.0.1'
const PORT = 3000
const TOKEN = '$a;b2yuM5454@4!cd'
//  retour = null = aucune demande de lecture de carte nfc
let retour = null
let client_globale = null
let fichier = '', contentType = ''

/**
 * retourne l'ip
 * @param {string|'public'|'private'} typeReseau
 * @param {String|'ipv4'|'ipv6'} famille
 * @returns {string}
 */
function obtenirIp(typeReseau, famille) {
  ip = IP.address(typeReseau, famille)
  let retour = "erreur"
  if (ip !== "127.0.0.1" && ip !== "0.0.0.0") {
    retour = ip
  }
  return retour
}

// --- nfc ---
vma405Emitter.on('tagId', (tagId) => {
  if (retour !== null) {
    retour['tagId'] = tagId.toUpperCase()
    client_globale.emit('envoieTagId', retour)
    console.log('--> demande carte, envoi tag id = ' + tagId.toUpperCase())
    retour = null
  } else {
    // console.log('-> Aucune demande, carte :' + card.uid.toString().toUpperCase())
    console.log('-> Aucune demande, carte :' + tagId.toUpperCase())
    if (client_globale !== null) {
      client_globale.emit('infosTagId', tagId.toUpperCase())
    }
  }
})

vma405Emitter.on('msgVma405', (msg) => {
  console.log('msgVma405 =', msg)
})


// --- commandes système ---
/** @function
 * Obtenir ip extérieur (wan/box)
 */
function obtenirIpWan() {
  const prog = spawn('curl', ['ifconfig.me'])
  prog.stdout.on('data', (data) => {
    prog.resultatRequete = data.toString()
  })

  prog.on('close', (code) => {
    if (code === 0) {
      // ok: ip = prog.resultatRequete
    } else {
      // erreur
    }
  })
}

/**
 * Obtenir des données de configuration d'un fichier (.chromium_env)
 * @param {Array} rechercher - liste des varaibles à rechercher ddans le fichier
 * @param {String} fichier - nom du fichier à lire
 * @returns {{msg, erreur: number}|{valeurs: {}, erreur: number}}
 */
function obtenirConfigurationDunFichier(rechercher, fichier) {
  try {
    const fic = fs.readFileSync(fichier, {encoding: 'utf8', flag: 'r'}).split('\n')
    let obj = {}
    for (let index = 0; index < fic.length; index++) {
      let ligne = fic[index].toString()
      if (ligne.length > 0 && ligne[0] !== '#' && ligne.indexOf('=') !== -1) {
        let tab = ligne.split('=')
        for (let im in rechercher) {
          mot = rechercher[im]
          if (mot === (tab[0].trim())) {
            obj[tab[0].trim()] = tab[1].trim()
          }
        }
      }
    }
    return {erreur: 0, valeurs: obj}
  } catch (error) {
    return {erreur: 1, msg: error}
  }
}

function afficherInfoServeur(donnees) {
  // console.log('-> fonction afficherInfoServeur !')
  // console.log('donnees = ', donnees)
  if (donnees.erreur === 0) {
    let bruteUrl = donnees.valeurs.url
    let posDeuxSlashs = bruteUrl.indexOf('//') + 2
    let posFinDomaine = bruteUrl.indexOf('/wv/login_hardware')
    let domaine = bruteUrl.substring(posDeuxSlashs, posFinDomaine)
    let onclique = ''
    if (donnees.valeurs.front_type === "FPI") {
      onclique = `onclick="clavierVirtuel.obtPosition('serveur');clavierVirtuel.afficher('serveur', 'alpahMin')"`
    }
    let fronts = ['FPI', 'FOR']
    let options = ''
    for (let i = 0; i < fronts.length; i++) {
      let sel = ''
      console.log(`${i} -> ${fronts[i]}  --  ${donnees.valeurs.front_type}`)
      if (fronts[i] === donnees.valeurs.front_type) {
        sel = 'selected'
      }
      options += `<option value="${fronts[i]}" ${sel}>${fronts[i]}</option>`
    }
    return `
      <div id="info-serveur" class="BF-ligne-deb l100p item-info" data-url-serveur="${bruteUrl}" data-serveur="${domaine}">Serveur: ${domaine}</div>
      
      <div class="BF-ligne-deb l100p">  
        <div id="bt-tester-serveur" class="bt bt-250px fond-ok curseur-action">
          <div class="md4px">Tester Serveur</div>
        </div>
      </div>
      
      <div class="BF-ligne-deb item-info l100p">
        <div id="bt-modifier-serveur" class="bt bt-250px fond-alerte curseur-action">
          <div class="md4px">Modifier Serveur</div>
          <div id="etat-modifier-serveur" class="mod-serveur-ok"></div>
        </div>
      </div>

      <div id="modifier-serveur" class="contenu-form eff p4px fond-header l100p">
        <div class="BF-ligne-deb mb8px">
          <label for="serveur" class="serveur-label">Serveur</label>
          <input type="text" id="serveur" class="input-pour-pi" name="serveur" value="${domaine}" ${onclique} required>
        </div>
        <div class="BF-ligne-deb  mb8px">
          <label for="nom-appareil" class="mod-wifi-label">APPAREIL</label>
          <input type="text" id="nom-appareil" class="input-pour-pi" name="nom-appareil" value="${os.hostname()}" disabled>
        </div>
        <div class="BF-ligne-deb  mb8px">
          <label for="passe" class="mod-wifi-label">GENERER MOT DE PASSE</label>
          <input type="checkbox" id="passe" name="passe" >
        </div>
        <div class="BF-ligne-deb  mb8px">
          <label for="type-front" class="mod-wifi-label">FRONT</label>
          <select id="type-front" class="input-pour-pi">${options}</select>
        </div>
        <div class="BF-ligne">
          <div id="bt-valider-modifier-serveur" class="bt bt-valider fond-ok coulBlanc curseur-action">Valider</div>
        </div>
      </div>
    `
  } else {
    return `
      <div class="BF-ligne-deb item-info l100p">Erreur</div>
      <div class="item-info">donnees.msg</div>
    `
  }
}

/** @function
 * Teste l'url avec curl
 * @param {Sring} url - url à tester
 * @param {Number} nbMaxStderr - nombre maxi d'évènement Stderr avant de sortir de la fonction
 */
function testUrl(url, nbMaxStderr) {
  console.log(`-> fonction testUrl, url = ->${url}<-`)
  const prog = spawn('curl', ['-I', url])
  prog.nbMaxStderr = nbMaxStderr
  prog.nbStderr = 0
  prog.resultatRequete = "404"
  etatUrl = 0
  prog.stdout.on('data', (data) => {
    let premiereLigne = data.toString().split('\n')[0]
    prog.resultatRequete = premiereLigne.split(' ')[1]
  })

  prog.stderr.on('data', (data) => {
    prog.nbStderr++
    if (prog.nbStderr === prog.nbMaxStderr) {
      prog.kill()
    }
  })

  prog.on('close', (code) => {
    // header 307 = redirection temporaire
    // header 308 = redirection permanente
    console.log('réponse test serveur = ', prog.resultatRequete)
    if (prog.resultatRequete === '200' || prog.resultatRequete === '307' || prog.resultatRequete === '308') {
      etatUrl = 1
    }
    client_globale.emit('etatUrlServeur', prog.resultatRequete)
  })
}


function modifierConfigurationWifi(data) {
  console.log('-> fonction modifierConfigurationWifi !')
  console.log('data = ', data)
  let template = `country=FR
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
network={
  ssid="${data.essid}"
  psk="${data.passePhrase}"
  scan_ssid=1    
}
`
  try {
    fs.writeFileSync("/etc/wpa_supplicant/wpa_supplicant.conf", template, {flag: "w"})
    client_globale.emit('modificationWifi', {
      erreur: 0,
      msg: `
        <div class="l100p h100p BF-col">
          <h1>Modification wifi effectuée,</h1>
          <h1>réseau = ${data.essid}</h1>
          <h1>Redémmarer l'appareil ! </h1>
        </div>
      `
    })
  } catch (erreur) {
    client_globale.emit('modificationWifi', {
      erreur: 1,
      msg: `
        <h1>Erreur configuration wifi</h1>
        <h2>${erreur}</h2>
      `
    })
  }
}

function afficherInfosWifi() {
  // console.log('-> fonction afficherInfosWifi !')
  const prog = spawn('iwconfig', [])
  prog.stdout.on('data', (data) => {
    let lignes = data.toString().split('\n')
    for (let i = 0; i < lignes.length; i++) {
      let ligne = lignes[i]
      if (ligne.indexOf('ESSID') !== -1) {
        let tmpData = ligne.split(':')
        let etatWifi = 'on'
        let essid = ''
        if (tmpData[1].includes('off')) {
          etatWifi = 'off'
        } else {
          essid = tmpData[1].trim().replace(/"/g, '')
        }
        let tmpData2 = ligne.split(' ')
        prog.resultat = {interface: tmpData2[0], etat: etatWifi, essid: essid}
        break
      }
    }
  })

  prog.on('close', (code) => {
    if (code === 0) {
      // wifi actif
      // if (prog.resultat.etat === 'on' && donneesFichierConfiguration.erreur === 0) {
      // uniquement sur pi
      if (donneesFichierConfiguration.valeurs.front_type === "FPI") {
        let onclique = ''
        // if (donneesFichierConfiguration.valeurs.front_type === "FPI") {
        oncliqueEssid = `onclick="clavierVirtuel.obtPosition('essid');clavierVirtuel.afficher('essid', 'alpahMin')"`
        oncliquePasse = `onclick="clavierVirtuel.obtPosition('pp');clavierVirtuel.afficher('pp', 'alpahMin')"`
        // }

        let fragHtml = `
            <div id="info-essid" class="BF-ligne-deb item-info l100p">Ssid: ${prog.resultat.essid}</div>
            <div class="BF-ligne-deb item-info l100p">
              <div id="bt-modifier-wifi" class="bt bt-250px fond-alerte curseur-action">
                <div class="md4px">Modifier Wifi</div>
                <div id="etat-modifier-wifi" class="mod-wifi-ok"></div>
              </div>
            </div>
            <div id="modifier-wifi" class="contenu-form eff p4px fond-header l100p">
              <div class="BF-ligne-deb  mb8px">
                <label for="essid" class="mod-wifi-label">RESEAU:</label>
                <input type="text" id="essid" class="input-pour-pi" name="essid" ${oncliqueEssid} required>
              </div>
              <div class="BF-ligne-deb mb8px">
                <label for="pp" class="mod-wifi-label">MOT DE PASSE:</label>
                <input type="password" id="pp" class="input-pour-pi" name="pp" ${oncliquePasse} required>
              </div>
              <div class="BF-ligne">
                <div id="bt-valider-modifier-wifi" class="bt bt-valider fond-ok coulBlanc curseur-action">Valider</div>
              </div>
            </div>
          `
        client_globale.emit('retourInfosWifi', fragHtml)
      }
      // }
    }
  })
}

/**
 * Lancer chromium
 * @param {Number|1|2} - etape
 */
function lancerChromium(etape, dataFichier) {
  console.log('-> fonction lancerChromium !')

  let optionsChromium = [], msgErreur = ''
  console.log('dataFichier = ', dataFichier)
  if (dataFichier.erreur === 0) {
    data = dataFichier.valeurs
  } else {
    msgErreur = dataFichier.msg
  }

  if (msgErreur === '') {
    if (etape === 1) {
      // dev
      if (dev === 1) {
        optionsChromium = ['--disable-features=Translate', '--disable-pinch', '--remote-debugging-port=9222', '--noerrdialogs', '--disable-infobars', '--check-for-update-interval=31536000', 'http://127.0.0.1:3000']
      } else {
        // prod
        optionsChromium = ['--disable-features=Translate', '--disable-pinch', '--noerrdialogs', '--disable-infobars', '--check-for-update-interval=31536000', 'http://127.0.0.1:3000']
      }
    } else {
      // dev
      console.log('-> etape 2, url = ', data.url)
      if (dev === 1) {
        optionsChromium = ['--disable-features=Translate', '--disable-pinch', '--remote-debugging-port=9222', '--noerrdialogs', '--disable-infobars', '--check-for-update-interval=31536000', data.url]
      } else {
        // prod
        optionsChromium = ['--disable-features=Translate', '--disable-pinch', '--noerrdialogs', '--disable-infobars', '--check-for-update-interval=31536000', data.url]
      }

    }

    // mode kiosk uniquement pi
    if (data.front_type === "FPI") {
      optionsChromium.push('--kiosk')
    }

    if (msgErreur === '') {
      const userAgent = `{"hostname":"${data.hostname}", "token": "${data.token}", "password":"${data.password}","modeNfc":"${data.mode_nfc}","front":"${data.front_type}","ip":"${obtenirIp('public', 'ipv4')}"}`
      console.log('userAgent = ', userAgent)

      optionsChromium.push(`--user-agent=${userAgent}`)
      console.log('optionsChromium = ', optionsChromium)

      // Lance chromium
      const demChromium = spawn('chromium-browser', optionsChromium)

      demChromium.stdout.on('data', (data) => {
        console.log(`demChromium - stdout: ${data}`)
      });

      demChromium.stderr.on('data', (data) => {
        console.error(`demChromium - stderr: ${data}`)
      })

      demChromium.on('close', (code) => {
        console.log(`demChromium - child process exited with code ${code}`)
        if (code === 0) {
          console.log('--> Chromium démarrer !')
        }
      })
    }
  } else {
    console.log('Erreur: ', msgErreur)
  }
}

function lancerApplication() {
  console.log('-> fonction lancerApplication !')
  const dataConf = obtenirConfigurationDunFichier(['hostname', 'token', 'password', 'front_type', 'url', 'mode_nfc'], './.chromium_env')
  if (dataConf.erreur === 0) {
    let prog
    if (dataConf.valeurs.front_type === "FPI") {
      prog = spawn('pkill', ['chromium'])
    } else {
      prog = spawn('pkill', ['chrome'])
    }

    prog.stdout.on('data', (data) => {
      console.log('stdout: ', data.toString())
    })

    prog.stderr.on('data', (data) => {
      console.log('stderr: ', data.toString())
    })

    prog.on('close', (code) => {
      if (code === 0) {
        console.log('--> Chromium arrêter !')
        const dataFichier = obtenirConfigurationDunFichier(['hostname', 'token', 'password', 'front_type', 'url', 'mode_nfc'], './.chromium_env')
        lancerChromium(2, dataFichier)
      }
    })
  } else {
    console.log('Erreur: ', dataConf.msg)
  }
}

function afficherFrontType() {
  console.log('-> fonction afficherFrontType !')
  console.log('donneesFichierConfiguration = ', donneesFichierConfiguration)
  if (donneesFichierConfiguration.erreur === 0) {
    return donneesFichierConfiguration.valeurs.front_type
  } else {
    return 'inconnu'
  }
}

function rnd(min, max) {
  return Math.round(Math.random() * ((max + 1) - min) + min, 0);
}

function generer_mot_de_passe(longueur) {
  let mot = '';
  let lettre = TAB[rnd(0, max_TAB)];
  for (let i = 0; i < (longueur); i++) {

    while (mot.indexOf(lettre) != -1) {
      lettre = TAB[rnd(0, 59)];
    }
    mot += lettre;
  }
  return mot
}

function modifierConfigurationServeur(data) {
  // console.log('-> fonction modifierConfigurationServeur !')
  let proto = 'https'
  // Développement serveur = "#serveur.com#", donne un protocol http et serveur = "serveur.com"
  let serveur = data.serveurDomaine.toString()
  // console.log('0 = ',serveur[0], '  --  dernier = ',serveur[(serveur.length-1)])
  if (serveur[0] === '#' && serveur[(serveur.length - 1)] === '#') {
    proto = 'http'
    serveur = data.serveurDomaine.toString().substring(1, (serveur.length - 1))
  }

  donnees = obtenirConfigurationDunFichier(['hostname', 'token', 'password', 'front_type', 'url', 'mode_nfc'], './.chromium_env')
  if (donnees.erreur === 0) {
    let motDePasse = generer_mot_de_passe(16)
    if (data.genererMotDePasse === false) {
      motDePasse = donnees.valeurs.password
    }

    let template = `#utilisateur
hostname = ${data.user}

#front
front_type = ${data.typeFront}

#url du serveur
#url = http://django-local.org:8001/wv/login_hardware
url = ${proto}://${serveur}/wv/login_hardware

#mode_nfc = NFCMO
mode_nfc = ${donnees.valeurs.mode_nfc}

password = ${motDePasse}
token =  ${donnees.valeurs.token}
`
    try {
      fs.writeFileSync(".chromium_env", template)
      client_globale.emit('modificationServeur', {erreur: 0, serveurDomaine: serveur})
      testUrl(serveur, 14)
      redemarrerChromium()
    } catch (error) {
      client_globale.emit('modificationServeur', {erreur: 1})
    }
  } else {
    client_globale.emit('modificationServeur', {erreur: 1})
  }
}

// --- serveur http ---
let typeMime = {
  "aac": "audio/aac",
  "abw": "application/x-abiword",
  "arc": "application/octet-stream",
  "avi": "video/x-msvideo",
  "azw": "application/vnd.amazon.ebook",
  "bin": "application/octet-stream",
  "bz": "application/x-bzip",
  "bz2": "application/x-bzip2",
  "csh": "application/x-csh",
  "css": "text/css",
  "csv": "text/csv",
  "doc": "application/msword",
  "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
  "eot": "application/vnd.ms-fontobject",
  "epub": "application/epub+zip",
  "gif": "images/gif",
  "htm": "text/html",
  "html": "text/html",
  "ico": "images/x-icon",
  "ics": "text/calendar",
  "jar": "application/java-archive",
  "jpeg": "images/jpeg",
  "jpeg": "images/jpeg",
  "js": "application/javascript",
  "json": "application/json",
  "mid": "audio/midi",
  "midi": "audio/midi",
  "mpeg": "video/mpeg",
  "mpkg": "application/vnd.apple.installer+xml",
  "odp": "application/vnd.oasis.opendocument.presentation",
  "ods": "application/vnd.oasis.opendocument.spreadsheet",
  "odt": "application/vnd.oasis.opendocument.text",
  "oga": "audio/ogg",
  "ogv": "video/ogg",
  "ogx": "application/ogg",
  "otf": "font/otf",
  "png": "images/png",
  "pdf": "application/pdf",
  "ppt": "application/vnd.ms-powerpoint",
  "pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
  "rar": "application/x-rar-compressed",
  "rtf": "application/rtf",
  "sh": "application/x-sh",
  "svg": "images/svg+xml",
  "swf": "application/x-shockwave-flash",
  "tar": "application/x-tar",
  "tif": "images/tiff",
  "tiff": "images/tiff",
  "ts": "application/typescript",
  "ttf": "font/ttf",
  "vsd": "application/vnd.visio",
  "wav": "audio/x-wav",
  "weba": "audio/webm",
  "webm": "video/webm",
  "webp": "images/webp",
  "woff": "font/woff",
  "woff2": "font/woff2",
  "xhtml": "application/xhtml+xml",
  "xls": "application/vnd.ms-excel",
  "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
  "xml": "application/xml",
  "xul": "application/vnd.mozilla.xul+xml",
  "zip": "application/zip",
  "3gp": "video/3gpp audio/3gpp",
  "3g2": "video/3gpp2 audio/3gpp2",
  "7z": "application/x-7z-compressed"
}

let www = process.cwd() + '/www/'
console.log('www  = ', www)

function retour404(res) {
  res.writeHead(404, {'Content-Type': 'text/html'});
  res.write('Page inconnue !');
  res.end();
}

function renderHtml(contenu, ctx) {
  // let contenuTp1, contenuTp2, contenuTp3, contenuTp4
  contenu = contenu.toString()
  let rendu = contenu.toString().replace(/{{\s*[\w\.]+\s*}}/g, function (match, token) {
    let clef = match.replace(/ /g, '').replace('{{', '').replace('}}', '')
    console.log('-> match = ', match, '  --  clef = ', clef)
    return ctx[clef]
  })
  contenu = {}
  return rendu
}

// lire la conf. dans le fichier .chromium_env
donneesFichierConfiguration = obtenirConfigurationDunFichier(['hostname', 'token', 'password', 'front_type', 'url', 'mode_nfc'], './.chromium_env')

const serveur = http.createServer(function (req, res) {
  let url = req.url;

  // routes
  let ctx = {}
  if (url == '/') {
    url = 'index.html'
    ctx = {
      fontType: afficherFrontType(),
      nomAppareil: os.hostname(),
      afficherInfoServeur: afficherInfoServeur(donneesFichierConfiguration),
      urlServeur: donneesFichierConfiguration.url,
      ip: obtenirIp('public', 'ipv4'),
      typeLecteurNfc: typeLecteurNfc,
      typeserveurNfc: 'nodejs'
    }
  }

  if (url == '/favicon.ico') url = 'img/favicon2.ico'

  fichier = www + url.substring(0, url.length);

  //assets
  let posDerPoint = url.lastIndexOf('.')
  let extention = ''
  if (posDerPoint != -1) {
    extention = url.substring(posDerPoint + 1, url.length);
    if (extention.toLowerCase() == 'css') contentType = 'text/css';
    contentType = typeMime[extention.toLowerCase()];
  }

  try {
    let contenuFichier = fs.readFileSync(fichier)

    // rendre du html
    if (extention === 'html') {
      contenuFichier = renderHtml(contenuFichier, ctx)
    }

    res.writeHead(200, {"Content-Type": contentType})
    res.write(contenuFichier)
    res.end();
    console.log('-> url = ' + url + '  --  fichier :' + fichier + '  --  contentType = ' + contentType + '   -> chargé !');
  } catch (err) {
    console.log('->  url = ' + url + '  --  Erreur: ' + err)
    retour404(res);
  }

})

// --- socket.io ---
const options = {
  // allowEIO3: true,
  cors: {
    origin: "*",
    methods: ["PUT", "GET", "POST"]
  }
}
const IO = require('socket.io')(serveur, options)
// middleware

IO.use(function (socket, next) {
  let token = socket.handshake.query.token
  // console.log('token reçu = '+token+'  --  TOKEN = '+TOKEN)
  if (token === TOKEN) {
    return next()
  } else {
    next(new Error("ERREUR d'autentification !"))
  }
})

IO.on('connection', client => {
  client_globale = client;
  client_globale.on('demandeTagId', (data) => {
    retour = data;
    console.log('-> demandeTagIdg = ' + JSON.stringify(retour))
  })

  client_globale.on('AnnuleDemandeTagId', () => {
    retour = null
  })

  client_globale.on('disconnect', () => {
    console.log('Client déconnecté !!')
  })

  client_globale.on('validerModifierWifi', (data) => {
    modifierConfigurationWifi(data)
  })

  client_globale.on('validerModifierServeur', (data) => {
    modifierConfigurationServeur(data)
  })


  client_globale.on('testerUrlServeur', (urlATester) => {
    console.log('-> test url serveur = ', urlATester)
    testUrl(urlATester, 12)
  })

  client_globale.on('donnerInfosWifi', () => {
    afficherInfosWifi()
  })

  client_globale.on('lancerApplication', () => {
    lancerApplication()
  })

})

// lancement serveur http
serveur.listen(PORT, ADR, () => {
  console.log(`le serveur écoute http://localhost:${PORT}`)
})

const dataConf = obtenirConfigurationDunFichier(['hostname', 'token', 'password', 'front_type', 'url', 'mode_nfc'], './.chromium_env')
lancerChromium(1, dataConf)
