const glob = require("glob");
const path = require("path");
const fs = require("fs-extra");
const axios = require('axios');
//const config = require( '../tribes/townconf.js' );
const Checkjson = require(`./Checkjson.js`);

/* This manage Objects for indexing and check and act to CRUD
   objectpath/objects/schema/objectName.json
                     /objectNames/searchindes/objectName_valueofkey_uuildlist.json
                     /objectNames/uuid.json

*/
const Odmdb = {};
/*
Input: metaobject => data mapper of Key: Value

  objname + an object {} + action Checkjson => get a valid or not answer
  objname + an object {} + action search => apply matching algo to find probalistic object id
  objname + action index => update /searcindex of objects concern

*/
Odmdb.setObject=(schemaPath, objectPath, objectName, schema, lgjson, lg)=>{
  /*
  @schemapath {string} path to create or replace a schema ${schemaPath}/schema/
  @objectPath {string} path where object are store 
  @objectName {string} name of the object
  @schema     {object} the json schema for this object
  @lgjson     {object} the json file for a specific language
  @lg         {string} the 2 letters language

  a shema   :
      schemaPath/schema/objectName.json
                       /lg/objectName_{lg}.json
  an object :
      objectPath/objectName/index/config.json ={"schema":"relativpathfile or http"}
                           /uniqueid.json defining schema
  
  */
  if (!fs.existsSync(schemaPath)){
    return {status:404, ref:"Odmdb", info:"pathnamedoesnotexist", moreinfo:{fullpath:schemaPath}}
  }
  if (!fs.existsSync(objectPath)){
    return {status:404, ref:"Odmdb", info:"pathnamedoesnotexist",moreinfo:{fullpath:objectPath}}
  }
  // store schema file if not empty undefined or {}
  if (schema && !(Object.keys(schema).length === 0 && schema.constructor === Object)){
    fs.outputJSONSync(`${schemaPath}/schema/${objectName}.json`,schema, {spaces:2})
  }
  if (lgjson && lg && !(Object.keys(lgjson).length === 0 && lgjson.constructor === Object)){ 
    fs.outputJSONSync(`${schemaPath}/lg/${objectName}_${lg}.json`,lgjson, {spaces:2})
  }
  //create environnement object with the new schema config
  if (!fs.existsSync(`${objectPath}/${objectName}`)){
    fs.outputJsonSync(`${objectPath}/${objectName}/index/config.json`,{schema:`${schemaPath}/schema/${objectName}.json`},{spaces:2})
  }
  return {status:200}
}

Odmdb.schema = (schemaPath, objectName, withschemacheck) => {
  // Return schema if exist and objectpath contain objectName { status:200;data:schema}
  if (!fs.existsSync(`${schemaPath}/${objectName}`))
    return {
      status: 404,
      info: "|odmdb|schemapathnamedoesnotexist",
      moreinfo: `${schemaPath}/${objectName}`,
    };
  if (!fs.existsSync(`${objectPath}/schema/${objectName}.json`)) {
    return {
      status: 404,
      info: `|odmdb|schemanotfound`,
      moreinfo: `file not found ${schemaPath}/schema/${objectName}.json`,
    };
  }
  const schema = fs.readJsonSync(`${schemaPath}/schema/${objectName}.json`);
  // check schema apx validity specificities primary unique ans searchindex
  if (withschemacheck) {
    if (!schema.apxprimarykey) {  
      // code 422: unprocessable Content
      return {
        status: 422,
        info: "|Odmdb|apxprimarykeynotfound",
        moreinfo: `${schemaPath}/schema/${objectName}.json`,
      };
    } else {
      if (
        !(
          schema.apxsearchindex[schema.apxprimarykey] &&
          schema.apxsearchindex[schema.apxprimarykey].list
        )
      ) {
        return {
          status: 422,
          info: "|Odmdb|apxprimaryketnotinsearchindexlist",
          moreinfo: `${schemaPath}/schema/${objectName}.json`,
        };
      }
      if (schema.apxuniquekey) {
        schema.apxuniquekey.forEach((k) => {
          if (
            !(
              schema.apxsearchindex[k] &&
              schema.apxsearchindex[k][schema.apxprimarykey]
            )
          ) {
            return {
              status: 422,
              info: "|Odmdb|apxuniquekeynotinsearchindex",
              moreinfo: `${schemaPath}/schema/${objectName}.json`,
            };
          }
        });
      }
    }
    const validschema = Checkjson.schema.validation(schema);
    if (validschema.status != 200) return validschema;
  }
  return {
    status: 200,
    data: schema,
  };
};

