/*
  syncwebserver.cpp - ESP3D sync functions class

  Copyright (c) 2014 Luc Lebosse. All rights reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include <pgmspace.h>
#include "config.h"
#if !defined(ASYNCWEBSERVER)

#include "webinterface.h"
#include "wificonf.h"
#include <WiFiClient.h>
#include <WiFiServer.h>
#include <WiFiUdp.h>
#include <StreamString.h>
#ifndef FS_NO_GLOBALS
#define FS_NO_GLOBALS
#endif
#include <FS.h>
#if defined ( ARDUINO_ARCH_ESP8266)
#include "ESP8266WiFi.h"
#include <ESP8266WebServer.h>
#endif
#if defined ( ARDUINO_ARCH_ESP32)
#include <WiFi.h>
#include <WebServer.h>
#include "SPIFFS.h"
#include "Update.h"
#include <esp_ota_ops.h>
#endif

#include "GenLinkedList.h"
#include "command.h"
#include "espcom.h"

#ifdef SSDP_FEATURE
#ifdef ARDUINO_ARCH_ESP32
#include <ESP32SSDP.h>
#else
#include <ESP8266SSDP.h>
#endif
#endif

//embedded response file if no files on SPIFFS
#include "nofile.h"
#include "syncwebserver.h"
WebSocketsServer * socket_server;


#define ESP_ERROR_AUTHENTICATION 1
#define ESP_ERROR_FILE_CREATION  2
#define ESP_ERROR_FILE_WRITE 3
#define ESP_ERROR_UPLOAD 4
#define ESP_ERROR_NOT_ENOUGH_SPACE 5
#define ESP_ERROR_UPLOAD_CANCELLED 6
#define ESP_ERROR_FILE_CLOSE 7
#define ESP_ERROR_NO_SD 8
#define ESP_ERROR_MOUNT_SD 9
#define ESP_ERROR_RESET_NUMBERING 10
#define ESP_ERROR_BUFFER_OVERFLOW 11
#define ESP_ERROR_START_UPLOAD 12


void pushError(int code, const char * st, uint16_t web_error = 500, uint16_t timeout = 1000){
    if (socket_server && st) {
        String s = "ERROR:" + String(code) + ":";
        s+=st;
        socket_server->sendTXT(ESPCOM::current_socket_id, s);
        if (web_error != 0) {
            if (web_interface) {
                if (web_interface->web_server.client().available() > 0) {
                    web_interface->web_server.send (web_error, "text/xml", st);
                }
            }
        }
        uint32_t t = millis();
        while (millis() - t < timeout) {
            socket_server->loop();
            delay(10);
        }
    }
} 

//abort reception of packages
void cancelUpload(){  
    if (web_interface) {
        if (web_interface->web_server.client().available() > 0) {
            HTTPUpload& upload = (web_interface->web_server).upload();
            upload.status = UPLOAD_FILE_ABORTED;
#if defined (ARDUINO_ARCH_ESP8266)
            web_interface->web_server.client().stopAll();
#endif
#if defined (ARDUINO_ARCH_ESP32) 
            errno = ECONNABORTED;
            web_interface->web_server.client().stop();
#endif
            delay(100);
        } 
    }
}

void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length)
{

    switch(type) {
    case WStype_DISCONNECTED:
        //USE_SERIAL.printf("[%u] Disconnected!\n", num);
        break;
    case WStype_CONNECTED: {
        //IPAddress ip = socket_server->remoteIP(num);
        //USE_SERIAL.printf("[%u] Connected from %d.%d.%d.%d url: %s\n", num, ip[0], ip[1], ip[2], ip[3], payload);
        String s = "CURRENT_ID:" + String(num);
        // send message to client
        ESPCOM::current_socket_id = num;
        socket_server->sendTXT(ESPCOM::current_socket_id, s);
        s = "ACTIVE_ID:" + String(ESPCOM::current_socket_id);
        socket_server->broadcastTXT(s);
    }
    break;
    case WStype_TEXT:
        //USE_SERIAL.printf("[%u] get Text: %s\n", num, payload);

        // send message to client
        // webSocket.sendTXT(num, "message here");

        // send data to all connected clients
        // webSocket.broadcastTXT("message here");
        break;
    case WStype_BIN:
        //USE_SERIAL.printf("[%u] get binary length: %u\n", num, length);
        //hexdump(payload, length);

        // send message to client
        // webSocket.sendBIN(num, payload, length);
        break;
    default:
        break;
    }

}


extern bool  deleteRecursive(String path);
extern void CloseSerialUpload (bool iserror, String & filename, int32_t linenb);
extern bool sendLine2Serial (String &  line, int32_t linenb, int32_t* newlinenb);
extern bool purge_serial();

const uint8_t PAGE_404 [] PROGMEM = "<HTML>\n<HEAD>\n<title>Redirecting...</title> \n</HEAD>\n<BODY>\n<CENTER>Unknown page : $QUERY$- you will be redirected...\n<BR><BR>\nif not redirected, <a href='http://$WEB_ADDRESS$'>click here</a>\n<BR><BR>\n<PROGRESS name='prg' id='prg'></PROGRESS>\n\n<script>\nvar i = 0; \nvar x = document.getElementById(\"prg\"); \nx.max=5; \nvar interval=setInterval(function(){\ni=i+1; \nvar x = document.getElementById(\"prg\"); \nx.value=i; \nif (i>5) \n{\nclearInterval(interval);\nwindow.location.href='/';\n}\n},1000);\n</script>\n</CENTER>\n</BODY>\n</HTML>\n\n";
const uint8_t PAGE_CAPTIVE [] PROGMEM = "<HTML>\n<HEAD>\n<title>Captive Portal</title> \n</HEAD>\n<BODY>\n<CENTER>Captive Portal page : $QUERY$- you will be redirected...\n<BR><BR>\nif not redirected, <a href='http://$WEB_ADDRESS$'>click here</a>\n<BR><BR>\n<PROGRESS name='prg' id='prg'></PROGRESS>\n\n<script>\nvar i = 0; \nvar x = document.getElementById(\"prg\"); \nx.max=5; \nvar interval=setInterval(function(){\ni=i+1; \nvar x = document.getElementById(\"prg\"); \nx.value=i; \nif (i>5) \n{\nclearInterval(interval);\nwindow.location.href='/';\n}\n},1000);\n</script>\n</CENTER>\n</BODY>\n</HTML>\n\n";
#define  CONTENT_TYPE_HTML "text/html"

//Root of Webserver/////////////////////////////////////////////////////

void handle_web_interface_root()
{
    String path = "/index.html";
    String contentType =  web_interface->getContentType(path);
    String pathWithGz = path + ".gz";
    //if have a index.html or gzip version this is default root page
    if((SPIFFS.exists(pathWithGz) || SPIFFS.exists(path)) && !web_interface->web_server.hasArg("forcefallback") && web_interface->web_server.arg("forcefallback")!="yes") {
        if(SPIFFS.exists(pathWithGz)) {
            path = pathWithGz;
        }
        FS_FILE file = SPIFFS.open(path, SPIFFS_FILE_READ);
        web_interface->web_server.streamFile(file, contentType);
        file.close();
        return;
    }
    //if no lets launch the default content
    web_interface->web_server.sendHeader("Content-Encoding", "gzip");
    web_interface->web_server.send_P(200,CONTENT_TYPE_HTML,PAGE_NOFILES,PAGE_NOFILES_SIZE);
}

//Login check///////////////////////////////////////////////////////////
void handle_login()
{
#ifdef AUTHENTICATION_FEATURE
    String smsg;
    String sUser,sPassword;
    String auths;
    int code = 200;
    bool msg_alert_error=false;
    //disconnect can be done anytime no need to check credential
    if (web_interface->web_server.hasArg("DISCONNECT")) {
        String cookie = web_interface->web_server.header("Cookie");
        int pos = cookie.indexOf("ESPSESSIONID=");
        String sessionID;
        if (pos!= -1) {
            int pos2 = cookie.indexOf(";",pos);
            sessionID = cookie.substring(pos+strlen("ESPSESSIONID="),pos2);
        }
        web_interface->ClearAuthIP(web_interface->web_server.client().remoteIP(), sessionID.c_str());
        web_interface->web_server.sendHeader("Set-Cookie","ESPSESSIONID=0");
        web_interface->web_server.sendHeader("Cache-Control","no-cache");
        String buffer2send = "{\"status\":\"Ok\",\"authentication_lvl\":\"guest\"}";
        web_interface->web_server.send(code, "application/json", buffer2send);
        return;
    }

    level_authenticate_type auth_level= web_interface->is_authenticated();
    if (auth_level == LEVEL_GUEST) {
        auths = F("guest");
    } else if (auth_level == LEVEL_USER) {
        auths = F("user");
    } else if (auth_level == LEVEL_ADMIN) {
        auths = F("admin");
    } else {
        auths = F("???");
    }

    //check is it is a submission or a query
    if (web_interface->web_server.hasArg("SUBMIT")) {
        //is there a correct list of query?
        if ( web_interface->web_server.hasArg("PASSWORD")&& web_interface->web_server.hasArg("USER")) {
            //USER
            sUser = web_interface->web_server.arg("USER");
            if ( !((sUser==FPSTR(DEFAULT_ADMIN_LOGIN)) || (sUser==FPSTR(DEFAULT_USER_LOGIN)))) {
                msg_alert_error=true;
                smsg=F("Error : Incorrect User");
                code=401;
            }
            if (msg_alert_error == false) {
                //Password
                sPassword = web_interface->web_server.arg("PASSWORD");
                String sadminPassword;

                if (!CONFIG::read_string(EP_ADMIN_PWD, sadminPassword, MAX_LOCAL_PASSWORD_LENGTH)) {
                    sadminPassword=FPSTR(DEFAULT_ADMIN_PWD);
                }

                String suserPassword;

                if (!CONFIG::read_string(EP_USER_PWD, suserPassword, MAX_LOCAL_PASSWORD_LENGTH)) {
                    suserPassword=FPSTR(DEFAULT_USER_PWD);
                }

                if(!(((sUser==FPSTR(DEFAULT_ADMIN_LOGIN)) && (strcmp(sPassword.c_str(),sadminPassword.c_str())==0)) ||
                        ((sUser==FPSTR(DEFAULT_USER_LOGIN)) && (strcmp(sPassword.c_str(),suserPassword.c_str()) == 0)))) {
                    msg_alert_error=true;
                    smsg=F("Error: Incorrect password");
                    Serial.println(sPassword.c_str());
                    Serial.println(sadminPassword.c_str());
                    code = 401;
                }
            }
        } else {
            msg_alert_error=true;
            smsg = F("Error: Missing data");
            code = 500;
        }
        //change password
        if ( web_interface->web_server.hasArg("PASSWORD")&& web_interface->web_server.hasArg("USER") && web_interface->web_server.hasArg("NEWPASSWORD") && (msg_alert_error==false) ) {
            String newpassword =  web_interface->web_server.arg("NEWPASSWORD");
            if (CONFIG::isLocalPasswordValid(newpassword.c_str())) {
                int pos=0;
                if(sUser==FPSTR(DEFAULT_ADMIN_LOGIN)) {
                    pos = EP_ADMIN_PWD;
                } else {
                    pos = EP_USER_PWD;
                }
                if (!CONFIG::write_string(pos,newpassword.c_str())) {
                    msg_alert_error=true;
                    smsg = F("Error: Cannot apply changes");
                    code = 500;
                }
            } else {
                msg_alert_error=true;
                smsg = F("Error: Incorrect password");
                code = 500;
            }
        }
        if ((code == 200) || (code == 500)) {
            level_authenticate_type current_auth_level;
            if(sUser == FPSTR(DEFAULT_ADMIN_LOGIN)) {
                current_auth_level = LEVEL_ADMIN;
            } else  if(sUser == FPSTR(DEFAULT_USER_LOGIN)) {
                current_auth_level = LEVEL_USER;
            } else {
                current_auth_level = LEVEL_GUEST;
            }
            //create Session
            if ((current_auth_level != auth_level) || (auth_level== LEVEL_GUEST)) {
                auth_ip * current_auth = new auth_ip;
                current_auth->level = current_auth_level;
                current_auth->ip=web_interface->web_server.client().remoteIP();
                strcpy(current_auth->sessionID,web_interface->create_session_ID());
                strcpy(current_auth->userID,sUser.c_str());
                current_auth->last_time=millis();
                if (web_interface->AddAuthIP(current_auth)) {
                    String tmps ="ESPSESSIONID=";
                    tmps+=current_auth->sessionID;
                    web_interface->web_server.sendHeader("Set-Cookie",tmps);
                    web_interface->web_server.sendHeader("Cache-Control","no-cache");
                    switch(current_auth->level) {
                    case LEVEL_ADMIN:
                        auths = "admin";
                        break;
                    case LEVEL_USER:
                        auths = "user";
                        break;
                    default:
                        auths = "guest";
                        break;
                    }
                } else {
                    delete current_auth;
                    msg_alert_error=true;
                    code = 500;
                    smsg = F("Error: Too many connections");
                }
            }
        }
        if (code == 200) {
            smsg = F("Ok");
        }

        //build  JSON
        String buffer2send = "{\"status\":\"" + smsg + "\",\"authentication_lvl\":\"";
        buffer2send += auths;
        buffer2send += "\"}";
        web_interface->web_server.send(code, "application/json", buffer2send);
    } else {
        if (auth_level != LEVEL_GUEST) {
            String cookie = web_interface->web_server.header("Cookie");
            int pos = cookie.indexOf("ESPSESSIONID=");
            String sessionID;
            if (pos!= -1) {
                int pos2 = cookie.indexOf(";",pos);
                sessionID = cookie.substring(pos+strlen("ESPSESSIONID="),pos2);
                auth_ip * current_auth_info = web_interface->GetAuth(web_interface->web_server.client().remoteIP(), sessionID.c_str());
                if (current_auth_info != NULL) {
                    sUser = current_auth_info->userID;
                }
            }
        }
        String buffer2send = "{\"status\":\"200\",\"authentication_lvl\":\"";
        buffer2send += auths;
        buffer2send += "\",\"user\":\"";
        buffer2send += sUser;
        buffer2send +="\"}";
        web_interface->web_server.send(code, "application/json", buffer2send);
    }
#else
    web_interface->web_server.sendHeader("Cache-Control","no-cache");
    web_interface->web_server.send(200, "application/json", "{\"status\":\"Ok\",\"authentication_lvl\":\"admin\"}");
#endif
}

//SSDP interface////////////////////////////////////////
#ifdef SSDP_FEATURE
void handle_SSDP()
{
    SSDP.schema(web_interface->web_server.client());
}
#endif

//SPIFFS files list and file commands///////////////////////////////////
void handleFileList()
{
    level_authenticate_type auth_level = web_interface->is_authenticated();
    if (auth_level == LEVEL_GUEST) {
        web_interface->_upload_status=UPLOAD_STATUS_NONE;
        web_interface->web_server.send(401,"text/plain","Authentication failed!\n");
        return;
    }
    String path ;
    String status = "Ok";
    if ((web_interface->_upload_status == UPLOAD_STATUS_FAILED) || (web_interface->_upload_status == UPLOAD_STATUS_FAILED)) {
        status = "Upload failed";
        web_interface->_upload_status=UPLOAD_STATUS_NONE;
    }
    //be sure root is correct according authentication
    if (auth_level == LEVEL_ADMIN) {
        path = "/";
    } else {
        path = "/user";
    }
    //get current path
    if(web_interface->web_server.hasArg("path")) {
        path += web_interface->web_server.arg("path") ;
    }
    //to have a clean path
    path.trim();
    path.replace("//","/");
    if (path[path.length()-1] !='/') {
        path +="/";
    }
    //check if query need some action
    if(web_interface->web_server.hasArg("action")) {
        //delete a file
        if(web_interface->web_server.arg ("action") == "delete" && web_interface->web_server.hasArg ("filename")) {
            String filename;
            String shortname = web_interface->web_server.arg ("filename");
            shortname.replace ("/","");
            filename = path + web_interface->web_server.arg ("filename");
            filename.replace ("//","/");
            if (!SPIFFS.exists (filename)) {
                status = shortname + F(" does not exists!");
            } else {
                if (SPIFFS.remove(filename)) {
                    status = shortname + F(" deleted");
                    //what happen if no "/." and no other subfiles ?
#if defined(ARDUINO_ARCH_ESP8266)
                    FS_DIR dir = SPIFFS.openDir(path);
                    if (!dir.next()) {
#else
                    String ptmp = path;
                    if ( (path != "/") && (path[path.length() - 1] = '/') ) {
                        ptmp = path.substring (0, path.length() - 1);
                    }
                    FS_FILE dir = SPIFFS.open (ptmp);
                    FS_FILE dircontent = dir.openNextFile();
                    if (!dircontent) {
#endif
                        //keep directory alive even empty
                        FS_FILE r = SPIFFS.open (path+"/.", SPIFFS_FILE_WRITE);
                        if (r) {
                            r.close();
                        }
                    }
                } else {
                    status = F("Cannot deleted ") ;
                    status += shortname ;
                }
            }
        }
        //delete a directory
        if(web_interface->web_server.arg("action") == "deletedir" && web_interface->web_server.hasArg("filename")) {
            String filename;
            String shortname = web_interface->web_server.arg("filename");
            shortname.replace("/","");
            filename = path + web_interface->web_server.arg("filename");
            filename += "/";
            filename.replace("//","/");
            if (filename != "/") {
                bool delete_error = false;
#if defined ( ARDUINO_ARCH_ESP8266)
                FS_DIR dir = SPIFFS.openDir(path + shortname);
                {
                    while (dir.next()) {
#else
                FS_FILE dir = SPIFFS.open(path + shortname);
                {
                    FS_FILE file2deleted = dir.openNextFile();
                    while (file2deleted) {
#endif
#if defined ( ARDUINO_ARCH_ESP8266)
                        String fullpath = dir.fileName();
#else
                        String fullpath = file2deleted.name();
#endif
                        if (!SPIFFS.remove(fullpath)) {
                            delete_error = true;
                            status = F("Cannot deleted ") ;
                            status+=fullpath;
                        }
#if defined(ARDUINO_ARCH_ESP32)
                        file2deleted = dir.openNextFile();
#endif
                    }
                }
                if (!delete_error) {
                    status = shortname ;
                    status+=" deleted";
                }
            }
        }
        //create a directory
        if(web_interface->web_server.arg("action")=="createdir" && web_interface->web_server.hasArg("filename")) {
            String filename;
            filename = path + web_interface->web_server.arg("filename") +"/.";
            String shortname = web_interface->web_server.arg("filename");
            shortname.replace("/","");
            filename.replace("//","/");
            if(SPIFFS.exists(filename)) {
                status = shortname + F(" already exists!");
            } else {
                FS_FILE r = SPIFFS.open(filename,SPIFFS_FILE_WRITE);
                if (!r) {
                    status = F("Cannot create ");
                    status += shortname ;
                } else {
                    r.close();
                    status = shortname + F(" created");
                }
            }
        }
    }
    String jsonfile = "{";
#if defined ( ARDUINO_ARCH_ESP8266 )
    FS_DIR dir = SPIFFS.openDir(path);
#else
    String ptmp = path;
    if ( (path != "/") && (path[path.length() - 1] = '/') ) {
        ptmp = path.substring (0, path.length() - 1);
    }
    FS_FILE dir = SPIFFS.open(ptmp);
#endif
    jsonfile+="\"files\":[";
    bool firstentry=true;
    String subdirlist="";
#if defined ( ARDUINO_ARCH_ESP8266 )
    while (dir.next()) {
        String filename = dir.fileName();
#else
    File fileparsed = dir.openNextFile();
    while (fileparsed) {
        String filename = fileparsed.name();
#endif
        String size ="";
        bool addtolist=true;
        //remove path from name
        filename = filename.substring(path.length(),filename.length());
        //check if file or subfile
        if (filename.indexOf("/")>-1) {
            //Do not rely on "/." to define directory as SPIFFS upload won't create it but directly files
            //and no need to overload SPIFFS if not necessary to create "/." if no need
            //it will reduce SPIFFS available space so limit it to creation
            filename = filename.substring(0,filename.indexOf("/"));
            String tag="*";
            tag += filename + "*";
            if (subdirlist.indexOf(tag)>-1 || filename.length()==0) { //already in list
                addtolist = false; //no need to add
            } else {
                size = -1; //it is subfile so display only directory, size will be -1 to describe it is directory
                if (subdirlist.length()==0) {
                    subdirlist+="*";
                }
                subdirlist += filename + "*"; //add to list
            }
        } else {
            //do not add "." file
            if (!((filename==".") || (filename==""))) {
#if defined ( ARDUINO_ARCH_ESP8266)
                size = CONFIG::formatBytes(dir.fileSize());
#else
                size = CONFIG::formatBytes(fileparsed.size());
#endif

            } else {
                addtolist = false;
            }
        }
        if(addtolist) {
            if (!firstentry) {
                jsonfile+=",";
            } else {
                firstentry=false;
            }
            jsonfile+="{";
            jsonfile+="\"name\":\"";
            jsonfile+=filename;
            jsonfile+="\",\"size\":\"";
            jsonfile+=size;
            jsonfile+="\"";
            jsonfile+="}";
        }
#ifdef ARDUINO_ARCH_ESP32
        fileparsed = dir.openNextFile();
#endif
    }
    jsonfile+="],";
    jsonfile+="\"path\":\"" + path + "\",";
    jsonfile+="\"status\":\"" + status + "\",";
    size_t totalBytes;
    size_t usedBytes;
#if defined ( ARDUINO_ARCH_ESP8266)
    fs::FSInfo info;
    SPIFFS.info(info);
    totalBytes = info.totalBytes;
    usedBytes = info.usedBytes;
#else
    totalBytes = SPIFFS.totalBytes();
    usedBytes = SPIFFS.usedBytes();
#endif
    jsonfile+="\"total\":\"" + CONFIG::formatBytes(totalBytes) + "\",";
    jsonfile+="\"used\":\"" + CONFIG::formatBytes(usedBytes) + "\",";
    jsonfile.concat(F("\"occupation\":\""));
    jsonfile+= CONFIG::intTostr(100*usedBytes/totalBytes);
    jsonfile+="\"";
    jsonfile+="}";
    path = "";
    web_interface->web_server.sendHeader("Cache-Control", "no-cache");
    web_interface->web_server.send(200, "application/json", jsonfile);
    web_interface->_upload_status=UPLOAD_STATUS_NONE;
}

//SPIFFS files uploader handle
void SPIFFSFileupload()
{
    static FS_FILE fsUploadFile = (FS_FILE)0;
    static String filename;
    //get authentication status
    level_authenticate_type auth_level= web_interface->is_authenticated();
    //Guest cannot upload
    if (auth_level == LEVEL_GUEST) {
        web_interface->_upload_status=UPLOAD_STATUS_FAILED;
        ESPCOM::println (F ("Upload rejected"), PRINTER_PIPE);
        pushError(ESP_ERROR_AUTHENTICATION, "Upload rejected", 401);
    } else {
        //get current file ID
        HTTPUpload& upload = (web_interface->web_server).upload();
        if ((web_interface->_upload_status != UPLOAD_STATUS_FAILED) || (upload.status == UPLOAD_FILE_START)) {
            //Upload start
            //**************
            if(upload.status == UPLOAD_FILE_START) {
                web_interface->_upload_status= UPLOAD_STATUS_ONGOING;
                String upload_filename = upload.filename;
                String  sizeargname  = upload_filename + "S";
                if (upload_filename[0] != '/') filename = "/" + upload_filename;
                else filename = upload.filename;
                //according User or Admin the root is different as user is isolate to /user when admin has full access
                if(auth_level != LEVEL_ADMIN) {
                    upload_filename = filename;
                    filename = "/user" + upload_filename;
                }
                
                if (SPIFFS.exists (filename) ) {
                    SPIFFS.remove (filename);
                }
                if (fsUploadFile ) {
                    fsUploadFile.close();
                }
                if ((web_interface->web_server).hasArg (sizeargname.c_str()) ) {
                    uint32_t filesize = (web_interface->web_server).arg (sizeargname.c_str()).toInt();
    #if defined ( ARDUINO_ARCH_ESP8266)
                    fs::FSInfo info;
                    SPIFFS.info(info);
                     uint32_t freespace = info.totalBytes- info.usedBytes;
    #endif
    #if defined ( ARDUINO_ARCH_ESP32)
                    uint32_t freespace = SPIFFS.totalBytes() - SPIFFS.usedBytes();
    #endif
                    
                    if (filesize > freespace) {
                        web_interface->_upload_status=UPLOAD_STATUS_FAILED;
                        pushError(ESP_ERROR_NOT_ENOUGH_SPACE, "Upload rejected, not enough space");
                    }
                }
                if (web_interface->_upload_status != UPLOAD_STATUS_FAILED) {
                    //create file
                    fsUploadFile = SPIFFS.open(filename, SPIFFS_FILE_WRITE);
                    //check If creation succeed
                    if (fsUploadFile) {
                        //if yes upload is started
                        web_interface->_upload_status= UPLOAD_STATUS_ONGOING;
                    } else {
                        //if no set cancel flag
                        web_interface->_upload_status=UPLOAD_STATUS_FAILED;
                        ESPCOM::println (F ("Error ESP create"), PRINTER_PIPE);
                        pushError(ESP_ERROR_FILE_CREATION, "File creation failed");
                    }
                }
                //Upload write
                //**************
            } else if(upload.status == UPLOAD_FILE_WRITE) {
                //check if file is available and no error
                if(fsUploadFile && web_interface->_upload_status == UPLOAD_STATUS_ONGOING) {
                    //no error so write post date
                    if (upload.currentSize != fsUploadFile.write(upload.buf, upload.currentSize)){
                        web_interface->_upload_status=UPLOAD_STATUS_FAILED;
                        ESPCOM::println (F ("Error ESP write"), PRINTER_PIPE);
                        pushError(ESP_ERROR_FILE_WRITE, "File write failed");
                        }
                } else {
                    //we have a problem set flag UPLOAD_STATUS_FAILED
                    web_interface->_upload_status=UPLOAD_STATUS_FAILED;
                    ESPCOM::println (F ("Error ESP write"), PRINTER_PIPE);
                }
                //Upload end
                //**************
            } else if(upload.status == UPLOAD_FILE_END) {
                //check if file is still open
                if(fsUploadFile) {
                    //close it
                    fsUploadFile.close();
                    if (web_interface->_upload_status == UPLOAD_STATUS_ONGOING) {
                        web_interface->_upload_status = UPLOAD_STATUS_SUCCESSFUL;
                    }
                } else {
                    //we have a problem set flag UPLOAD_STATUS_FAILED
                    web_interface->_upload_status=UPLOAD_STATUS_FAILED;
                    ESPCOM::println (F ("Error ESP close"), PRINTER_PIPE);
                    pushError(ESP_ERROR_FILE_CLOSE, "File close failed");
                }
                //Upload cancelled
                //**************
            } else {
                    web_interface->_upload_status = UPLOAD_STATUS_FAILED;
                    return;
                    //ESPCOM::println (F ("Error ESP upload"), PRINTER_PIPE);
                    //pushError(ESP_ERROR_UPLOAD, "File upload failed");
            }
        }
    }
    if (web_interface->_upload_status == UPLOAD_STATUS_FAILED) {
        cancelUpload();
        if (SPIFFS.exists (filename) ) {
            SPIFFS.remove (filename);
            }
    }
    CONFIG::wait(0);
}

//FW update using Web interface/////////////////////////////////////////
#ifdef WEB_UPDATE_FEATURE
void WebUpdateUpload()
{
    static size_t last_upload_update;
    static uint32_t maxSketchSpace ;
    //only admin can update FW
    if(web_interface->is_authenticated() != LEVEL_ADMIN) {
        web_interface->_upload_status=UPLOAD_STATUS_FAILED;
        ESPCOM::println (F ("Update failed"), PRINTER_PIPE);
        log_esp3d("Web Update failed");
        pushError(ESP_ERROR_AUTHENTICATION, "Upload rejected",401);
    } else {
        //get current file ID
        HTTPUpload& upload = (web_interface->web_server).upload();
        if ((web_interface->_upload_status != UPLOAD_STATUS_FAILED) || (upload.status == UPLOAD_FILE_START)) {
            //Upload start
            //**************
            if(upload.status == UPLOAD_FILE_START) {
                ESPCOM::println (F ("Update Firmware"), PRINTER_PIPE);
                web_interface->_upload_status= UPLOAD_STATUS_ONGOING;
                String  sizeargname  = upload.filename + "S";
                
    #if defined ( ARDUINO_ARCH_ESP8266)
                WiFiUDP::stopAll();
    #endif
                size_t flashsize = 0;
    #if defined ( ARDUINO_ARCH_ESP8266)
                maxSketchSpace = (ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000;
    #else 
                if (esp_ota_get_running_partition()) {
                    const esp_partition_t* partition = esp_ota_get_next_update_partition(NULL);
                    if (partition) {
                        maxSketchSpace = partition->size;
                    }
                }  
    #endif
                if ((web_interface->web_server).hasArg (sizeargname.c_str()) ) {
                    flashsize = (web_interface->web_server).arg (sizeargname).toInt();
                } else {
                    flashsize = maxSketchSpace;
                }
                if ((flashsize > maxSketchSpace) || (flashsize == 0)) {
                    web_interface->_upload_status=UPLOAD_STATUS_FAILED;
                    pushError(ESP_ERROR_NOT_ENOUGH_SPACE, "Upload rejected");
                }
                if (web_interface->_upload_status != UPLOAD_STATUS_FAILED) {
                    last_upload_update = 0;
                    if(!Update.begin(maxSketchSpace)) { //start with max available size
                        web_interface->_upload_status=UPLOAD_STATUS_FAILED;
                        pushError(ESP_ERROR_NOT_ENOUGH_SPACE, "Upload rejected");
                    } else {
                        if (( CONFIG::GetFirmwareTarget() == REPETIER4DV) || (CONFIG::GetFirmwareTarget() == REPETIER)) ESPCOM::println (F ("Update 0%%"), PRINTER_PIPE);
                        else ESPCOM::println (F ("Update 0%"), PRINTER_PIPE);
                    }
                }
                //Upload write
                //**************
            } else if(upload.status == UPLOAD_FILE_WRITE) {
                //check if no error
                if (web_interface->_upload_status == UPLOAD_STATUS_ONGOING) {
                    //we do not know the total file size yet but we know the available space so let's use it
                    if ( ((100 * upload.totalSize) / maxSketchSpace) !=last_upload_update) {
                        last_upload_update = (100 * upload.totalSize) / maxSketchSpace;
                        String s = "Update ";
                        s+= String(last_upload_update);
                        s+= "%";
                        if (( CONFIG::GetFirmwareTarget() == REPETIER4DV) || (CONFIG::GetFirmwareTarget() == REPETIER)) s+= "%";
                        ESPCOM::println (s.c_str(), PRINTER_PIPE);
                    }
                    if(Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
                        web_interface->_upload_status=UPLOAD_STATUS_FAILED;
                        pushError(ESP_ERROR_FILE_WRITE, "File write failed");
                    }
                }
                //Upload end
                //**************
            } else if(upload.status == UPLOAD_FILE_END) {
                if(Update.end(true)) { //true to set the size to the current progress
                    //Now Reboot
                    if (( CONFIG::GetFirmwareTarget() == REPETIER4DV) || (CONFIG::GetFirmwareTarget() == REPETIER)) ESPCOM::println (F("Update 100%%"), PRINTER_PIPE);
                    else ESPCOM::println (F("Update 100%"), PRINTER_PIPE);
                    web_interface->_upload_status=UPLOAD_STATUS_SUCCESSFUL;
                }
            } else if(upload.status == UPLOAD_FILE_ABORTED) {
                ESPCOM::println (F("Update Failed"), PRINTER_PIPE);
                web_interface->_upload_status=UPLOAD_STATUS_FAILED;
                //pushError(ESP_ERROR_UPLOAD_CANCELLED, "Upload cancelled");
            }
        }
    }
    
    if (web_interface->_upload_status==UPLOAD_STATUS_FAILED) {
        cancelUpload();
        Update.end();
    }
    
    CONFIG::wait(0);
}

void handleUpdate()
{
    level_authenticate_type auth_level = web_interface->is_authenticated();
    if (auth_level != LEVEL_ADMIN) {
        web_interface->_upload_status=UPLOAD_STATUS_NONE;
        web_interface->web_server.send(403,"text/plain","Not allowed, log in first!\n");
        return;
    }
    String jsonfile = "{\"status\":\"" ;
    jsonfile+=CONFIG::intTostr(web_interface->_upload_status);
    jsonfile+="\"}";
    //send status
    web_interface->web_server.sendHeader("Cache-Control", "no-cache");
    web_interface->web_server.send(200, "application/json", jsonfile);
    //if success restart
    if (web_interface->_upload_status==UPLOAD_STATUS_SUCCESSFUL) {
        CONFIG::wait(2000);
        web_interface->restartmodule=true;
    } else {
        web_interface->_upload_status=UPLOAD_STATUS_NONE;
    }
}
#endif

//Handle not registred path on SPIFFS neither SD ///////////////////////
void handle_not_found()
{
    static const char NOT_AUTH_NF [] PROGMEM = "HTTP/1.1 301 OK\r\nLocation: /\r\nCache-Control: no-cache\r\n\r\n";

    if (web_interface->is_authenticated() == LEVEL_GUEST) {
        web_interface->web_server.sendContent_P(NOT_AUTH_NF);
        return;
    }
    bool page_not_found = false;
    String path = web_interface->web_server.urlDecode(web_interface->web_server.uri());
    String contentType =  web_interface->getContentType(path);
    String pathWithGz = path + ".gz";
    log_esp3d("Not found %s, type %s", path.c_str(), contentType.c_str());
    if(SPIFFS.exists(pathWithGz) || SPIFFS.exists(path)) {
        if(SPIFFS.exists(pathWithGz)) {
            path = pathWithGz;
        }
        FS_FILE file = SPIFFS.open(path, SPIFFS_FILE_READ);
        web_interface->web_server.streamFile(file, contentType);
        file.close();
        return;
    } else {
        page_not_found = true;
    }

    if (page_not_found ) {
#ifdef CAPTIVE_PORTAL_FEATURE
        if (WiFi.getMode()!=WIFI_STA ) {
            String contentType=FPSTR(PAGE_CAPTIVE);
            String stmp = WiFi.softAPIP().toString();
            //Web address = ip + port
            String KEY_IP = F("$WEB_ADDRESS$");
            String KEY_QUERY = F("$QUERY$");
            if (wifi_config.iweb_port!=80) {
                stmp+=":";
                stmp+=CONFIG::intTostr(wifi_config.iweb_port);
            }
            contentType.replace(KEY_IP,stmp);
            contentType.replace(KEY_IP,stmp);
            contentType.replace(KEY_QUERY,web_interface->web_server.uri());
            web_interface->web_server.send(200,"text/html",contentType);
            //web_interface->web_server.sendContent_P(NOT_AUTH_NF);
            return;
        }
#endif
        log_esp3d("Page not found");
        path = F("/404.htm");
        contentType =  web_interface->getContentType(path);
        pathWithGz =  path + F(".gz");
        if(SPIFFS.exists(pathWithGz) || SPIFFS.exists(path)) {
            if(SPIFFS.exists(pathWithGz)) {
                path = pathWithGz;
            }
            FS_FILE file = SPIFFS.open(path, SPIFFS_FILE_READ);
            web_interface->web_server.streamFile(file, contentType);
            file.close();

        } else {
            //if not template use default page
            contentType=FPSTR(PAGE_404);
            String stmp;
            if (WiFi.getMode()==WIFI_STA ) {
                stmp=WiFi.localIP().toString();
            } else {
                stmp=WiFi.softAPIP().toString();
            }
            //Web address = ip + port
            String KEY_IP = F("$WEB_ADDRESS$");
            String KEY_QUERY = F("$QUERY$");
            if (wifi_config.iweb_port!=80) {
                stmp+=":";
                stmp+=CONFIG::intTostr(wifi_config.iweb_port);
            }
            contentType.replace(KEY_IP,stmp);
            contentType.replace(KEY_QUERY,web_interface->web_server.uri());
            web_interface->web_server.send(200,"text/html",contentType);
        }
    }
}

//Handle web command query and send answer /////////////////////////////
void handle_web_command()
{
    level_authenticate_type auth_level= web_interface->is_authenticated();
    /*  if (auth_level == LEVEL_GUEST) {
          web_interface->web_server.send(403,"text/plain","Not allowed, log in first!\n");
          return;
      }*/
    String buffer2send = "";
    ESPResponseStream espresponse;
    String cmd = "";
    if (web_interface->web_server.hasArg("plain") || web_interface->web_server.hasArg("commandText")) {
        if (web_interface->web_server.hasArg("plain")) {
            cmd = web_interface->web_server.arg("plain");
        } else {
            cmd = web_interface->web_server.arg("commandText");
        }
        log_esp3d("WebCommand %s",cmd.c_str());
    } else {
        log_esp3d("Invalid arg");
        web_interface->web_server.send(200,"text/plain","Invalid command");
        return;
    }
    //if it is for ESP module [ESPXXX]<parameter>
    cmd.trim();
    int ESPpos = cmd.indexOf("[ESP");
    if (ESPpos==0) {
        //is there the second part?
        int ESPpos2 = cmd.indexOf("]",ESPpos);
        if (ESPpos2>-1) {
            //Split in command and parameters
            String cmd_part1=cmd.substring(ESPpos+4,ESPpos2);
            String cmd_part2="";
            //only [ESP800] is allowed login free if authentication is enabled
            if ((auth_level == LEVEL_GUEST)  && (cmd_part1.toInt()!=800)) {
                web_interface->web_server.send(401,"text/plain","Authentication failed!\n");
                return;
            }
            //is there space for parameters?
            if ((uint)ESPpos2<cmd.length()) {
                cmd_part2=cmd.substring(ESPpos2+1);
            }
            //if command is a valid number then execute command
            if(cmd_part1.toInt()!=0) {
                COMMAND::execute_command(cmd_part1.toInt(), cmd_part2, WEB_PIPE, auth_level, &espresponse);
                ESPCOM::flush(WEB_PIPE, &espresponse);
            }
            //if not is not a valid [ESPXXX] command
        }
    } else {
        if (auth_level == LEVEL_GUEST) {
            web_interface->web_server.send(401,"text/plain","Authentication failed!\n");
            return;
        }
        //send command to serial as no need to transfer ESP command
        //to avoid any pollution if Uploading file to SDCard
        if ((web_interface->blockserial) == false) {
            //block every query
            web_interface->blockserial = true;
            log_esp3d("Block Serial");
            //empty the serial buffer and incoming data
            log_esp3d("Start PurgeSerial");
            if(ESPCOM::available(DEFAULT_PRINTER_PIPE)) {
                ESPCOM::bridge();
                CONFIG::wait(1);
            }
            log_esp3d("End PurgeSerial");
            web_interface->web_server.setContentLength(CONTENT_LENGTH_UNKNOWN);
            web_interface->web_server.sendHeader("Content-Type","text/plain",true);
            web_interface->web_server.sendHeader("Cache-Control","no-cache");
            web_interface->web_server.send(200);
            //send command
            log_esp3d("Start PurgeSerial");
            if(ESPCOM::available(DEFAULT_PRINTER_PIPE)) {
                ESPCOM::bridge();
                CONFIG::wait(1);
            }
            log_esp3d("End PurgeSerial");
            ESPCOM::println (cmd, DEFAULT_PRINTER_PIPE);
            bool done = false;
            String current_buffer;
            String current_line;
            //int pos;
            int temp_counter = 0;
            String tmp;
            bool datasent = false;
            uint32_t timeout = millis();
            //pickup the list
            while ((millis() - timeout < 2000) && !done) {
                //give some time between each buffer
                if (ESPCOM::available(DEFAULT_PRINTER_PIPE)) {
                    log_esp3d("Got data");
                    timeout = millis();
                    size_t len = ESPCOM::available(DEFAULT_PRINTER_PIPE);
                    uint8_t sbuf[len+1];
                    //read buffer
                    ESPCOM::readBytes (DEFAULT_PRINTER_PIPE, sbuf, len);
                    //change buffer as string
                    sbuf[len]='\0';
                    //add buffer to current one if any
                    current_buffer += (char * ) sbuf;
                    while (current_buffer.indexOf("\n") !=-1) {
                        log_esp3d("Remove new line");
                        //remove the possible "\r"
                        current_buffer.replace("\r","");
                        //get line
                        current_line = current_buffer.substring(0,current_buffer.indexOf("\n"));
                        //if line is command ack - just exit so save the time out period
                        if ((current_line == "ok") || (current_line == "wait") || (current_line.startsWith("ok") && !((CONFIG::GetFirmwareTarget() == REPETIER) || (CONFIG::GetFirmwareTarget() == REPETIER4DV)))) {
                            done = true;
                            buffer2send +=current_line;
                            log_esp3d("Found ok/wait add New buffer %s", buffer2send.c_str());
                            buffer2send +="\n";
                            break;
                        }
                        //get the line and transmit it
                        //check command
                        if ((CONFIG::GetFirmwareTarget() == REPETIER) || (CONFIG::GetFirmwareTarget() == REPETIER4DV)) {
                            //save time no need to continue
                            if (current_line.indexOf("busy:") > -1) {
                                temp_counter++;
                            } else if (COMMAND::check_command(current_line, NO_PIPE, false)) {
                                temp_counter ++ ;
                            }
                        } else {
                            if (COMMAND::check_command(current_line, NO_PIPE, false)) {
                                temp_counter ++ ;
                            }
                        }
                        if (temp_counter > 5) {
                            log_esp3d("Timeout X5");
                            done = true;
                            break;
                        }
                        if ((CONFIG::GetFirmwareTarget()  == REPETIER) || (CONFIG::GetFirmwareTarget() == REPETIER4DV)) {
                            if (!current_line.startsWith( "ok ")) {
                                buffer2send +=current_line;
                                buffer2send +="\n";
                            }
                        } else {
                            buffer2send +=current_line;
                            log_esp3d("New buffer %s", buffer2send.c_str());
                            buffer2send +="\n";
                        }
                        if (buffer2send.length() > 1200) {
                            web_interface->web_server.sendContent(buffer2send);
                           log_esp3d("Sending %s", buffer2send.c_str());
                            buffer2send = "";
                            datasent = true;
                        }
                        //current remove line from buffer
                        tmp = current_buffer.substring(current_buffer.indexOf("\n")+1,current_buffer.length());
                        current_buffer = tmp;
                        CONFIG::wait (0);
                    }
                    CONFIG::wait (0);
                } else {
                    CONFIG::wait(1);
                }
                //it is sending too many temp status should be heating so let's exit the loop
                if (temp_counter > 5) {
                    done = true;
                }
            }
            log_esp3d("Finished");
            //to be sure connection close
            if (buffer2send.length() > 0) {
                web_interface->web_server.sendContent(buffer2send);
                log_esp3d("Sending %s", buffer2send.c_str());
                datasent = true;
            }
            if (!datasent) {
                web_interface->web_server.sendContent(" \r\n");
            }
            web_interface->web_server.sendContent("");
            log_esp3d("Start PurgeSerial");
            if(ESPCOM::available(DEFAULT_PRINTER_PIPE)) {
                ESPCOM::bridge();
                CONFIG::wait(1);
            }
            log_esp3d("End PurgeSerial");
            web_interface->blockserial = false;
            log_esp3d("Release PurgeSerial");
        } else {
            web_interface->web_server.send(200,"text/plain","Serial is busy, retry later!");
        }
    }
}

