/*
 * configFS.h
 * File-class for config
 * for configuration of user-data
 * 
 * author Creator P.Rebesky
 * Copyright (©): 2023 by Peter Rebesky
 * This code can use in private cases only. Every business or companies using of this codes or codes parts is required an approval of us (me)
 * Every private use can exchange some parts of code or modify some code-lines. This code can change for private use only.
 * This software is basicly owned by Peter Rebesky and any comercial using is forbidden without approval of us (me).
 * Version 1.00 
 * 10.02.2023 
 */
#ifndef CONFIG_FS_H_
#define CONFIG_FS_H_

// class for manage config-data into and from file "config.ini"
#include "global.h"
#include <LittleFS.h> // LittleFS is declared

#define __TARGET_SERVER "t_url"
#define __NAME_IoT "n_iot"
#define __SWITCH_TEMP "s_temp"
#define __AUTOMATIC "a_enab"
#define __CONTENT_TYPE "c_type"
#define __PUSH_PULL "c_push"
#define __HTTP "http://"
#define __HTTPS "https://"
#define __SENSOR1 "n_sens1"
#define __SENSOR2 "n_sens2"
#define __SENSOR3 "n_sens3"
#define __SENSOR4 "n_sens4"

/***** class for save data intern into ESP8266 *****/
class configFS {
  private:
  	String TARGET_URL="http://yourServer/temperature.php";
    String NAME_IoT="Temp-Control";
    String Sensor1="Sensor 1";
    String Sensor2="Sensor 2";
    String Sensor3="Sensor 3";
    String Sensor4="Sensor 4";
  	bool MOUNTED = false;
    bool CONFIG_LOAD = false;
  	void loadConfig(String s);
    int calculateFreeSpaceFS();
    unsigned char h2int(char c);
    String getTargetWithout();
    bool checkHTTPadjustTime();
	