Odmdb.Checkjson = (objectPath, objectName, data, withschemacheck) => {
  /*
  @objectPath path to the folder that contain /objects/objectName/ /lg/objectName_{lg}.json /schema/objectName.json
  @objectName name of object
  @data data to check based on schema objectName definition
  
  @return status:200 Data is consistent with schema and primarykey does not exist
          status:201 Data is consistent with schema and primarykey does already exist
          status:other means unconsistent schema:
            404: schema does not exist
                 or unconsitent data and schema from Checkjson.js Checkjson.schema.data

  */
  const res = { status: 200 };
  //get schema link of object
    const schemaPath = fs.readJsonSync(`${objectPath}/${objectName}/index/config.json`)['schema']
    if (schemaPath.substring(0,4)=="http"){
      // lance requete http pour recuperer le schema
    }else{
      schema=="!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
    }
  // check schema validity
  const schema = Odmdb.schema(objectPath, objectName, withschemacheck);
  if (schema.status != 200) return schema;
  console.log("SCHEMA for checking:");
  console.log(schema.data);
  console.log("DATA to check:");
  console.log(data);
  // withschemacheck at false, if check then it is done at Odmdb.schema
  const validate = Checkjson.schema.data(schema.data, data, false);
  if (validate.status != 200) {
    return validate;
  }
  if (
    schema.data.apxprimarykey &&
    data[k] &&
    fs.existsSync(`${objectPath}/${objectName}/${data[k]}.json}`)
  ) {
    res.status = 201; // means created => exist an object with this primary key
  }
  if (schema.data.apxuniquekey) {
    schema.data.apxuniquekey.forEach((k) => {
      if (
        data[k] &&
        fs.existsSync(
          `${objectPath}/${objectName}/searchindex/${objectName}_${k}_${schema.data.apxprimarykey}.json}`
        ) &&
        fs.readJsonSync(
          `${objectPath}/${objectName}/searchindex/${objectName}_${k}_${schema.data.apxprimarykey}.json}`
        )[k]
      ) {
        res.status = 201; // means created => exist as primary key
      }
    });
  }
  return res;
};
Odmdb.search = (objectPath, objectName, search) => {
  /*
  @search= {
    txt: string,
    algo: match | pattern | fuzzy
    fieldstring:[list of field],
    indexfilter:{index1:[val1,val2 | ] }
  }
  Return data:[uuids]

  example: search exact match hill in townId
   heavy search={txt:"hill",algo:"match",fieldstring:"toxnId"}
   light search={txt:"hill", algo:"match", indexfilter:{"key":"townId","value":[]}}
   light search={txt:"hill", algo:"match", indexfilter:{"key":"nationId","value":"ants"}}

   */
  const schema = Odmdb.schema(objectPath, objectName);
  if (schema.status != 200) return schema;
};
Odmdb.get = (objectPath, objectName, uuidprimarykeyList, fieldList) => {
  /*
  @uuidprimarykeyList list of uuid requested
  @fieldList key to return for each object
  Return objectName {status:200; data:{found:[{primarykey,field}],notfound:[uuid]}
  if all primarykey exist then data.notfound does not exist
  if all primarykey does not exist data.found does not exist
  */
  const res = { status: 200, data: {} };
  uuidprimarykeyList.forEach((id) => {
    if (fs.existsSync(`${objectPath}/${objectName}/${id}.json`)) {
      if (!res.data.found) res.data.found = [];
      const objectdata = fs.readJsonSync(
        `${objectPath}/${objectName}/${id}.json`
      );
      if (!fieldList) {
        res.data.found.push(objectdata);
      } else {
        const objinfo = {};
        fieldlList.forEach((k) => {
          if (objectdata[k]) objinfo[k] = objectdata[k];
        });
        res.data.found.push(objinfo);
      }
    } else {
      if (!res.data.notfound) res.data.notfound = [];
    }
  });
  return res;
};
Odmdb.create = (objectPath, objectName, data) => {
  /*
  Create an objects data into objectName 
  @objectPath path to the folder that contain /objects/objectName/ /objectsInfo/objectName_lg.json /objectsMeta/objectName.json
  @objectName name of object
  @data data to check based on objectsMeta definition 
  */
};
Odmdb.update = (objectPath, objectName, data) => {
  /*
  Create an objects data into objectName 
  @objectPath path to the folder that contain /objects/objectName/ /objectsInfo/objectName_lg.json /objectsMeta/objectName.json
  @objectName name of object
  @data data to check based on objectsMeta definition  
  */
};
Odmdb.delete = (objectPath, objectName, data) => {
  /*
  Create an objects data into objectName 
  @objectPath path to the folder that contain /objects/objectName/ /objectsInfo/objectName_lg.json /objectsMeta/objectName.json
  @objectName name of object
  @data data to check based on objectsMeta definition  
  */
};
/*console.log("test Odmdb");
console.log(
  Odmdb.check(
    "/media/phil/usbfarm/apxtrib/nationchains/socialworld/objects",
    "nations",
    { nationId: "123", status: "unchain" }
  )
);*/
module.exports = Odmdb;