//Handle web command query and sent ack or fail instead of answer //////
void handle_web_command_silent()
{
    level_authenticate_type auth_level= web_interface->is_authenticated();
    if (auth_level == LEVEL_GUEST) {
        web_interface->web_server.send(401,"text/plain","Authentication failed!\n");
        return;
    }
    String buffer2send = "";
    String cmd = "";
    //int count ;
    if (web_interface->web_server.hasArg("plain") || web_interface->web_server.hasArg("commandText")) {
        if (web_interface->web_server.hasArg("plain")) {
            cmd = web_interface->web_server.arg("plain");
        } else {
            cmd = web_interface->web_server.arg("commandText");
        }
        log_esp3d("Web Command:%s", cmd.c_str());
    } else {
        log_esp3d("Invalid argument");
        web_interface->web_server.send(200,"text/plain","Invalid command");
        return;
    }
    //if it is for ESP module [ESPXXX]<parameter>
    cmd.trim();
    int ESPpos = cmd.indexOf("[ESP");
    if (ESPpos==0) {
        //is there the second part?
        int ESPpos2 = cmd.indexOf("]",ESPpos);
        if (ESPpos2>-1) {
            //Split in command and parameters
            String cmd_part1=cmd.substring(ESPpos+4,ESPpos2);
            String cmd_part2="";
            //is there space for parameters?
            if ((uint)ESPpos2<cmd.length()) {
                cmd_part2=cmd.substring(ESPpos2+1);
            }
            //if command is a valid number then execute command
            if(cmd_part1.toInt()!=0) {
                if (COMMAND::execute_command(cmd_part1.toInt(),cmd_part2,NO_PIPE, auth_level)) {
                    web_interface->web_server.send(200,"text/plain","ok");
                } else {
                    web_interface->web_server.send(500,"text/plain","error");
                }

            }
            //if not is not a valid [ESPXXX] command
        }
    } else {
        //send command to serial as no need to transfer ESP command
        //to avoid any pollution if Uploading file to SDCard
        if ((web_interface->blockserial) == false) {
            //send command
            ESPCOM::println (cmd, DEFAULT_PRINTER_PIPE);
            web_interface->web_server.send(200,"text/plain","ok");
        } else {
            web_interface->web_server.send(200,"text/plain","Serial is busy, retry later!");
        }
    }

}


