/**
 *
 * (c) Copyright Ascensio System SIA 2025
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

// connect the necessary packages and modules
const express = require('express');
const path = require('path');
const favicon = require('serve-favicon');
const bodyParser = require('body-parser');
const fileSystem = require('fs');
const formidable = require('formidable');
const jwt = require('jsonwebtoken');
const config = require('config');
const mime = require('mime');
const urllib = require('urllib');
const urlModule = require('url');
const { emitWarning } = require('process');
const DocManager = require('./helpers/docManager');
const documentService = require('./helpers/documentService');
const fileUtility = require('./helpers/fileUtility');
const wopiApp = require('./helpers/wopi/wopiRouting');
const users = require('./helpers/users');

const configServer = config.get('server');
const siteUrl = configServer.get('siteUrl');
const enableForgotten = configServer.get('enableForgotten');
const fileChoiceUrl = configServer.has('fileChoiceUrl') ? configServer.get('fileChoiceUrl') : '';
const cfgSignatureEnable = configServer.get('token.enable');
const cfgSignatureUseForRequest = configServer.get('token.useforrequest');
const cfgSignatureAuthorizationHeader = configServer.get('token.authorizationHeader');
const cfgSignatureAuthorizationHeaderPrefix = configServer.get('token.authorizationHeaderPrefix');
const cfgSignatureSecretExpiresIn = configServer.get('token.expiresIn');
const cfgSignatureSecret = configServer.get('token.secret');
const verifyPeerOff = configServer.get('verify_peer_off');
const plugins = config.get('plugins');

if (verifyPeerOff) {
  process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
}

String.prototype.hashCode = function hashCode() {
  const len = this.length;
  let ret = 0;
  for (let i = 0; i < len; i++) {
    ret = Math.imul(ret, 31) + this.charCodeAt(i);
  }
  return ret;
};
String.prototype.format = function format(...args) {
  let text = this.toString();

  if (!args.length) return text;

  for (let i = 0; i < args.length; i++) {
    text = text.replace(new RegExp(`\\{${i}\\}`, 'gi'), args[i]);
  }

  return text;
};

const app = express(); // create an application object
app.disable('x-powered-by');
app.set('views', path.join(__dirname, 'views')); // specify the path to the main template
app.set('view engine', 'ejs'); // specify which template engine is used

app.use((req, res, next) => {
  res.setHeader('Access-Control-Allow-Origin', '*'); // allow any Internet domain to access the resources of this site
  next();
});

app.use(express.static(path.join(__dirname, 'public'))); // public directory
app.use(favicon(`${__dirname}/public/images/favicon.ico`)); // use favicon

app.use(bodyParser.json()); // connect middleware that parses json
app.use(bodyParser.urlencoded({ extended: false })); // connect middleware that parses urlencoded bodies

app.get('/', (req, res) => { // define a handler for default page
  try {
    req.DocManager = new DocManager(req, res);

    res.render('index', { // render index template with the parameters specified
      preloaderUrl: siteUrl + configServer.get('preloaderUrl'),
      fillExts: fileUtility.getFillExtensions(),
      storedFiles: req.DocManager.getStoredFiles(),
      params: req.DocManager.getCustomParams(),
      users,
      languages: configServer.get('languages'),
      serverVersion: config.get('version'),
      enableForgotten,
    });
  } catch (ex) {
    console.log(ex); // display error message in the console
    res.status(500); // write status parameter to the response
    res.render('error', { message: 'Server error' }); // render error template with the message parameter specified
  }
});

app.get('/forgotten', async (req, res) => {
  if (!enableForgotten) {
    res.status(403);
    res.render(
      'error',
      { message: 'The forgotten page is disabled.' },
    );
    return;
  }

  let forgottenFiles = [];

  function getForgottenList() {
    return new Promise((resolve, reject) => {
      documentService.commandRequest('getForgottenList', '', (err, data, ress) => {
        if (err) {
          reject(err);
        } else {
          resolve(JSON.parse(ress.data));
        }
      });
    });
  }

  function getForgottenFile(key) {
    return new Promise((resolve, reject) => {
      documentService.commandRequest('getForgotten', key, (err, data) => {
        if (err) {
          reject(err);
        } else {
          const parsedData = JSON.parse(data);
          resolve({
            name: parsedData.key,
            documentType: fileUtility.getFileType(parsedData.url),
            url: parsedData.url,
          });
        }
      });
    });
  }

  try {
    const forgottenListResponse = await getForgottenList();

    const { keys } = forgottenListResponse;
    forgottenFiles = await Promise.all(keys.map(getForgottenFile));
  } catch (error) {
    console.error(error);
  }

  req.DocManager = new DocManager(req, res);
  res.render('forgotten', { forgottenFiles });
});

app.delete('/forgotten', (req, res) => { // define a handler for removing forgotten file
  if (!enableForgotten) {
    res.sendStatus(403);
    return;
  }

  try {
    const fileName = req.query.filename;
    if (fileName && typeof fileName === 'string') { // if the forgotten file name is defined
      documentService.commandRequest('deleteForgotten', fileName);
      res.status(204).send();
    }
  } catch (ex) {
    console.log(ex);
    res.write('Server error');
    res.status(500).send();
  }
});

app.get('/download', (req, res) => { // define a handler for downloading files
  req.DocManager = new DocManager(req, res);

  const fileName = fileUtility.getFileName(req.query.fileName);
  const userAddress = req.query.useraddress;
  let token = '';

  if (!!userAddress
        && cfgSignatureEnable && cfgSignatureUseForRequest) {
    const authorization = req.get(cfgSignatureAuthorizationHeader);
    if (authorization && authorization.startsWith(cfgSignatureAuthorizationHeaderPrefix)) {
      token = authorization.substring(cfgSignatureAuthorizationHeaderPrefix.length);
    }

    try {
      jwt.verify(token, cfgSignatureSecret);
    } catch (err) {
      console.log(`checkJwtHeader error: name = ${err.name} message = ${err.message} token = ${token}`);
      res.sendStatus(403);
      return;
    }
  }

  // get the path to the force saved document version
  let filePath = req.DocManager.forcesavePath(fileName, userAddress, false);
  if (filePath === '') {
    filePath = req.DocManager.storagePath(fileName, userAddress); // or to the original document
  }

  // add headers to the response to specify the page parameters
  res.setHeader('Content-Length', fileSystem.statSync(filePath).size);
  res.setHeader('Content-Type', mime.getType(filePath));

  res.setHeader('Content-Disposition', `attachment; filename*=UTF-8''${encodeURIComponent(fileName)}`);

  const filestream = fileSystem.createReadStream(filePath);
  filestream.pipe(res); // send file information to the response by streams
});

app.get('/history', (req, res) => {
  req.DocManager = new DocManager(req, res);
  if (cfgSignatureEnable && cfgSignatureUseForRequest) {
    const authorization = req.get(cfgSignatureAuthorizationHeader);
    if (authorization && authorization.startsWith(cfgSignatureAuthorizationHeaderPrefix)) {
      const token = authorization.substring(cfgSignatureAuthorizationHeaderPrefix.length);
      try {
        jwt.verify(token, cfgSignatureSecret);
      } catch (err) {
        console.log(`checkJwtHeader error: name = ${err.name} message = ${err.message} token = ${token}`);
        res.sendStatus(403);
        return;
      }
    } else {
      res.sendStatus(403);
      return;
    }
  }

  const { fileName } = req.query;
  const userAddress = req.query.useraddress;
  const { ver } = req.query;
  const { file } = req.query;
  let Path = '';

  if (file.includes('diff')) {
    Path = req.DocManager.diffPath(fileName, userAddress, ver);
  } else if (file.includes('prev')) {
    Path = req.DocManager.prevFilePath(fileName, userAddress, ver);
  } else {
    res.sendStatus(403);
    return;
  }

  // add headers to the response to specify the page parameters
  res.setHeader('Content-Length', fileSystem.statSync(Path).size);
  res.setHeader('Content-Type', mime.getType(Path));
  res.setHeader('Content-Disposition', `attachment; filename*=UTF-8''${encodeURIComponent(file)}`);

  const filestream = fileSystem.createReadStream(Path);
  filestream.pipe(res); // send file information to the response by streams
});

app.post('/upload', (req, res) => { // define a handler for uploading files
  req.DocManager = new DocManager(req, res);
  req.DocManager.storagePath(''); // mkdir if not exist

  const userIp = req.DocManager.curUserHostAddress(); // get the path to the user host
  const uploadDir = req.DocManager.storageRootPath(userIp);
  const uploadDirTmp = path.join(uploadDir, 'tmp'); // and create directory for temporary files if it doesn't exist
  req.DocManager.createDirectory(uploadDirTmp);

  const fileSizeLimit = configServer.get('maxFileSize');
  // create a new incoming form
  const form = new formidable.IncomingForm({ maxFileSize: fileSizeLimit, maxTotalFileSize: fileSizeLimit });
  form.uploadDir = uploadDirTmp; // and write there all the necessary parameters
  form.keepExtensions = true;

  form.parse(req, (err, fields, files) => { // parse this form
    if (err) { // if an error occurs
      // DocManager.cleanFolderRecursive(uploadDirTmp, true);  // clean the folder with temporary files
      res.writeHead(200, { 'Content-Type': 'text/plain' }); // and write the error status and message to the response
      res.write(`{ "error": "${err.message}"}`);
      res.end();
      return;
    }

    const file = files.uploadedFile[0];

    if (file === undefined) { // if file parameter is undefined
      res.writeHead(200, { 'Content-Type': 'text/plain' }); // write the error status and message to the response
      res.write('{ "error": "Uploaded file not found"}');
      res.end();
      return;
    }

    file.originalFilename = req.DocManager.getCorrectName(file.originalFilename);

    // check if the file size exceeds the maximum file size
    if (fileSizeLimit < file.size || file.size <= 0) {
      // DocManager.cleanFolderRecursive(uploadDirTmp, true);  // clean the folder with temporary files
      res.writeHead(200, { 'Content-Type': 'text/plain' });
      res.write('{ "error": "File size is incorrect"}');
      res.end();
      return;
    }

    const exts = fileUtility.getSuppotredExtensions(); // all the supported file extensions
    const curExt = fileUtility.getFileExtension(file.originalFilename, true);
    const documentType = fileUtility.getFileType(file.originalFilename);

    if (exts.indexOf(curExt) === -1 || fileUtility.getFormatActions(curExt).length === 0) {
      // DocManager.cleanFolderRecursive(uploadDirTmp, true);  // if not, clean the folder with temporary files
      res.writeHead(200, { 'Content-Type': 'text/plain' }); // and write the error status and message to the response
      res.write('{ "error": "File type is not supported"}');
      res.end();
      return;
    }

    fileSystem.rename(file.filepath, `${uploadDir}/${file.originalFilename}`, (error) => { // rename a file
      // DocManager.cleanFolderRecursive(uploadDirTmp, true);  // clean the folder with temporary files
      res.writeHead(200, { 'Content-Type': 'text/plain' });
      if (error) { // if an error occurs
        res.write(`{ "error": "${error}"}`); // write an error message to the response
      } else {
        // otherwise, write a new file name to the response
        res.write(`{ "filename": "${file.originalFilename}", "documentType": "${documentType}" }`);

        // get user id and name parameters or set them to the default values
        const user = users.getUser(req.query.userid);

        req.DocManager.saveFileData(file.originalFilename, user.id, user.name);
      }
      res.end();
    });
  });
});

app.post('/create', (req, res) => {
  const { title } = req.body;
  const fileUrl = req.body.url;

  try {
    req.DocManager = new DocManager(req, res);

    let host = siteUrl;
    if (host.indexOf('/') === 0) {
      host = req.DocManager.getServerHost();
    }
    if (urlModule.parse(fileUrl).host !== urlModule.parse(host).host) {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.write(JSON.stringify({ error: 'File domain is incorrect' }));
      res.end();
      return;
    }

    req.DocManager.storagePath(''); // mkdir if not exist

    const fileName = req.DocManager.getCorrectName(title);
    const userAddress = req.DocManager.curUserHostAddress();
    req.DocManager.historyPath(fileName, userAddress, true);

    urllib.request(fileUrl, { method: 'GET' }, (err, data) => {
      // check if the file size exceeds the maximum file size
      if (configServer.get('maxFileSize') < data.length || data.length <= 0) {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.write(JSON.stringify({ error: 'File size is incorrect' }));
        res.end();
        return;
      }

      const exts = fileUtility.getSuppotredExtensions(); // all the supported file extensions
      const curExt = fileUtility.getFileExtension(fileName, true);

      if (exts.indexOf(curExt) === -1 || fileUtility.getFormatActions(curExt).length === 0) {
        // and write the error status and message to the response
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.write(JSON.stringify({ error: 'File type is not supported' }));
        res.end();
        return;
      }

      fileSystem.writeFileSync(req.DocManager.storagePath(fileName), data);

      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.write(JSON.stringify({ file: fileName }));
      res.end();
    });
  } catch (e) {
    res.status(500);
    res.write(JSON.stringify({
      error: 1,
      message: e.message,
    }));
    res.end();
  }
});

app.post('/convert', (req, res) => { // define a handler for converting files
  req.DocManager = new DocManager(req, res);

  const fileName = fileUtility.getFileName(req.body.filename);
  const filePass = req.body.filePass ? req.body.filePass : null;
  const lang = req.body.lang ? req.body.lang : null;
  const fileUri = req.DocManager.getDownloadUrl(fileName, true);
  const fileExt = fileUtility.getFileExtension(fileName, true);
  const internalFileExt = 'ooxml';
  const convExt = req.body.fileExt ? req.body.fileExt : internalFileExt;
  const { keepOriginal } = req.body;
  const response = res;

  const writeResult = function writeResult(filename, step, error) {
    const result = {};

    // write file name, step and error values to the result object if they are defined
    if (filename !== null) result.filename = filename;

    if (step !== null) result.step = step;

    if (error !== null) result.error = error;

    response.setHeader('Content-Type', 'application/json');
    response.write(JSON.stringify(result));
    response.end();
  };

  const callback = async function callback(err, resp) {
    if (err) { // if an error occurs
      // check what type of error it is
      if (err.name === 'ConnectionTimeoutError' || err.name === 'ResponseTimeoutError') {
        writeResult(fileName, 0, null); // despite the timeout errors, write the file to the result object
      } else {
        writeResult(null, null, JSON.stringify(err)); // other errors trigger an error message
      }
      return;
    }

    try {
      const responseData = documentService.getResponseUri(resp.toString());
      const result = responseData.percent;
      const newFileUri = responseData.uri; // get the callback url
      const newFileType = `.${responseData.fileType}`; // get the file type

      if (result !== 100) { // if the status isn't 100
        writeResult(fileName, result, null); // write the origin file to the result object
        return;
      }

      // get the file name with a new extension
      const correctName = req.DocManager.getCorrectName(fileUtility.getFileName(fileName, true) + newFileType);

      const { status, data } = await urllib.request(newFileUri, { method: 'GET' });

      if (status !== 200) throw new Error(`Conversion service returned status: ${status}`);

      // write a file with a new extension, but with the content from the origin file
      if (fileUtility.getFileType(correctName) !== null) {
        fileSystem.writeFileSync(req.DocManager.storagePath(correctName), data);
      } else {
        writeResult(newFileUri.replace('http://localhost/', siteUrl), result, 'FileTypeIsNotSupported');
        return;
      }
      // remove file with the origin extension
      if (!keepOriginal) fileSystem.unlinkSync(req.DocManager.storagePath(fileName));

      const userAddress = req.DocManager.curUserHostAddress();
      const historyPath = req.DocManager.historyPath(fileName, userAddress, true);
      // get the history path to the file with a new extension
      const correctHistoryPath = req.DocManager.historyPath(correctName, userAddress, true);

      if (!keepOriginal) {
        fileSystem.renameSync(historyPath, correctHistoryPath); // change the previous history path

        fileSystem.renameSync(
          path.join(correctHistoryPath, `${fileName}.txt`),
          path.join(correctHistoryPath, `${correctName}.txt`),
        ); // change the name of the .txt file with document information
      } else if (newFileType !== null) {
        const user = users.getUser(req.query.userid);

        req.DocManager.saveFileData(correctName, user.id, user.name);
      }

      writeResult(correctName, result, null); // write a file with a new name to the result object
    } catch (e) {
      if (!e.message.includes('-9')) console.log(e); // display error message in the console
      writeResult(null, null, e.message);
    }
  };

  try {
    // check if the file with such an extension can be converted
    if ((fileUtility.getConvertExtensions().indexOf(fileExt) !== -1) || ('fileExt' in req.body)) {
      const storagePath = req.DocManager.storagePath(fileName);
      const stat = fileSystem.statSync(storagePath);
      let key = fileUri + stat.mtime.getTime();

      key = documentService.generateRevisionId(key); // get document key
      // get the url to the converted file
      documentService.getConvertedUri(fileUri, fileExt, convExt, key, true, callback, filePass, lang, fileName);
    } else {
      // if the file with such an extension can't be converted, write the origin file to the result object
      writeResult(fileName, null, null);
    }
  } catch (ex) {
    console.log(ex);
    writeResult(null, null, 'Server error');
  }
});

app.get('/files', (req, res) => { // define a handler for getting files information
  try {
    req.DocManager = new DocManager(req, res);
    // get the information about the files from the storage path
    const filesInDirectoryInfo = req.DocManager.getFilesInfo();
    res.setHeader('Content-Type', 'application/json');
    res.write(JSON.stringify(filesInDirectoryInfo)); // transform files information into the json string
  } catch (ex) {
    console.log(ex);
    res.write('Server error');
  }
  res.end();
});

app.get('/files/file/:fileId', (req, res) => { // define a handler for getting file information by its id
  try {
    req.DocManager = new DocManager(req, res);
    const { fileId } = req.params;
    // get the information about the file specified by a file id
    const fileInfoById = req.DocManager.getFilesInfo(fileId);
    res.setHeader('Content-Type', 'application/json');
    res.write(JSON.stringify(fileInfoById));
  } catch (ex) {
    console.log(ex);
    res.write('Server error');
  }
  res.end();
});

app.delete('/file', (req, res) => { // define a handler for removing file
  try {
    req.DocManager = new DocManager(req, res);
    let fileName = req.query.filename;
    if (fileName) { // if the file name is defined
      fileName = fileUtility.getFileName(fileName); // get its part without an extension

      req.DocManager.fileRemove(fileName); // delete file and his history
    } else {
      // if the file name is undefined, clean the storage folder
      req.DocManager.cleanFolderRecursive(req.DocManager.storagePath(''), false);
    }

    res.write('{"success":true}');
  } catch (ex) {
    console.log(ex);
    res.write('Server error');
  }
  res.end();
});

app.get('/csv', (req, res) => { // define a handler for downloading csv files
  const fileName = 'csv.csv';
  const csvPath = path.join(__dirname, 'public', 'assets', 'document-templates', 'sample', fileName);

  // add headers to the response to specify the page parameters
  res.setHeader('Content-Length', fileSystem.statSync(csvPath).size);
  res.setHeader('Content-Type', mime.getType(csvPath));

  res.setHeader('Content-Disposition', `attachment; filename*=UTF-8''${encodeURIComponent(fileName)}`);

  const filestream = fileSystem.createReadStream(csvPath);
  filestream.pipe(res); // send file information to the response by streams
});

app.post('/reference', (req, res) => { // define a handler for renaming file
  req.DocManager = new DocManager(req, res);

  const result = function result(data) {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.write(JSON.stringify(data));
    res.end();
  };

  const { referenceData } = req.body;
  let fileName = '';
  if (referenceData) {
    const { instanceId } = referenceData;

    if (instanceId === req.DocManager.getInstanceId()) {
      const fileKey = JSON.parse(referenceData.fileKey);
      const { userAddress } = fileKey;

      if (userAddress === req.DocManager.curUserHostAddress()
                && req.DocManager.existsSync(req.DocManager.storagePath(fileKey.fileName))) {
        ({ fileName } = fileKey);
      }
    }
  }

  if (!fileName && !!req.body.path) {
    const filePath = fileUtility.getFileName(req.body.path);

    if (req.DocManager.existsSync(req.DocManager.storagePath(filePath))) {
      fileName = filePath;
    }
  }

  if (!fileName && !!req.body.link) {
    if (req.body.link.indexOf(req.DocManager.getServerUrl()) === -1) {
      result({
        url: req.body.link,
        directUrl: req.body.link,
      });
      return;
    }

    const urlObj = urlModule.parse(req.body.link, true);
    fileName = urlObj.query.fileName;
    if (!req.DocManager.existsSync(req.DocManager.storagePath(fileName))) {
      result({ error: 'File is not exist' });
      return;
    }
  }

  if (!fileName) {
    result({ error: 'File is not found' });
    return;
  }

  const data = {
    fileType: fileUtility.getFileExtension(fileName).slice(1),
    key: req.DocManager.getKey(fileName),
    url: req.DocManager.getDownloadUrl(fileName, true),
    directUrl: req.body.directUrl ? req.DocManager.getDownloadUrl(fileName) : null,
    referenceData: {
      fileKey: JSON.stringify({ fileName, userAddress: req.DocManager.curUserHostAddress() }),
      instanceId: req.DocManager.getServerUrl(),
    },
    link: `${req.DocManager.getServerUrl()}/editor?fileName=${encodeURIComponent(fileName)}`,
    path: fileName,
  };

  if (cfgSignatureEnable) {
    // sign token with given data using signature secret
    data.token = jwt.sign(data, cfgSignatureSecret, { expiresIn: cfgSignatureSecretExpiresIn });
  }

  result(data);
});

app.put('/restore', async (req, res) => { // define a handler for restore file version
  const { fileName, version, url } = req.body;
  const result = {};
  if (fileName) {
    req.DocManager = new DocManager(req, res);
    const userAddress = req.DocManager.curUserHostAddress();
    const key = req.DocManager.getKey(fileName);
    const filePath = req.DocManager.storagePath(fileName, userAddress);
    const historyPath = req.DocManager.historyPath(fileName, userAddress);
    const newVersion = req.DocManager.countVersion(historyPath) + 1;
    const newVersionPath = path.join(`${historyPath}`, `${newVersion}`);
    if (url) {
      const { status, data } = await urllib.request(url, { method: 'GET' });
      if (status === 200) {
        req.DocManager.createDirectory(newVersionPath);
        req.DocManager.copyFile(
          filePath,
          path.join(`${newVersionPath}`, `prev${fileUtility.getFileExtension(fileName)}`),
        );
        fileSystem.writeFileSync(path.join(`${newVersionPath}`, 'key.txt'), key);
        fileSystem.writeFileSync(filePath, data);
        result.success = true;
      } else {
        result.success = false;
        result.error = `Document editing service returned status: ${status}`;
      }
    } else {
      const versionPath = path.join(`${historyPath}`, `${version}`, `prev${fileUtility.getFileExtension(fileName)}`);
      if (fileSystem.existsSync(versionPath)) {
        req.DocManager.createDirectory(newVersionPath);
        req.DocManager.copyFile(
          filePath,
          path.join(`${newVersionPath}`, `prev${fileUtility.getFileExtension(fileName)}`),
        );
        fileSystem.writeFileSync(path.join(`${newVersionPath}`, 'key.txt'), key);
        req.DocManager.copyFile(versionPath, filePath);
        result.success = true;
      } else {
        result.success = false;
        result.error = 'Version path does not exists';
      }
    }
  } else {
    result.success = false;
    result.error = 'Filename is empty';
  }

  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.write(JSON.stringify(result));
  res.end();
});

app.post('/track', async (req, res) => { // define a handler for tracking file changes
  req.DocManager = new DocManager(req, res);

  let uAddress = req.query.useraddress;
  let fName = fileUtility.getFileName(req.query.filename);
  let version = 0;

  // track file changes
  const processTrack = async function processTrack(response, bodyTrack, fileNameTrack, userAddressTrack) {
    // callback file saving process
    const callbackProcessSave = async function callbackProcessSave(
      downloadUri,
      body,
      fileName,
      userAddress,
      newFileName,
    ) {
      try {
        if (!req.DocManager.existsSync(req.DocManager.storagePath(fileName, userAddress))) {
          console.log(`callbackProcessSave error: name = ${fileName} userAddress = ${userAddress} is not exist`);
          response.write('{"error":1, "message":"file is not exist"}');
          response.end();
          return;
        }

        const { status, data } = await urllib.request(downloadUri, { method: 'GET' });

        if (status !== 200) throw new Error(`Document editing service returned status: ${status}`);

        const storagePath = req.DocManager.storagePath(newFileName, userAddress);

        let historyPath = req.DocManager.historyPath(newFileName, userAddress); // get the path to the history data
        if (historyPath === '') { // if the history path doesn't exist
          historyPath = req.DocManager.historyPath(newFileName, userAddress, true); // create it
          req.DocManager.createDirectory(historyPath); // and create a directory for the history data
        }

        const countVersion = req.DocManager.countVersion(historyPath); // get the next file version number
        version = countVersion + 1;
        // get the path to the specified file version
        const versionPath = req.DocManager.versionPath(newFileName, userAddress, version);
        req.DocManager.createDirectory(versionPath); // create a directory to the specified file version

        const downloadZip = body.changesurl;
        if (downloadZip) {
          // get the path to the file with document versions differences
          const pathChanges = req.DocManager.diffPath(newFileName, userAddress, version);
          const zip = await urllib.request(downloadZip, { method: 'GET' });
          const statusZip = zip.status;
          const dataZip = zip.data;
          if (statusZip === 200) {
            fileSystem.writeFileSync(pathChanges, dataZip); // write the document version differences to the archive
          } else {
            emitWarning(`Document editing service returned status: ${statusZip}`);
          }
        }

        const changeshistory = body.changeshistory || JSON.stringify(body.history);
        if (changeshistory) {
          // get the path to the file with document changes
          const pathChangesJson = req.DocManager.changesPath(newFileName, userAddress, version);
          fileSystem.writeFileSync(pathChangesJson, changeshistory); // and write this data to the path in json format
        }

        const pathKey = req.DocManager.keyPath(newFileName, userAddress, version); // get the path to the key.txt file
        fileSystem.writeFileSync(pathKey, body.key); // write the key value to the key.txt file

        // get the path to the previous file version
        const pathPrev = path.join(versionPath, `prev${fileUtility.getFileExtension(fileName)}`);
        // and write it to the current path
        fileSystem.renameSync(req.DocManager.storagePath(fileName, userAddress), pathPrev);

        fileSystem.writeFileSync(storagePath, data);

        // get the path to the forcesaved file
        const forcesavePath = req.DocManager.forcesavePath(newFileName, userAddress, false);
        if (forcesavePath !== '') { // if this path is empty
          fileSystem.unlinkSync(forcesavePath); // remove it
        }
      } catch (ex) {
        console.log(ex);
        response.write(`{"error":1,"message":${JSON.stringify(ex)}}`);
        response.end();
        return;
      }

      response.write('{"error":0}');
      response.end();
    };

    // file saving process
    const processSave = async function processSave(downloadUri, body, fileName, userAddress) {
      if (!downloadUri) {
        response.write('{"error":1,"message":"save uri is empty"}');
        response.end();
        return;
      }

      const curExt = fileUtility.getFileExtension(fileName); // get current file extension
      const downloadExt = `.${body.filetype}`; // get the extension of the downloaded file

      let newFileName = fileName;

      // convert downloaded file to the file with the current extension if these extensions aren't equal
      if (downloadExt !== curExt) {
        const key = documentService.generateRevisionId(downloadUri);
        // get the correct file name if it already exists
        newFileName = req.DocManager.getCorrectName(fileUtility.getFileName(fileName, true) + downloadExt, userAddress);
        try {
          documentService.getConvertedUriSync(downloadUri, downloadExt, curExt, key, async (err, data) => {
            if (err) {
              await callbackProcessSave(downloadUri, body, fileName, userAddress, newFileName);
              return;
            }
            try {
              const resp = documentService.getResponseUri(data);
              await callbackProcessSave(resp.uri, body, fileName, userAddress, fileName);
            } catch (ex) {
              console.log(ex);
              await callbackProcessSave(downloadUri, body, fileName, userAddress, newFileName);
            }
          });
          return;
        } catch (ex) {
          console.log(ex);
        }
      }
      await callbackProcessSave(downloadUri, body, fileName, userAddress, newFileName);
    };

    // callback file force saving process
    const callbackProcessForceSave = async function callbackProcessForceSave(
      downloadUri,
      body,
      fileName,
      userAddress,
      newFileName = false,
    ) {
      try {
        const { status, data } = await urllib.request(downloadUri, { method: 'GET' });

        if (status !== 200) throw new Error(`Document editing service returned status: ${status}`);

        const downloadExt = `.${body.fileType}`;
        const isSubmitForm = body.forcesavetype === 3; // SubmitForm
        let correctName = fileName;
        let forcesavePath = '';

        if (isSubmitForm) {
          // new file
          if (newFileName) {
            correctName = req.DocManager.getCorrectName(
              `${fileUtility.getFileName(fileName, true)}-form${downloadExt}`,
              userAddress,
            );
          } else {
            const ext = fileUtility.getFileExtension(fileName);
            correctName = req.DocManager.getCorrectName(
              `${fileUtility.getFileName(fileName, true)}-form${ext}`,
              userAddress,
            );
          }
          forcesavePath = req.DocManager.storagePath(correctName, userAddress);
        } else {
          if (newFileName) {
            correctName = req.DocManager.getCorrectName(fileUtility.getFileName(
              fileName,
              true,
            ) + downloadExt, userAddress);
          }
          // create forcesave path if it doesn't exist
          forcesavePath = req.DocManager.forcesavePath(correctName, userAddress, false);
          if (forcesavePath === '') {
            forcesavePath = req.DocManager.forcesavePath(correctName, userAddress, true);
          }
        }

        fileSystem.writeFileSync(forcesavePath, data);

        if (isSubmitForm) {
          const uid = body.actions[0].userid;
          req.DocManager.saveFileData(correctName, uid, 'Filling Form', userAddress);

          const { formsdataurl } = body;
          if (formsdataurl) {
            const formsdataName = req.DocManager.getCorrectName(
              `${fileUtility.getFileName(correctName, true)}.txt`,
              userAddress,
            );
            // get the path to the file with forms data
            const formsdataPath = req.DocManager.storagePath(formsdataName, userAddress);
            const formsdata = await urllib.request(formsdataurl, { method: 'GET' });
            const statusFormsdata = formsdata.status;
            const dataFormsdata = formsdata.data;
            if (statusFormsdata === 200) {
              fileSystem.writeFileSync(formsdataPath, dataFormsdata); // write the forms data
            } else {
              emitWarning(`Document editing service returned status: ${statusFormsdata}`);
            }
          } else {
            emitWarning('Document editing service do not returned formsdataurl');
          }
        }
      } catch (ex) {
        console.log(ex);
        response.write(`{"error":1,"message":${JSON.stringify(ex)}}`);
        response.end();
        return;
      }

      response.write('{"error":0}');
      response.end();
    };

    // file force saving process
    const processForceSave = async function processForceSave(downloadUri, body, fileName, userAddress) {
      if (!downloadUri) {
        response.write('{"error":1,"message":"forcesave uri is empty"}');
        response.end();
        return;
      }

      const curExt = fileUtility.getFileExtension(fileName);
      const downloadExt = `.${body.filetype}`;

      // convert downloaded file to the file with the current extension if these extensions aren't equal
      if (downloadExt !== curExt) {
        const key = documentService.generateRevisionId(downloadUri);
        try {
          documentService.getConvertedUriSync(downloadUri, downloadExt, curExt, key, async (err, data) => {
            if (err) {
              await callbackProcessForceSave(downloadUri, body, fileName, userAddress, true);
              return;
            }
            try {
              const resp = documentService.getResponseUri(data);
              await callbackProcessForceSave(resp.uri, body, fileName, userAddress, false);
            } catch (ex) {
              console.log(ex);
              await callbackProcessForceSave(downloadUri, body, fileName, userAddress, true);
            }
          });
          return;
        } catch (ex) {
          console.log(ex);
        }
      }
      await callbackProcessForceSave(downloadUri, body, fileName, userAddress, false);
    };

    if (bodyTrack.status === 1) { // editing
      if (bodyTrack.actions && bodyTrack.actions[0].type === 0) { // finished edit
        const user = bodyTrack.actions[0].userid;
        if (bodyTrack.users.indexOf(user) === -1) {
          const { key } = bodyTrack;
          try {
            documentService.commandRequest('forcesave', key); // call the forcesave command
          } catch (ex) {
            console.log(ex);
          }
        }
      }
    } else if (bodyTrack.status === 2 || bodyTrack.status === 3) { // MustSave, Corrupted
      await processSave(bodyTrack.url, bodyTrack, fileNameTrack, userAddressTrack); // save file
      return;
    } else if (bodyTrack.status === 6 || bodyTrack.status === 7) { // MustForceSave, CorruptedForceSave
      await processForceSave(bodyTrack.url, bodyTrack, fileNameTrack, userAddressTrack); // force save file
      return;
    }

    response.write('{"error":0}');
    response.end();
  };

  // read request body
  const readbody = async function readbody(request, response, fileName, userAddress) {
    let content = '';
    request.on('data', async (data) => { // get data from the request
      content += data;
    });
    request.on('end', async () => {
      const body = JSON.parse(content);
      await processTrack(response, body, fileName, userAddress); // and track file changes
    });
  };

  // check jwt token
  if (cfgSignatureEnable && cfgSignatureUseForRequest) {
    let body = null;
    if (req.body.hasOwnProperty('token')) { // if request body has its own token
      body = documentService.readToken(req.body.token); // read and verify it
    } else {
      const checkJwtHeaderRes = documentService.checkJwtHeader(req); // otherwise, check jwt token headers
      if (checkJwtHeaderRes) { // if they exist
        if (checkJwtHeaderRes.payload) {
          body = checkJwtHeaderRes.payload; // get the payload object
        }
        // get user address and file name from the query
        if (checkJwtHeaderRes.query) {
          if (checkJwtHeaderRes.query.useraddress) {
            uAddress = checkJwtHeaderRes.query.useraddress;
          }
          if (checkJwtHeaderRes.query.filename) {
            fName = fileUtility.getFileName(checkJwtHeaderRes.query.filename);
          }
        }
      }
    }
    if (!body) {
      res.write('{"error":1,"message":"body is empty"}');
      res.end();
      return;
    }
    await processTrack(res, body, fName, uAddress);
    return;
  }

  if (req.body.hasOwnProperty('status')) { // if the request body has status parameter
    await processTrack(res, req.body, fName, uAddress); // track file changes
  } else {
    await readbody(req, res, fName, uAddress); // otherwise, read request body first
  }
});

app.get('/config', async (req, res) => {
  try {
    req.DocManager = new DocManager(req, res);
    const fileName = fileUtility.getFileName(req.query.fileName);

    const userAddress = req.DocManager.curUserHostAddress();
    // if the file with a given name doesn't exist
    if (!req.DocManager.existsSync(req.DocManager.storagePath(fileName, userAddress))) {
      throw new Error(`File not found: ${fileName}`); // display error message
    }

    // file config data
    const data = {
      document: {
        key: req.DocManager.getKey(fileName),
        title: fileName,
        url: req.DocManager.getDownloadUrl(fileName, true),
        permissions: JSON.parse(req.query.permissions || '{}'),
        referenceData: {
          fileKey: JSON.stringify({ fileName, userAddress: req.DocManager.curUserHostAddress() }),
          instanceId: req.DocManager.getInstanceId(),
        },
      },
      editorConfig: {
        callbackUrl: req.DocManager.getCallback(fileName),
        mode: 'edit',
      },
    };

    if (req.query.directUrl === 'true') {
      data.document.directUrl = req.DocManager.getDownloadUrl(fileName);
    }

    if (cfgSignatureEnable) {
      // sign token with given data using signature secret
      data.token = jwt.sign(data, cfgSignatureSecret, { expiresIn: cfgSignatureSecretExpiresIn });
    }

    res.setHeader('Content-Type', 'application/json');
    res.write(JSON.stringify(data));
  } catch (ex) {
    console.log(ex);
    res.status(500);
    res.write('error');
  }
  res.end();
});

app.get('/editor', (req, res) => { // define a handler for editing document
  try {
    req.DocManager = new DocManager(req, res);

    let { fileExt } = req.query;
    const user = users.getUser(req.query.userid);
    const userid = user.id;
    const { name } = user;

    if (fileExt) {
      fileExt = fileUtility.getFileExtension(fileUtility.getFileName(fileExt), true);
      // create demo document of a given extension
      const fName = req.DocManager.createDemo(!!req.query.sample, fileExt, userid, name, false);

      // get the redirect path
      const redirectPath = `${req.DocManager.getServerUrl()}/editor?mode=edit&fileName=`
      + `${encodeURIComponent(fName)}${req.DocManager.getCustomParams()}`;
      res.redirect(redirectPath);
      return;
    }

    const fileName = fileUtility.getFileName(req.query.fileName);
    const lang = req.DocManager.getLang();
    const userDirectUrl = req.query.directUrl === 'true';

    let actionData = 'null';
    if (req.query.action) {
      try {
        actionData = JSON.stringify(JSON.parse(req.query.action));
      } catch (ex) {
        console.log(ex);
      }
    }

    let type = req.query.type || ''; // type: embedded/mobile/desktop
    if (type === '') {
      type = new RegExp(configServer.get('mobileRegEx'), 'i').test(req.get('User-Agent')) ? 'mobile' : 'desktop';
    } else if (type !== 'mobile'
            && type !== 'embedded') {
      type = 'desktop';
    }

    const templatesImageUrl = req.DocManager.getTemplateImageUrl(fileUtility.getFileType(fileName));
    const createUrl = req.DocManager.getCreateUrl(fileUtility.getFileType(fileName), userid, type, lang);
    let templates = null;
    if (createUrl != null) {
      templates = [
        {
          image: '',
          title: 'Blank',
          url: createUrl,
        },
        {
          image: templatesImageUrl,
          title: 'With sample content',
          url: `${createUrl}&sample=true`,
        },
      ];
    }

    const userGroup = user.group;
    const { reviewGroups } = user;
    const { commentGroups } = user;
    const { userInfoGroups } = user;
    const userRoles = user.roles;

    const usersInfo = [];
    const usersForProtect = [];
    if (user.id !== 'uid-0') {
      users.getAllUsers().forEach((userInfo) => {
        const u = userInfo;
        u.image = userInfo.avatar ? `${req.DocManager.getServerUrl()}/images/${userInfo.id}.png` : null;
        usersInfo.push(u);
      }, usersInfo);

      users.getUsersForProtect(user.id).forEach((userInfo) => {
        const u = userInfo;
        u.image = userInfo.avatar ? `${req.DocManager.getServerUrl()}/images/${userInfo.id}.png` : null;
        usersForProtect.push(u);
      }, usersForProtect);
    }

    fileExt = fileUtility.getFileExtension(fileName);

    const userAddress = req.DocManager.curUserHostAddress();
    // if the file with a given name doesn't exist
    if (!req.DocManager.existsSync(req.DocManager.storagePath(fileName, userAddress))) {
      throw new Error(`File not found: ${fileName}`); // display error message
    }
    const key = req.DocManager.getKey(fileName);
    const url = req.DocManager.getDownloadUrl(fileName, true);
    const directUrl = req.DocManager.getDownloadUrl(fileName);
    let mode = req.query.mode || 'edit'; // mode: view/edit/review/comment/fillForms/embedded

    let canEdit = fileUtility.getEditExtensions().indexOf(fileExt.slice(1)) !== -1; // check if this file can be edited
    if (((!canEdit && mode === 'edit') || mode === 'fillForms')
      && fileUtility.getFillExtensions().indexOf(fileExt.slice(1)) !== -1) {
      mode = 'fillForms';
      canEdit = true;
    }
    if (!canEdit && mode === 'edit') {
      mode = 'view';
    }

    let submitForm = false;
    if (mode !== 'view') {
      submitForm = user.canSubmitForm;
    }

    if (user.goback != null) {
      user.goback.url = `${req.DocManager.getServerUrl()}`;
    }

    // file config data
    const argss = {
      apiUrl: siteUrl + configServer.get('apiUrl'),
      file: {
        name: fileName,
        ext: fileUtility.getFileExtension(fileName, true),
        uri: url,
        directUrl: !userDirectUrl ? null : directUrl,
        uriUser: directUrl,
        created: new Date().toDateString(),
        favorite: user.favorite != null ? user.favorite : 'null',
      },
      editor: {
        type,
        documentType: fileUtility.getFileType(fileName),
        key,
        token: '',
        callbackUrl: req.DocManager.getCallback(fileName),
        createUrl: userid !== 'uid-0' ? createUrl : null,
        templates: user.templates ? templates : null,
        isEdit: canEdit && (mode === 'edit' || mode === 'view' || mode === 'filter' || mode === 'blockcontent'),
        review: canEdit && (mode === 'edit' || mode === 'review'),
        chat: userid !== 'uid-0',
        coEditing: mode === 'view' && userid === 'uid-0' ? { mode: 'strict', change: false } : null,
        comment: mode !== 'view' && mode !== 'fillForms' && mode !== 'embedded' && mode !== 'blockcontent',
        fillForms: mode !== 'view' && mode !== 'comment' && mode !== 'blockcontent',
        modifyFilter: mode !== 'filter',
        modifyContentControl: mode !== 'blockcontent',
        copy: !user.deniedPermissions.includes('copy'),
        download: !user.deniedPermissions.includes('download'),
        print: !user.deniedPermissions.includes('print'),
        mode: mode !== 'view' ? 'edit' : 'view',
        canBackToFolder: type !== 'embedded',
        curUserHostAddress: req.DocManager.curUserHostAddress(),
        lang,
        userid: userid !== 'uid-0' ? userid : null,
        userImage: user.avatar ? `${req.DocManager.getServerUrl()}/images/${user.id}.png` : null,
        name,
        userGroup,
        userRoles,
        reviewGroups: JSON.stringify(reviewGroups),
        commentGroups: JSON.stringify(commentGroups),
        userInfoGroups: JSON.stringify(userInfoGroups),
        fileChoiceUrl,
        submitForm,
        plugins: JSON.stringify(plugins),
        actionData,
        fileKey: userid !== 'uid-0'
          ? JSON.stringify({ fileName, userAddress: req.DocManager.curUserHostAddress() }) : null,
        instanceId: userid !== 'uid-0' ? req.DocManager.getInstanceId() : null,
        protect: !user.deniedPermissions.includes('protect'),
        goback: user.goback != null ? user.goback : '',
        close: user.close,
      },
      dataInsertImage: {
        fileType: 'svg',
        url: `${req.DocManager.getServerUrl(true)}/images/logo.svg`,
        directUrl: !userDirectUrl ? null : `${req.DocManager.getServerUrl()}/images/logo.svg`,
      },
      dataDocument: {
        fileType: 'docx',
        url: `${req.DocManager.getServerUrl(true)}/assets/document-templates/sample/sample.docx`,
        directUrl: !userDirectUrl
          ? null
          : `${req.DocManager.getServerUrl()}/assets/document-templates/sample/sample.docx`,
      },
      dataSpreadsheet: {
        fileType: 'csv',
        url: `${req.DocManager.getServerUrl(true)}/csv`,
        directUrl: !userDirectUrl ? null : `${req.DocManager.getServerUrl()}/csv`,
      },
      usersForMentions: user.id !== 'uid-0' ? users.getUsersForMentions(user.id) : null,
      usersForProtect,
      usersInfo,
    };

    if (cfgSignatureEnable) {
      app.render('config', argss, (err, html) => { // render a config template with the parameters specified
        if (err) {
          console.log(err);
        } else {
          // sign token with given data using signature secret
          argss.editor.token = jwt.sign(
            JSON.parse(`{${html}}`),
            cfgSignatureSecret,
            { expiresIn: cfgSignatureSecretExpiresIn },
          );
          argss.dataInsertImage.token = jwt.sign(
            argss.dataInsertImage,
            cfgSignatureSecret,
            { expiresIn: cfgSignatureSecretExpiresIn },
          );
          argss.dataDocument.token = jwt.sign(
            argss.dataDocument,
            cfgSignatureSecret,
            { expiresIn: cfgSignatureSecretExpiresIn },
          );
          argss.dataSpreadsheet.token = jwt.sign(
            argss.dataSpreadsheet,
            cfgSignatureSecret,
            { expiresIn: cfgSignatureSecretExpiresIn },
          );
        }
        res.render('editor', argss); // render the editor template with the parameters specified
      });
    } else {
      res.render('editor', argss);
    }
  } catch (ex) {
    console.log(ex);
    res.status(500);
    res.render('error', { message: `Server error: ${ex.message}` });
  }
});

app.post('/rename', (req, res) => { // define a handler for renaming file
  let { newfilename } = req.body;
  const origExt = req.body.ext;
  const curExt = fileUtility.getFileExtension(newfilename, true);
  if (curExt !== origExt) {
    newfilename += `.${origExt}`;
  }

  const { dockey } = req.body;
  const meta = { title: newfilename };

  const result = function result(err, data, ress) {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.write(JSON.stringify({ result: ress }));
    res.end();
  };

  documentService.commandRequest('meta', dockey, result, meta);
});

app.post('/historyObj', (req, res) => {
  req.DocManager = new DocManager(req, res);
  const { fileName } = req.body;
  const { directUrl } = req.body || null;
  const historyObj = req.DocManager.getHistoryObject(fileName, null, directUrl);

  if (cfgSignatureEnable) {
    for (let i = 0; i < historyObj.historyData.length; i++) {
      // sign token with given data using signature secret
      historyObj.historyData[i].token = jwt.sign(
        historyObj.historyData[i],
        cfgSignatureSecret,
        { expiresIn: cfgSignatureSecretExpiresIn },
      );
    }
  }
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.write(JSON.stringify(historyObj));
  res.end();
});

app.get('/formats', (req, res) => {
  try {
    const formats = fileUtility.getFormats();
    res.json({
      formats,
    });
  } catch (ex) {
    console.log(ex); // display error message in the console
    res.status(500); // write status parameter to the response
    res.render('error', { message: 'Server error' }); // render error template with the message parameter specified
  }
});

wopiApp.registerRoutes(app);

// "Not found" error with 404 status
app.use((req, res, next) => {
  const err = new Error('Not Found');
  err.status = 404;
  next(err);
});

// render the error template with the parameters specified
// eslint-disable-next-line no-unused-vars
app.use((err, req, res, next) => {
  res.status(err.status || 500);
  res.render('error', {
    message: err.message,
  });
});

// save all the functions to the app module to export it later in other files
module.exports = app;