  public:
    int SwitchOnTemp=4;
    int SwitchOffTemp=2;
    int FREESPACE=0;
    bool sendPUSH=true; // true: sending POST data to server, false: no sending only answer per get
    bool sendJSON=true; // true: send as JSON, false: send as URL-encoded
    int SendSSL=0;  // 0 = send over http, send over https
    bool begin();		// start to get data from file
  	String getTargetURL();
    String getTargetURLclean();
    String getTargetServer();
    String getName();
    bool readconfigFS();
    bool saveconfigFS();
    int getFreeSpace();
    bool savePostValues(String saveValues);
    String decodeOnValue(String s);
    String getOnePostValue(String post,String ident);
    String getOneFileValue(String file,String ident);
    String urldecode(String str);
    String urlencode(String str);
    void saveValues(String str);
    String readSavedValues(int pointer);
    String getSensorName(int sensor);
    void end();
// debug functions
    bool getMounted();
};
/**** mount the file-object ****/
bool configFS::begin(){
	if(LittleFS.begin()){
		this->MOUNTED = true;
    this->CONFIG_LOAD=this->readconfigFS();
    this->calculateFreeSpaceFS();
	}
	return this->MOUNTED;
}
/**** read values from file or create new default-values ****/
bool configFS::readconfigFS(){
bool r=false;
File Fconfig = LittleFS.open("/config.ini","r");
	if (Fconfig){
		String s=Fconfig.readString();
		this->loadConfig(s);
		Fconfig.close();
		r = true;
	}
return r;
}
/****** for compatibility ******/
void configFS::end(){
//	do nothing, it's for compatibility only
}
/****** debug function *****/
bool configFS::getMounted(){
  return this->MOUNTED;
}
/******** handle target URL ******/
String configFS::getName(){
return this->NAME_IoT; 
}
/******** get sensor name *********/
String configFS::getSensorName(int sensor){
  switch(sensor){
    case 1: return this->Sensor1; break;
    case 2: return this->Sensor2; break;
    case 3: return this->Sensor3; break;
    case 4: return this->Sensor4; break;
    default: return "not defined"; break;
  }
}
/******** handle target URL clean******/
String configFS::getTargetURLclean(){
return getTargetWithout(); 
}
/******** handle target URL ******/
String configFS::getTargetURL(){
return this->TARGET_URL; 
}
/****** handle update server ******/
String configFS::getTargetServer(){
  String url = getTargetWithout();
  int urlEnd = url.indexOf("/",0);
  return url.substring(0,urlEnd);
}
//*** get return without http r https ******/
String configFS::getTargetWithout(){
  String url;
  int httpString = this->TARGET_URL.indexOf(__HTTP,0);
  int httpsString = this->TARGET_URL.indexOf(__HTTPS,0);
  if(httpString != -1){
    url=TARGET_URL.substring(httpString+7);
    SendSSL=0;
  }else if(httpsString != -1){
    url=TARGET_URL.substring(httpsString+8);
    SendSSL=1;
  }else{
    url=this->TARGET_URL;
    SendSSL=0;
  }
  return url; 
}
/*** end ***/
bool configFS::checkHTTPadjustTime(){
    if(this->TARGET_URL.indexOf(__HTTPS,0) >= 0) SendSSL=1;
    else SendSSL =0;
    if(SendSSL==1) _secAdjust=_ADJUST_HTTPS;
    else _secAdjust=_ADJUST_HTTP;

  return true;
}
/**** save actuelle config-data ****/
bool configFS::saveconfigFS(){
  bool r = false;
  String s = "{\n";
  s += "Config: \"";  s += 1; s += "\",\n";
  s += "Name_IoT: \"";  s += this->NAME_IoT; s += "\",\n";
  s += "Name_Sens1: \"";  s += this->Sensor1; s += "\",\n";
  s += "Name_Sens2: \"";  s += this->Sensor2; s += "\",\n";
  s += "Name_Sens3: \"";  s += this->Sensor3; s += "\",\n";
  s += "Name_Sens4: \"";  s += this->Sensor4; s += "\",\n";
  s += "Target_URL: \"";  s += this->TARGET_URL; s += "\",\n";
  s += "Switch_Temp: \""; s += this->SwitchOnTemp; s += "\",\n";
  s += "Cont_Type: \""; s += this->sendJSON; s += "\",\n";
  s += "Push_Pull: \""; s += this->sendPUSH; s += "\"\n";
  s += "}";

//  Serial.println(s);
  if(this->MOUNTED){
    File Fconfig = LittleFS.open("/config.ini","w");
    if (Fconfig){
      int w=Fconfig.print(s);
      Fconfig.close();
      if (w > 1) r = true;  // write file was successful
    }
  }
  return r;
}
//******************* load one value from saved config *****************
String configFS::getOneFileValue(String file,String ident){
String ret;
  int argBegin = file.indexOf(ident);
  if(argBegin>0){
    int argEnd = file.indexOf(",",argBegin+2);
    ret = this->decodeOnValue(file.substring(argBegin, argEnd));
  }
return ret;
}
//******************* decode post-values *******************************
String configFS::getOnePostValue(String post,String ident){
  String returnValue="";
  if(post.length()>0){
    int identBegin = post.indexOf(ident);
    if(identBegin >= 0){
      int argEnd = post.indexOf("&",identBegin);
      if (argEnd == -1) argEnd = post.length();
      returnValue = post.substring(post.indexOf("=",identBegin)+1,argEnd);
    }
  }
  return this->urldecode(returnValue);  
}
/**** decode file-data and save into class ****/
void configFS::loadConfig(String s){
  if(getOneFileValue(s,"Config:").toInt()!=0){  // check if config-data is available. If not, then save default values at once
    this->NAME_IoT = getOneFileValue(s,"Name_IoT:");
    this->Sensor1 = getOneFileValue(s,"Name_Sens1:");
    this->Sensor2 = getOneFileValue(s,"Name_Sens2:");
    this->Sensor3 = getOneFileValue(s,"Name_Sens3:");
    this->Sensor4 = getOneFileValue(s,"Name_Sens4:");
    this->TARGET_URL = getOneFileValue(s,"Target_URL:");
    this->SwitchOnTemp = getOneFileValue(s,"Switch_Temp:").toInt();
    this->sendJSON = getOneFileValue(s,"Cont_Type:").toInt();
    this->sendPUSH = getOneFileValue(s,"Push_Pull:").toInt();
  }
  else this->saveconfigFS();  // save for the first time all default data
}
/**** extract one value from string ****/
String configFS::decodeOnValue(String s){
  int valueBegin = s.indexOf("\"");
  int valueLength = s.length();
  if(valueLength >0){
    if(valueBegin > 0){
      s = s.substring(valueBegin+1,valueLength-1);
    }
    else {
      valueBegin = s.indexOf(":");
      s = s.substring(valueBegin+1,valueLength);
    }
  }
  else s = "";
  return s;
}
/****** get free space from file-system ******/
int configFS::calculateFreeSpaceFS(){
  if(MOUNTED){
    FSInfo fsinfo;
    LittleFS.info(fsinfo);
    FREESPACE = fsinfo.totalBytes - fsinfo.usedBytes;
  }
  else FREESPACE = 0;
  return FREESPACE;
}
int configFS::getFreeSpace(){
  return this->FREESPACE;
}
/***** decode values from html-post-arguments *****/
bool configFS::savePostValues(String saveValues){
  bool r=false;
  if(saveValues.length()>0){
//    _debugString=saveValues;
    this->NAME_IoT = getOnePostValue(saveValues,__NAME_IoT);
    this->Sensor1 = getOnePostValue(saveValues,__SENSOR1);
    this->Sensor2 = getOnePostValue(saveValues,__SENSOR2);
    this->Sensor3 = getOnePostValue(saveValues,__SENSOR3);
    this->Sensor4 = getOnePostValue(saveValues,__SENSOR4);
    this->TARGET_URL = getOnePostValue(saveValues,__TARGET_SERVER);
    this->SwitchOnTemp = getOnePostValue(saveValues,__SWITCH_TEMP).toInt();
    this->sendJSON  = getOnePostValue(saveValues,__CONTENT_TYPE).toInt();
    this->sendPUSH  = getOnePostValue(saveValues,__PUSH_PULL).toInt();
 }
//  Serial.println(saveValues);
  return this->saveconfigFS();
}
/***** url decoding part *****/
unsigned char configFS::h2int(char c){
    if (c >= '0' && c <='9') return((unsigned char)c - '0');
    if (c >= 'a' && c <='f') return((unsigned char)c - 'a' + 10);
    if (c >= 'A' && c <='F') return((unsigned char)c - 'A' + 10);
    return(0);
}
/***** url decoding function ******/ 
String configFS::urldecode(String str){
    String encodedString="";
    char c;
    char code0;
    char code1;
    for (int i =0; i < str.length(); i++){
      c=str.charAt(i);
      if (c == '+') encodedString+=' ';  
      else if (c == '%') {
        i++;
        code0=str.charAt(i);
        i++;
        code1=str.charAt(i);
        c = (h2int(code0) << 4) | h2int(code1);
        encodedString+=c;
      }
      else encodedString+=c;  
      yield();
    }
   return encodedString;
}
/***** url encoding function ******/ 
String configFS::urlencode(String str){
    String encodedString="";
    char c;
    char code0;
    char code1;
    char code2;
    for (int i =0; i < str.length(); i++){
      c=str.charAt(i);
      if (c == ' ') encodedString+= '+';
      else if (isalnum(c)) encodedString+=c;
      else{
        code1=(c & 0xf)+'0';
        if ((c & 0xf) >9) code1=(c & 0xf) - 10 + 'A';
        c=(c>>4)&0xf;
        code0=c+'0';
        if (c > 9) code0=c - 10 + 'A';
        code2='\0';
        encodedString+='%';
        encodedString+=code0;
        encodedString+=code1;
        //encodedString+=code2;
      }
      yield();
    }
    return encodedString;
}

#endif //*** CONFIG_FS_H_