//Serial SD files list//////////////////////////////////////////////////
void handle_serial_SDFileList()
{
#ifndef USE_AS_UPDATER_ONLY
    //this is only for admin an user
    if (web_interface->is_authenticated() == LEVEL_GUEST) {
        web_interface->_upload_status=UPLOAD_STATUS_NONE;
        web_interface->web_server.sendHeader("Cache-Control", "no-cache");
        web_interface->web_server.send(401, "application/json", "{\"status\":\"Authentication failed!\"}");
        return;
    }
    
    log_esp3d("Serial SD upload done");
    String sstatus="Ok";
    if ((web_interface->_upload_status == UPLOAD_STATUS_FAILED) || (web_interface->_upload_status == UPLOAD_STATUS_FAILED)) {
        sstatus = "Upload failed";
        web_interface->_upload_status = UPLOAD_STATUS_NONE;
    }
    String jsonfile = "{\"status\":\"" + sstatus + "\"}";
    web_interface->web_server.sendHeader("Cache-Control", "no-cache");
    web_interface->web_server.send(200, "application/json", jsonfile);
    web_interface->blockserial = false;
    web_interface->_upload_status=UPLOAD_STATUS_NONE;
#endif //USE_AS_UPDATER_ONLY
}

#define NB_RETRY 5
#define MAX_RESEND_BUFFER 228
#define SERIAL_CHECK_TIMEOUT 2000
//SD file upload by serial
void SDFile_serial_upload()
{
#ifndef USE_AS_UPDATER_ONLY
    static int32_t lineNb =-1;
    static String current_line;
    static bool is_comment = false;
    static String current_filename;
    String response;
    //Guest cannot upload - only admin and user
    if(web_interface->is_authenticated() == LEVEL_GUEST) {
        web_interface->_upload_status=UPLOAD_STATUS_FAILED;
        ESPCOM::println (F ("SD upload rejected"), PRINTER_PIPE);
        pushError(ESP_ERROR_AUTHENTICATION, "Upload rejected", 401);
        log_esp3d("SD upload rejected");
    } else {
        //retrieve current file id
        HTTPUpload& upload = (web_interface->web_server).upload();
        if((web_interface->_upload_status != UPLOAD_STATUS_FAILED) || (upload.status == UPLOAD_FILE_START)) {
            //Upload start
            //**************
            if(upload.status == UPLOAD_FILE_START) {
                web_interface->_upload_status= UPLOAD_STATUS_ONGOING;
                log_esp3d("Upload start");
                String command = "M29";
                String resetcmd = "M110 N0";
                if (CONFIG::GetFirmwareTarget() == SMOOTHIEWARE)resetcmd = "N0 M110";
                lineNb=1;
                //close any ongoing upload and get current line number
                if(!sendLine2Serial (command,-1, &lineNb)){
                    //it can failed for repetier
                    if ( ( CONFIG::GetFirmwareTarget() == REPETIER4DV) || (CONFIG::GetFirmwareTarget() == REPETIER) ) {
                        if(!sendLine2Serial (command,1, NULL)){
                            log_esp3d("Upload start failed");
                            web_interface->_upload_status= UPLOAD_STATUS_FAILED;
                            pushError(ESP_ERROR_START_UPLOAD, "Upload rejected");
                        }
                    } else {
                        log_esp3d("Upload start failed");
                        web_interface->_upload_status= UPLOAD_STATUS_FAILED;
                        pushError(ESP_ERROR_START_UPLOAD, "Upload rejected");
                    }
                } else {
                    //Mount SD card
                    command = "M21";
                    if(!sendLine2Serial (command,-1, NULL)){
                        log_esp3d("Mounting SD failed");
                        web_interface->_upload_status= UPLOAD_STATUS_FAILED;
                        pushError(ESP_ERROR_MOUNT_SD, "Mounting SD failed");
                    }
                    if (web_interface->_upload_status != UPLOAD_STATUS_FAILED) {
                        //Reset line numbering
                        if(!sendLine2Serial (resetcmd,-1, NULL)){
                            log_esp3d("Reset Numbering failed");
                            web_interface->_upload_status= UPLOAD_STATUS_FAILED;
                            pushError(ESP_ERROR_RESET_NUMBERING, "Reset Numbering failed");
                        }
                    }
                    if (web_interface->_upload_status != UPLOAD_STATUS_FAILED) {
                        lineNb=1;
                        //need to lock serial out to avoid garbage in file
                        (web_interface->blockserial) = true;
                        current_line ="";
                        current_filename = upload.filename;
                        is_comment = false;
                        String response;
                        ESPCOM::println (F ("Uploading..."), PRINTER_PIPE);
                        //Clear all serial
                        ESPCOM::flush (DEFAULT_PRINTER_PIPE);
                        purge_serial();
                        //besure nothing left again
                        purge_serial();
                        command = "M28 " + upload.filename;
                        //send start upload
                        //no correction allowed because it means reset numbering was failed
                        if (sendLine2Serial(command, lineNb, NULL)){
                            CONFIG::wait(1200);
                            //additional purge, in case it is slow to answer
                            purge_serial();
                            web_interface->_upload_status= UPLOAD_STATUS_ONGOING;
                            log_esp3d("Creation Ok");
                            
                        } else  {
                            web_interface->_upload_status= UPLOAD_STATUS_FAILED;
                            log_esp3d("Creation failed");
                            pushError(ESP_ERROR_FILE_CREATION, "File creation failed");
                        }
                    }
                }
                //Upload write
                //**************
                //upload is on going with data coming by 2K blocks
            } else if(upload.status == UPLOAD_FILE_WRITE) { //if com error no need to send more data to serial
                for (uint pos = 0;( pos < upload.currentSize) && (web_interface->_upload_status == UPLOAD_STATUS_ONGOING); pos++) { //parse full post data
                    //feed watchdog
                    CONFIG::wait(0);
                    //it is a comment
                    if (upload.buf[pos] == ';') {
                        log_esp3d("Comment found");
                        is_comment = true;
                    }
                    //it is an end line
                    else  if ( (upload.buf[pos] == 13) || (upload.buf[pos] == 10) ) {
                        //if comment line then reset
                        is_comment = false;
                        //does line fit the buffer ?
                        if (current_line.length() < MAX_RESEND_BUFFER) {
                            //do we have something in buffer ?
                            if (current_line.length() > 0 ) {
                                lineNb++;
                                if (!sendLine2Serial (current_line, lineNb, NULL) ) {
                                    log_esp3d("Error sending line");
                                    CloseSerialUpload (true, current_filename,lineNb);
                                    web_interface->_upload_status= UPLOAD_STATUS_FAILED;
                                    pushError(ESP_ERROR_FILE_WRITE, "File write failed");
                                }
                                //reset line
                                current_line = "";

                            } else {
                                log_esp3d ("Empy line");
                            }
                        } else {
                            //error buffer overload
                            log_esp3d ("Error over buffer(1)");
                            lineNb++;
                            web_interface->_upload_status= UPLOAD_STATUS_FAILED;
                            pushError(ESP_ERROR_BUFFER_OVERFLOW, "Error buffer overflow");
                        }
                    } else if (!is_comment) {
                        if (current_line.length() < MAX_RESEND_BUFFER) {
                            current_line += char (upload.buf[pos]);  //copy current char to buffer to send/resend
                        } else {
                            log_esp3d ("Error over buffer(2)");
                            lineNb++;
                            web_interface->_upload_status= UPLOAD_STATUS_FAILED;
                            pushError(ESP_ERROR_BUFFER_OVERFLOW, "Error buffer overflow");
                        }
                    }
                }
                //Upload end
                //**************
            } else if(upload.status == UPLOAD_FILE_END && web_interface->_upload_status == UPLOAD_STATUS_ONGOING) {
                //if last part does not have '\n'
                if (current_line.length()  > 0) {
                    lineNb++;
                    if (!sendLine2Serial (current_line, lineNb, NULL) ) {
                        log_esp3d ("Error sending buffer");
                        lineNb++;
                        CloseSerialUpload (true, current_filename, lineNb);
                        web_interface->_upload_status= UPLOAD_STATUS_FAILED;
                        pushError(ESP_ERROR_FILE_WRITE, "File write failed");
                    }
                }
                log_esp3d ("Upload finished");
                lineNb++;
                CloseSerialUpload (false, current_filename, lineNb);
                //Upload cancelled
                //**************
            } else { //UPLOAD_FILE_ABORTED
                log_esp3d("Error, Something happened");
                web_interface->_upload_status= UPLOAD_STATUS_FAILED;
                //pushError(ESP_ERROR_UPLOAD_CANCELLED, "Upload cancelled");
            }
        }
    }
    
    if (web_interface->_upload_status == UPLOAD_STATUS_FAILED) {
        ESPCOM::println (F ("Upload failed"), PRINTER_PIPE);
        lineNb++;
        CloseSerialUpload (true, current_filename, lineNb);
        cancelUpload();
    }
#endif //USE_AS_UPDATER_ONLY
}

#endif