const fs = require("fs-extra");
const path = require("path");
const glob = require("glob");
const dnsSync = require("dns-sync");
const mustache = require("mustache");
const jsdom = require("jsdom");
const { JSDOM } = jsdom;
const minihtml = require("html-minifier").minify;
const minijs = require("terser").minify;
const sharp = require("sharp");
const readlineSync = require("readline-sync");
const Odmdb = require("./Odmdb.js");
const conf = require(`../../../adminapi/objects/tribes/itm/adminapi.json`);
const currentmod = "Wwws";
const log = conf.api.activelog.includes(currentmod);
const Wwws = {};

Wwws.getwco = (wconame, ctx) => {
  /**
   * In a webpage to add a wco
   * <script src="/api/adminapi/wwws/getwco/wco.js?wcotribe=adminapi&tribe=adminapi&xapp=admin&pagename=apxid&code=enjoy&tagid=id"></script>
   * <div id="tagid"  add tag here to customize if needded></div>
   *
   *  The script request will update /tribe/objects/wwws/itm/xapp.json with
   *      tpl, schema, tpldata, ...
   *  A wco has a /adminapi/objects/wco/itm/wconame.json that contain tpl options, ref, schema, ...
   * The dynamic content is store in <div id="ctx.tagid">
   * so tpldata:{${tagid}_${wco.tpldatamodel.key}:"..."}
   * When the script request is done, it checks if exist file in wwws/${app}/src/tpldata/${pagename}/${tagid}_${wco.tpldatamodel.key}_lg.json
   *     if not it create with the wco example tpldatamodel ${wco.tpldatamodel.key}
   * Check also if exist in localdb.pagename.tpldata
   */
  const filereq = `../${ctx.wcotribe}/objects/wco/${wconame}/${wconame}.js`;
  const wcoconf = `../${ctx.wcotribe}/objects/wco/itm/${wconame}.json`;
  if (
    !fs.existsSync(filereq) ||
    !fs.existsSync(wcoconf) ||
    !fs.pathExistsSync(`../${ctx.tribe}`)
  ) {
    return {
      status: 404,
      ref: "Wwws",
      msg: "filedoesnotexist",
      data: { js: filereq, wcoconf: wcoconf, tribe: ctx.tribe },
    };
  }
  //check in ctx.wcotribe if  ctx.tribe_ctx.code exist in
  console.log("@todo don't forget to manage accessright to wco in Wwws");
  //check that all tpl, tpldata, ... are available for this pagename
  if (
    wconame == "tracker" &&
    !fs.pathExistsSync(`../${ctx.tribe}/objects/wwws/cdn/trkret`)
  ) {
    fs.mkdirSync(`../${ctx.tribe}/objects/wwws/cdn/`, { recursive: true });
    fs.cpSync(
      `../adminapi/objects/wwws/cdn/trkret`,
      `../${ctx.tribe}/objects/wwws/cdn/`,
      { recursive: true }
    );
  }
  const webconf = `../${ctx.tribe}/objects/wwws/itm/${ctx.xapp}.json`;
  const webpageinit = {
    dns: [],
    apxtri: {
      headers: {
        xtrkversion: 1,
        xalias: "anonymous",
        xapp: "recruiter",
        xdays: 0,
        xhash: "anonymous",
        xlang: "en",
        xprofils: "anonymous",
        xtribe: "smatchit",
        xuuid: "0",
      },
    },
    tailwindcsscontent: [
      `../${ctx.tribe}/objects/wwws/${ctx.xapp}/src/**/*.{html,js,mustache}`,
      `../${ctx.tribe}/objects/wco/**/*.{html,js,mustache}`,
      "../adminapi/objects/wco/apx/*.{html,js,mustache}",
      "../adminapi/objects/wco/tracker/*.{html,js,mustache}",
    ],
    pages: {},
  };
  webpageinit.pages[ctx.pagename] = {
    version: 1,
    language: ["en"],
    profils: ["anonymous"],
    itms: {},
    tpl: {},
    options: {},
    ref: {},
    schema: [],
    tpldata: {},
    wco: {},
  };
  const wcoinfo = fs.readJSONSync(wcoconf);
  const webpage = fs.existsSync(webconf)
    ? fs.readJSONSync(webconf)
    : webpageinit;
  // check that webconf for tailwindcsscontent property exist for this wco request
  const pathtocheckfortw = [
    `../../../../../../../adminapi/objects/wco/${wconame}/*.{html,js,mustache}`,
    `../../../../../../../${ctx.tribe}/objects/wwws/${ctx.xapp}/src/**/*.{html,js,mustache}`,
  ];
  if (!webpage.tailwindcsscontent) {
    webpage.tailwindcsscontent = [];
  }
  pathtocheckfortw.forEach((tw) => {
    if (!webpage.tailwindcsscontent.includes(tw)) {
      webpage.tailwindcsscontent.push(tw);
    }
  });
  // check that all tpl for this compoent are well in pages tpl object
  if (wcoinfo.tpl && Object.keys(wcoinfo.tpl).length > 0) {
    Object.keys(wcoinfo.tpl).forEach((t) => {
      //console.log(ctx.pagename,"---",t)
      //console.log(Object.keys(webpage.pages[ctx.pagename].tpl))
      if (!Object.keys(webpage.pages[ctx.pagename].tpl).includes(t)) {
        //console.log(wcoinfo.tpl[t])
        webpage.pages[ctx.pagename].tpl[t] = wcoinfo.tpl[t];
      }
    });
  }
  // check that tpldata exist for the wco, if not create them with template data example into the project
  //console.log(wcoinfo,ctx)
  if (
    !ctx.tagid &&
    wcoinfo.tpldatamodel &&
    Object.keys(wcoinfo.tpldatamodel).length > 0
  ) {
    console.log(
      `Warning: you add a wco that request tagid to initiate tpldata into your project, please add in wwws/getwco/${wcoinfo.wconame}.js?xx&tagid=id1,id2 where this wco is used`
    );
  }
  if (
    ctx.tagid &&
    wcoinfo.tpldatamodel &&
    Object.keys(wcoinfo.tpldatamodel).length > 0
  ) {
    Object.keys(wcoinfo.tpldatamodel).forEach((t) => {
      //tagid can concern many id then tagid=idA,idB,idC
      ctx.tagid = ctx.tagid.includes(",") ? ctx.tagid.split(",") : [ctx.tagid];
      ctx.tagid.forEach((tid) => {
        const pathtpldata = `${ctx.tribe}/objects/wwws/${ctx.xapp}/src/tpldata/${ctx.pagename}/${tid}_${t}`;
        console.log("pathtpldata:", pathtpldata);
        const localdbname = `${ctx.pagename}_${tid}_${t}`;
        if (
          !Object.keys(webpage.pages[ctx.pagename].tpldata).includes(
            localdbname
          )
        ) {
          webpage.pages[ctx.pagename].tpldata[localdbname] = pathtpldata;
        }
        wcoinfo.lang.forEach((l) => {
          if (!fs.existsSync(`../${wcoinfo.tpldatamodel[t]}_${l}.json`)) {
            console.log(
              `Warning, this file is suppose to exist ../${wcoinfo.tpldatamodel[t]}_${l}.json  check lg or mispelling`
            );
          }
          if (
            !fs.existsSync(`../${pathtpldata}_${l}.json`) &&
            fs.existsSync(`../${wcoinfo.tpldatamodel[t]}_${l}.json`)
          ) {
            const tpldataexample = fs.readJSONSync(
              `../${wcoinfo.tpldatamodel[t]}_${l}.json`
            );
            Object.keys(ctx).forEach((k) => {
              if (k == "tagid") {
                tpldataexample[k] = tid;
              } else {
                tpldataexample[k] = ctx[k];
              }
            });
            fs.outputJSONSync(`../${pathtpldata}_${l}.json`, tpldataexample, {
              spaces: 2,
            });
          }
        });
      });
    });
  }
  // check if referential are there for this wco
  if (wcoinfo.ref && Object.keys(wcoinfo.ref).length > 0) {
    Object.keys(wcoinfo.ref).forEach((t) => {
      t = t.replace("{{tribe}}", ctx.tribe);
      if (!Object.keys(webpage.pages[ctx.pagename].ref).includes(t)) {
        webpage.pages[ctx.pagename].ref[t] = wcoinfo.ref[t];
      }
    });
  }
  //check that schema are also their for wco
  if (wcoinfo.schema && wcoinfo.schema.length > 0)
    [
      wcoinfo.schema.forEach((s) => {
        s = s.replace("{{tribe}}", ctx.tribe);
        if (!webpage.pages[ctx.pagename].schema.includes(s)) {
          webpage.pages[ctx.pagename].schema.push(s);
        }
      }),
    ];
  // save the conf for update localdb when the web page request it
  fs.outputJSONSync(webconf, webpage, { spaces: 2 });
  // create a text file with component to watch for tailwind
  let sourcetw=""
  webpage.tailwindcsscontent.forEach(s=>{
    sourcetw+=`@source "${s}";\n`
  })
  fs.outputFileSync(`../${ctx.tribe}/objects/wwws/${ctx.xapp}/src/static/css/sourcetw.css`,sourcetw,"utf-8");
  return {
    status: 200,
    ref: "Wwws",
    msg: "wcoupdatesuccessinpageconf",
    data: { file: path.resolve(filereq) },
  };
};

