const FileManager = require("./file_manager")
const config = require("./config")
const execSync = require("child_process").execSync
const JtlSql = require("./jtlsql")
const DhlReturns = require("./dhl_returns")
const fileManager = new FileManager()
const jtlSql = new JtlSql()
const CsvLogger = require('./csv_logger')
const CsvExport = require('./csv_export')
const PATH_LOGFILES = require('./config').PATH_LOGFILES;
const FILE_PATH_CSV_EXPORT = require('./config').FILE_PATH_CSV_EXPORT;
const EXPECTED_PROPERTIES = require('./config').EXPECTED_PROPERTIES
const logger = new CsvLogger(PATH_LOGFILES, ['timestamp', 'level', 'message'], 30); // 30 Tage aufbewahren
const csvExport = new CsvExport(FILE_PATH_CSV_EXPORT)
const EmailSender = require("./email_sender")
const CsvToHtmlConverter = require("./csv_to_html_converter")
const path = require('path');


class App {

  #warnOrErrOccured = false
  #timestamp
  
  constructor() {
    this.#timestamp = Math.round(parseInt(Date.now()) / 1000)    
    logger.timestamp = this.#timestamp

    process.on('uncaughtException', (err)=>{
      this.#warnOrErrOccured = err
      console.log(err)
      this.#shutdown()
    })

  }

  async run() {
    
    logger.log('info',"Pogramm gestartet")    
    logger.log('info',"Lade Datei "+config.FILE_PATH_SENDUNGSNUMMERN)
    let data = []
    
    try {
      data = fileManager.readExcelFile(config.FILE_PATH_SENDUNGSNUMMERN)
    } catch (err) {
      logger.log("err",err.message)
      this.#warnOrErrOccured = err
      await this.#shutdown()
    }
    
    
    await this.#checkDataStructure(Object.getOwnPropertyNames(data[0]))        
    
    logger.log('info', data.length+" Datensätze gefunden")
    
    for (let i=0; i < data.length; i++) {      
      const liefBestNr = data[i]['Auftrags-Nr._1']

      const order = await jtlSql.getOrderOnLiefBest(liefBestNr)
      if (!order) {
        logger.log('warn',"Keinen Auftrag gefunden zur Lieferantenbestellung: "+liefBestNr)
        this.#warnOrErrOccured = true
        continue
      }
      logger.log('info',"Auftrag '"+ order.cBestellNr+"' gefunden zur Lieferantenbestellung: "+liefBestNr)      
      await this.#handleShipping(data[i], order)      
    }   
    
    if (config.MOVE_FILE_TO_PROCESSED_FOLDER) {      
      await this.#moveFileToProcessedFolder(config.FILE_PATH_SENDUNGSNUMMERN)
    }
    
    await this.#shutdown()    
  }

   async #shutdown() {
    if (this.#warnOrErrOccured) {
      //logger.log("err",this.#warnOrErrOccured.message)
      if (config.SEND_MAIL_ON_EROR) {
        let emailSender = new EmailSender()
        let csvToHtmlConverter = new CsvToHtmlConverter()     
        await emailSender.sendMail({
          to: defaultEmailConfig.to,
          subject: "[Problem] Sendungsnummern Frank Flechtwaren",        
          html: `Last Error: <p style="font-weight: bold"">${this.#warnOrErrOccured.toString()}</p><br><br> ${await csvToHtmlConverter.convertToHtml(logger.getLogFilePath())}`       
        })
      }
      
      process.exit(1)
    }
    logger.log("info","Proramm beendet")
    process.exit()
  }

  async #handleShipping(excelFileData, jtlOrderData) {
    const sendDate = FileManager.convertDateExcel(excelFileData.Versanddatum)
    console.log(excelFileData)
    const lieferschein = await jtlSql.getLieferscheinOnAuftragsnummer(jtlOrderData.cBestellNr)
    console.log(lieferschein)
    const data = {
      id: lieferschein.cLieferscheinNr,
      date: this.#formatDate(sendDate),
      trackingNr: excelFileData['Sendungs-Nr.'], 
      infos: excelFileData['Lieferschein-Nr.'], 
      returnTrackingNr:''      
    }

    if (jtlOrderData.kShop == 7) {
      const paket = {}
      paket.itemWeight = 1
      paket.cReference = jtlOrderData.cBestellNr + " / " + jtlOrderData.cInetBestellNr
      const labelData = await this.#createLabelData(excelFileData, jtlOrderData, paket)
      
      data.returnTrackingNr = this.#getDhlReturnTrackingCode(labelData).toString() 
      
    }

    csvExport.add(data)
  }

  #formatDate(d) {

    let day =  d.getDate()
    if (day < 10) day = `0${day}`
    let month = d.getMonth() + 1
    if (month < 10) month = `0${month}`
    let year = d.getFullYear()
    return day +'.'+ month  +'.'+year
  }



  async #createLabelData(excelFileData, jtlOrderData, paketData) {
       
    const liefAddress = await jtlSql.getAdresse(jtlOrderData.tAdresse_kAdresse)
    
    const data = {
      firma: liefAddress.cFirma,
      name: excelFileData['Liefer-Name'] ? excelFileData['Liefer-Name'] : liefAddress.cVorname + ' '+ liefAddress.cNachname ,
      strasse: excelFileData['Liefer-Str.'] ? excelFileData['Liefer-Str.'] : liefAddress.cStrasse,
      plz: excelFileData['Liefer-Plz'] ? excelFileData['Liefer-Plz'] : liefAddress.cPLZ,
      ort: excelFileData['Liefer-Stadt'] ? excelFileData['Liefer-Stadt'] : liefAddress.cOrt,
      landISO2: liefAddress.cISO,
      email: liefAddress.cMail,

      itemWeight: paketData.fGewicht * 1000,
      customerReference: paketData.cReference.replaceAll("  "," "),
      shipmentReference: paketData.cReference.replaceAll("  "," "),
    }

    return data
  }


  #getDhlReturnTrackingCode(labelData) {
    const dhlReturns = new DhlReturns()       
    const dhlShippingData = dhlReturns.createDhlShippingDataObject(labelData)

    const returnTrackingCode = execSync(
              "node ../dhlApi/index.js func=ReturnShipping data=\"" +
              JSON.stringify(dhlShippingData).replaceAll('"', '\\"') +
              "\""
    )
    return returnTrackingCode
  }


  async #checkDataStructure(proerties) {

    if (proerties) {      
      try {
        if (this.#hasDataStructureChanged(proerties)) {
          throw new Error("DATA_STRUCTURE_OF_FILE_HAS_CHANGED")
        }
        logger.log("info", "Datenstruktur ist OK")
      } catch (err) {
        this.#warnOrErrOccured = err
        logger.log('err', "Fehler in der Datenstruktur: " + err.message)
        await this.#shutdown()
      }
    }

  }

  #hasDataStructureChanged(properties) {
    return JSON.stringify(properties) !== JSON.stringify(EXPECTED_PROPERTIES)
  }

  async #moveFileToProcessedFolder(file) {
    //Move file to processed
    let fileManager = new FileManager()   
    let filename = this.#timestamp + "_" + path.basename(file)

    try {
      await fileManager.moveFile(file, config.PATH_TO_MOVE_PROCESSED_FILES + filename)
    } catch (err) {
      this.#warnOrErrOccured = err      
      logger.log('error', "Fehler beim verschieben: " + err.message)
    }
  }

}

module.exports = App