Wwws.build = (tribeId, webapp, srcdist, options) => {
  console.log(`Building ${tribeId}/objects/wwws/${webapp}/${srcdist}`);
  /*
  mettre en cdn de la tribe /cdn/share/lib/nom du fichier 
  /adminapi/node_modules/axios/dist/axios.min.js ds /cdn/lib/axios/dist/axios.min.js
  et dans html le build sera src="/cdn/lib/axios/dist/axios.min.js"

  */
  const pathto = `../${tribeId}/objects/wwws`;
  let confwww;
  if (fs.existsSync(`${pathto}/itm/${webapp}.json`)) {
    confwww = fs.readJSONSync(`${pathto}/itm/${webapp}.json`);
  } else {
    confwww = {
      website: webapp,
      appimgs: [],
      commentappimg:
        "Image list in src that are used by app that must be copy into /dist",
      apxtri: {
        headers: {
          xtrkversion: 1,
          xalias: "anonymous",
          xapp: webapp,
          xdays: 0,
          xhash: "anonymous",
          xlang: "fr", // it changed in browser with wco/apx/apx.js from html lang value
          xprofils: "anonymous",
          xtribe: tribeId,
          xuuid: "0",
        },
      },
      pages: {},
    };
  }
  //console.log(confwww.pages);
  if (srcdist == "dist") {
    fs.removeSync(`${pathto}/${webapp}/dist`);
    fs.mkdirSync(`${pathto}/${webapp}/dist`);
  }
  let appimgs = {}; // to store any image used in all html
  glob.sync(`${pathto}/${webapp}/src/*.html`).forEach(async (f) => {
    // @todo parse each html and get relevant information to copy and paste to dist confwww
    const pginfo = path.parse(f).name.split("_");
    const lg = pginfo.pop();
    const pgname = pginfo.join("_");
    console.log(f, pgname);
    if (!confwww.pages[pgname]) {
      confwww.pages[pgname] = {
        version: 1,
        languages: [],
        profils: ["anonymous"],
        tpl: {},
        tpldata: {},
        itms: {},
        ref: {},
        schema: [],
        options: {},
        wcodata: {},
        appdata: {},
      }; // test if lib exist or not if not create a symlink with node_modules
      /*if (
        (src.includes("static/lib/") || src.includes("wco/")) &&
        !fs.existsSync(`${pathto}/${webapp}/src/${src}`)
      ) {
        Wwws.getsymlink(`${pathto}/${webapp}/src/${src}`, tribe);
      }*/
    }
    if (!confwww.pages[pgname].languages.includes(lg))
      confwww.pages[pgname].languages.push(lg);

    const pgtxt = fs.readFileSync(f, "utf8");
    const pg = new JSDOM(pgtxt);
    const dc = pg.window.document;
    let pgscripts = [];
    dc.querySelectorAll("script[src]").forEach((s) => {
      if (
        /\/api\/.*\/wwws\/objects\/wco\/itm\/.*/.test(s.src) &&
        !pgscripts.includes(s.src)
      ) {
        pgscripts.push(s.getAttribute("src"));
      }
    });
    dc.querySelectorAll("img[src]").forEach((s) => {
      const imgsrc = s.getAttribute("src");
      s.setAttribute(
        "src",
        imgsrc.replace(/(.*)\.(png|png|gif|bmp|jpg|jpeg)$/, "$1.webp")
      );
      if (!appimgs[imgsrc]) {
        appimgs[imgsrc] = { pages: [] };
      }
      appimgs[imgsrc].pages.push(pginfo);
    });
    let wcojs = "";
    pgscripts.forEach((s) => {
      if (s[0] !== "/" && s.substring(0, 4) != "http") {
        // file must be copy to dist if / means it is absolute not relative
        if (s.includes("wco/")) {
          //console.log(`${pathto}/${webapp}/src/wco/${path.parse(s).name}/*.mustache`)
          glob
            .sync(
              `${pathto}/${webapp}/src/wco/${path.parse(s).name}/*.mustache`
            )
            .forEach((m) => {
              const tplname = path.parse(m).name.replace(/_..$/, "");
              confwww.pages[pgname].tpl[
                `${path.parse(s).name}${tplname}`
              ] = `${tribeId}/${m.replace(/_..\.mustache$/, "")}`;
            });
          dc.querySelectorAll(`script[src='${s}']`).forEach((e) => e.remove());
          wcojs +=
            fs.readFileSync(`${pathto}/${webapp}/src/${s}`, "utf8") + "\n";
        } else {
          if (srcdist == "dist") {
            fs.copySync(
              `../${tribeId}/objects/wwws/${webapp}/src/${s}`,
              `../${tribeId}/objects/wwws/${webapp}/dist/${s}`
            );
          }
        }
      }
    });
    glob
      .sync(`${pathto}/${webapp}/src/tpldata/${pgname}/*.json`)
      .forEach((t) => {
        const tpldataname = path.parse(t).name.replace(/_..$/, "");
        console.log("tpldata:", tpldataname);
        confwww.pages[pgname].tpldata[tpldataname] = `${tribeId}/${t.replace(
          /_..\.json$/,
          ""
        )}`;
      });
    if (srcdist == "dist") {
      //add last script static/js/pagenamewco.js
      const swco = dc.createElement("script");
      swco.src = `static/js/${pgname.replace(/_..$/, "")}wco.js`;
      swco.type = "text/javascript";
      dc.head.appendChild(swco);
      const minijswco = await minijs(wcojs, {
        compress: {
          drop_console: true, // Supprime les appels console.log
          passes: 2, // Effectue plusieurs passes pour optimiser davantage
        },
        mangle: {
          toplevel: true, // Renomme les variables au niveau supérieur
        },
      });
      fs.outputFileSync(
        `${pathto}/${webapp}/dist/static/js/${pgname.replace(
          /_..$/,
          ""
        )}wco.js`,
        minijswco.code,
        "utf8"
      );
      const minipg = minihtml(pg.serialize(), {
        collapseWhitespace: true,
        removeComments: true,
        removeRedundantAttributes: true,
        minifyCSS: true,
        minifyJS: true,
      });
      fs.outputFileSync(
        `${pathto}/${webapp}/dist/${pgname}_${lg}.html`,
        minipg,
        "utf8"
      );
    }
  });
  //console.log(appimgs)

  const commonfilestrt = {};

  // force some image to be in dist that are not existing in html mainly used by wco app
  confwww.commonfiles.forEach((i) => {
    const src = `${pathto}/${webapp}/src/${i}`;
    const dist = `${pathto}/${webapp}/dist/${i}`;
    //console.log(imgsrc,"---------------",imgdist)
    if (!fs.existsSync(src)) {
      commonfilestrt[src] = {
        ERROR: `this file does not exist request by wwws/itm/${webapp}.json`,
      };
    } else if (!fs.existsSync(dist)) {
      fs.ensureDirSync(path.dirname(dist));
      fs.copyFileSync(src, dist);
    }
  });
  const imgtrt = {};
  Object.keys(appimgs).forEach(async (i) => {
    const imgsrc = `${pathto}/${webapp}/src/${i}`;
    const imgdist = `${pathto}/${webapp}/dist/${i.replace(
      /(.*)\.(png|png|gif|bmp|jpg|jpeg)$/i,
      "$1.webp"
    )}`;
    console.log("imgsrc:", imgsrc, " imgdist:", imgdist);
    if (fs.existsSync(imgsrc)) {
      const srcstats = fs.statfsSync(imgsrc);
      let newimg = sharp(imgsrc);
      const srcmetadata = await newimg.metadata();
      if (!fs.existsSync(imgdist)) {
        if (
          srcstats.size > 2 * 1024 * 1024 ||
          srcmetadata.width > 1920 ||
          srcmetadata.height > 1080
        ) {
          newimg = newimg.resize({ width: 1920, height: 1080, fit: "inside" });
        }
        fs.ensureDirSync(path.dirname(imgdist));
        await newimg.webp({ quality: 80 }).toFile(imgdist);
      }
      const diststats = fs.statfsSync(imgdist);
      const distmetadata = await sharp(imgdist).metadata();
      imgtrt[imgsrc] = {
        dest: imgdist,
        srcstats,
        srcmetadata,
        diststats,
        distmetadata,
      };
    } else {
      imgtrt[imgsrc] = { ERROR: `${imgsrc} this file does not exist` };
    }
  });
  // saved new conf for updatelocaldb data
  fs.outputJSONSync(`${pathto}/itm/${webapp}.json`, confwww, { spaces: 2 });
  console.log(imgtrt);
  return {
    status: 200,
    ref: "Wwws",
    msg: "success",
    data: { imgtrt, commonfilestrt },
  };
};

if (process.argv && process.argv.length == 5) {
  const tribe = process.argv[2];
  const webapp = process.argv[3];
  const srcdist = process.argv[4];
  console.log(
    `Run from node.js command (tribe=${tribe} webapp=${webapp} yarn ${srcdist}:css)`
  );
  if (
    fs.pathExistsSync(`../${tribe}`) &&
    fs.pathExistsSync(`../${tribe}/objects/wwws/${webapp}`)
  ) {
    console.log(Wwws.build(tribe, webapp, srcdist, {}));
  } else {
    console.log(
      `Sorry your parameter are not set properly ../${tribe}/objects/wwws/${webapp} does not exist`
    );
  }
}

Wwws.initlocalwco = (tribwco, profils, lg) => {
  const wco = {};
  Object.keys(tribwco).forEach((t) => {
    if (!fs.existsSync(`../${tribwco}`)) {
    }
  });
};

Wwws.initlocaldata = (tribe, appname, pagename, version, profils, lg) => {
  const fileparam = `../${tribe}/objects/wwws/itm/${appname}.json`;
  //console.log(path.resolve(fileparam));
  if (!fs.existsSync(fileparam)) {
    return {
      status: 404,
      ref: "Wwws",
      msg: "appdoesnotexist",
      data: { fileparam },
    };
  }
  const locals = fs.readJSONSync(fileparam);
  if (!locals.pages[pagename]) {
    return {
      status: 200,
      ref: "Wwws",
      msg: "pagedoesnotexist",
      data: { pagename },
    };
  }
  if (locals.pages[pagename].version == version) {
    return { status: 200, ref: "Wwws", msg: "nonewdatamodel", data: {} };
  }
  let authorize = false;
  profils.forEach((p) => {
    authorize = authorize || locals.pages[pagename].profils.includes(p);
  });
  if (!authorize) {
    return {
      status: 200,
      ref: "Wwws",
      msg: "forbidenaccess",
      data: { pagename, profils },
    };
  }
  //check version
  const initname = `../${tribe}/tmp/initlocaldata/${tribe}_${appname}_${pagename}_${lg}_${locals.pages[pagename].version}.json`;
  if (fs.existsSync(initname) && 1 != 1) {
    const init = fs.readJsonSync(initname);
    if (init.app.version == locals.app.version) {
      return { status: 200, ref: "Wwws", msg: "datamodelnoupdate", data: init };
    }
  }
  const localstorage = {
    version: locals.pages[pagename].version,
    headers: locals.apxtri.headers,
    confpage: locals.pages[pagename].confpage,
    req: {},
    itm: {},
    itms: {},
    options: {},
    tpl: {},
    tpldata: {},
    tpldatanew: {},
    ref: {},
    schema: {},
    screens: {},
    screensnew: {},
  };
  localstorage.headers.xlang = lg;
  // A faire plus tard charger tous les referentiele et les data pour une page adminpage
  /* if (pagename=="pageadmin"){
    // load any referentialdata
    glob.Sync(`../${tribe}/objects/*.json`).forEach(f=>{
      if (!localstorage.schema.includes(`${tribe}/objects/${path.basename(f,".json")}`)){
        localstorage.schema.push(`${tribe}/objects/${path.basename(f,".json")}`)
      }
    })

  }
  */
  const loc = locals.pages[pagename];
  if (loc.itms) {
    Object.keys(loc.itms).forEach((r) => {
      const src = `../${loc.itms[r]}.json`;
      if (fs.existsSync(src)) {
        localstorage.itms[r] = fs.readJSONSync(src);
      } else {
        localstorage.itms[
          r
        ] = `Check your ${fileparam} for itms in ${pagename} and ${r}`;
      }
    });
  }
  if (loc.ref) {
    Object.keys(loc.ref).forEach((r) => {
      const src = `../${loc.ref[r]}_${lg}.json`;
      if (fs.existsSync(src)) {
        localstorage.ref[r] = fs.readJSONSync(src);
      } else {
        localstorage.ref[
          r
        ] = `Check your ${fileparam} for ref in ${pagename} and ${r}`;
      }
    });
  }
  if (loc.options) {
    Object.keys(loc.options).forEach((r) => {
      const src = `../${loc.options[r]}_${lg}.json`;
      //console.log(path.resolve(src))

      if (fs.existsSync(src)) {
        localstorage.options[r] = fs.readJSONSync(src);
      } else {
        localstorage.options[
          r
        ] = `Check your ${fileparam} for options in ${pagename} profil and ${r}`;
      }
    });
  }
  if (!loc.tpl) loc.tpl = {};
  if (!loc.tpldata) loc.tpldata = {};
  if (!loc.tpldatanew) loc.tpldatanew = {};
  // remove loc.components (this is now in tpldata and tpl)
  if (loc.components) {
    loc.components.forEach((c) => {
      console.log("ggggggggggggggggg", c);
      const componame = path.basename(c);
      loc.tpl[componame] = `${c}/${componame}.mustache`;
      loc.tpldata[componame] = `${c}/${componame}`;
    });
  }
  if (loc.tpl) {
    Object.keys(loc.tpl).forEach((r) => {
      // possible to store an independant language mustache
      let src = `../${loc.tpl[r]}`;
      if (!fs.existsSync(src)) {
        src += `_${lg}.mustache`;
      }
      //console.log(path.resolve(src))
      if (fs.existsSync(src)) {
        localstorage.tpl[r] = fs.readFileSync(src, "utf-8");
      } else {
        localstorage.tpl[
          r
        ] = `Check your ${fileparam} for template in ${pagename} profil and ${r}`;
      }
    });
  }
  if (loc.tpldata) {
    Object.keys(loc.tpldata).forEach((r) => {
      let src = `../${loc.tpldata[r]}`;
      //console.log(path.resolve(src))
      if (!fs.existsSync(src)) {
        src += `_${lg}.json`;
      }
      if (fs.existsSync(src)) {
        localstorage.tpldata[r] = fs.readJSONSync(src);
      } else {
        localstorage.tpldata[
          r
        ] = `Check your ${fileparam} for template in ${pagename} profil and ${r} in tpldata`;
      }
    });
  }
  if (loc.tpldatanew) {
    Object.keys(loc.tpldatanew).forEach((r) => {
      let src = `../${loc.tpldatanew[r]}`;
      //console.log(path.resolve(src))
      if (!fs.existsSync(src)) {
        src += `_${lg}.json`;
      }
      if (fs.existsSync(src)) {
        localstorage.tpldatanew[r] = fs.readJSONSync(src);
      } else {
        localstorage.tpldatanew[
          r
        ] = `Check your ${fileparam} for template in ${pagename} profil and ${r} in tpldatanew`;
      }
    });
  }
  if (!loc.screens) loc.screens = {};
  if (loc.screens) {
    Object.keys(loc.screens).forEach((r) => {
      let src = `../${loc.screens[r]}`;
      //console.log(path.resolve(src))
      if (!fs.existsSync(src)) {
        src += `_${lg}.json`;
      }
      if (fs.existsSync(src)) {
        localstorage.screens[r] = fs.readJSONSync(src);
      } else {
        localstorage.screens[
          r
        ] = `Check your ${fileparam} for template in ${pagename} profil and ${r} in screens`;
      }
    });
  }
  if (!loc.screensnew) loc.screensnew = {};
  if (loc.screensnew) {
    Object.keys(loc.screensnew).forEach((r) => {
      let src = `../${loc.screensnew[r]}`;
      //console.log(path.resolve(src))
      if (!fs.existsSync(src)) {
        src += `_${lg}.json`;
      }
      if (fs.existsSync(src)) {
        localstorage.screensnew[r] = fs.readJSONSync(src);
      } else {
        localstorage.screensnew[
          r
        ] = `Check your ${fileparam} for template in ${pagename} profil and ${r} in screensnew`;
      }
    });
  }
  if (loc.schema) {
    loc.schema.forEach((objpath) => {
      const name = path.basename(objpath);
      const schema = Odmdb.Schema(`../${objpath}`, false, lg);
      if (schema.status == 200) {
        localstorage.schema[name] = schema.data.schema;
      } else {
        //console.log(schema);
        let msg = `Check your ${fileparam} for schema in ${pagename}, for ${schema.status} ${schema.ref} ${schema.msg} :`;
        if (schema.status == 406) {
          if (schema.msg) msg += schema.msg;
          if (schema.multimsg) {
            schema.multimsg.forEach((err) => {
              msg += `${err.msg} ${JSON.stringify(err.data)})`;
            });
          }
        }
        localstorage.schema[name] = msg;
      }
    });
  }
  if (loc.wcodata) {
    //data that must be updated in case of change in the browser
    localstorage.wco = loc.wcodata;
  }
  if (loc.appdata) {
    //basic information to this page (menu, header, footer, company, other)
    localstorage.appdata = loc.appdata;
  }

  return {
    status: 200,
    ref: "Wwws",
    msg: "datamodelupdate",
    data: localstorage,
  };
};

/*Wwws.apxtriinstall = (paramconf) => {
  if (fs.existsSync(`${conf.dirtown}/conf.json`)) {
    console.log("You already have a conf on this town");
    process.exit();
  }
  //first install
  const nginxconf = fs.readFileSync(
    `${conf.dirapi}/adminapi/www/adminapx/conf/nginx.conf.mustache`,
    "utf8"
  );
  const proxyparams = fs.readFileSync(
    "../nationchains/www/adminapx/static/tpl/nginxproxy_params.mustache",
    "utf8"
  );
  // saved and change nginx conf
  if (!fs.existsSync("/etc/nginx/nginxconf.saved")) {
    fs.moveSync("/etc/nginx/nginx.conf", "/etc/nginx/nginxconf.saved");
    console.log(
      "your previous /etc/nginx/nginx.conf was backup in  /etc/nginx/nginxconf.saved"
    );
  }
  fs.outputFileSync(
    "/etc/nginx/nginx.conf",
    mustache.render(nginxconf, paramconf),
    "utf8"
  );
  fs.outputFileSync(
    "/etc/nginx/proxy_params",
    mustache.render(proxyparams, paramconf),
    "utf8"
  );ln -s ../../../../../../../adminapi/node_modules/axios axios
  if (!fs.existsSync(paramconf.nginx.logs)) fs.mkdirSync(paramconf.nginx.logs);
  paramconf.nginx.firstinstall = true;
  fs.outputJsonSync("../tribes/conf.json", paramconf, {
    space: 2,
  });

  return Www.create(paramconf.nginx);
};
*/
Wwws.create = (paramnginx) => {
  /**
   * Create an nginx conf to make available a spaceweb for a tribe /www/appname/
   *
   * create
   * /dist
   * /src/static/lib/
   *     ln -s ../../../../../../../adminapi/node_modules/axios axios
   *
   *
   *
   *
   *
   *
   *
   *
   */
  const res = {
    status: 200,
    ref: "Www",
    msg: "successfulwww",
    data: { website: paramnginx.website },
  };
  const nginxwebsite = fs.readFileSync(
    `${conf.dirapi}/adminapi/www/adminapx/conf/nginxmodelwebsite.conf.mustache`,
    "utf8"
  );
  fs.outputFileSync(
    `./${paramnginx.fswww}www/nginx_${paramnginx.website}.conf`,
    mustache.render(nginxwebsite, paramnginx),
    "utf8"
  );
  if (!fs.existsSync(`./${paramnginx.fswww}www/${paramnginx.website}`)) {
    //See later how to generate specific template of webapp
    fs.mkdirSync(`./${paramnginx.fswww}www/${paramnginx.website}`);
  }
  if (!fs.existsSync(`./${paramnginx.fswww}www/cdn`)) {
    //See later how to generate specific template of webapp
    fs.mkdirSync(`./${paramnginx.fswww}www/cdn`);
  }
  //restart nginx
  const { exec } = require("child_process");
  exec(paramnginx.restart, (error, stdout, stderr) => {
    if (error) {
      if (paramnginx.firstinstall) {
        console.log("\x1b[42m", error, stdout, stderr, "x1b[0m");
      }
      //@todo supprimer la derniere config et relancer
      res.status = 500;
      res.msg = "nginxError";
      res.data = { msg: `${error}<br>${stdout}<br>${stderr}` };
    } else {
      if (paramnginx.firstinstall) {
        // the tribes/conf.json is saved in apxtriinstall
        console.log(
          `\x1b[42m###########################################################################################\x1b[0m\n\x1b[42mWellcome into apxtri, you can now 'yarn dev' for dev or 'yarn startpm2' for prod or       \n'yarn unittest' for testing purpose. Access to your town here \x1b[0m\x1b[32mhttp://adminapx\x1b[0m \x1b[42m             \nto finish your town setup. Don't forget to set your localhost /etc/hosts by adding 127.0.0.1 adminapx or {LAN IP} adminapx .  Check README's project to learn more.                          \x1b[0m\n\x1b[42m###########################################################################################\x1b[0m`
        );
      } else {
        // add website to tribe conf
      }
    }
  });
  return res;
};
Wwws.setssl = () => {
  // Run process to change nginx conf to get a ssl
};

Wwws.configlist = (tribeId) => {
  //if accessright R return list of conf parameter {webapp:{conf parameter}}
  const res = { status: 200, data: {} };
  return res;
};

module.exports = Wwws;