//
//  EpsonFiscalPrinter.swift
//  iPOS
//
//  Created by bbc on 19/11/16.
//  Copyright © 2016 BBC. All rights reserved.
//

import Foundation
import Alamofire
import SWXMLHash

class XMLReceiptFiscalPrinter {
    var xml: String
    
    /*
     1 = Additional header. This type must be placed before the beginFiscalReceipt sub-element.
     2 = Additional row (before MF logotype).
     3 = Additional promo (after MF logotype).
     4 = Additional description (in the body of the fiscal receipt).
     7 = Customer Id     
     8 = Print or Erase all EFT-POS transaction lines. Requires firmware version >= 4.012.
     */
    
    enum MessageType: Int {
        case additionalHeaderBeforeBeginFiscalReceipt = 1
        case additionalRowBeforeMF = 2
        case additionalPromoAfterMF = 3
        case additionalDescriptionInBody = 4
    }
    var font: String{
        get{
            return "1" //settings.PrinterFont.description
        }
    }
    let NEWLINE = "\n"
    
    init() {
        xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
        + NEWLINE + "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">"
        + NEWLINE + "<s:Body>"
        
    }
    
    func printerFiscalReceipt(){
        xml += NEWLINE + "<printerFiscalReceipt>"
    }
    
    func beginFiscalReceiptSecond(){
        xml +=  NEWLINE + "<beginFiscalReceipt>"
    }
    
    func beginFiscalReceipt(){
        xml += NEWLINE + "<printerFiscalReceipt>"
        + NEWLINE + "<beginFiscalReceipt/>"
    }
    
    func beginNonFiscalReceipt(){
        xml += NEWLINE + "<printerNonFiscal>"
            + NEWLINE + "<beginNonFiscal/>"
    }
    
    func beginRefundTicket(message: String, messageType: MessageType, index: inout Int){
        let msg = self.removeIllegalCharacters(message: message)
        let nextIndex = self.getNextMessageTypeIndex(index: &index)
        xml += NEWLINE + "<printRecMessage  operator=\"1\" messageType=\"\(messageType.rawValue)\" index=\"\(nextIndex)\" font=\"\(font)\" message=\"\(msg)\" />"
    }
    
    func printRecRefund(description: String, quantity: Double, unitPrice: Double, department: Int){
        let desc = self.removeIllegalCharacters(message: description)
        xml +=  NEWLINE + "<printRecRefund  operator=\"1\" font=\"\(font)\" description=\"\(desc)\" quantity=\"\(Util.DoubleToStringWithPointSeparator(quantity))\" unitPrice=\"\(Util.DoubleToStringWithPointSeparator(unitPrice))\" department=\"\(department)\" justification=\"1\" />"
   }
    
    func printRecMessage(message: String, messageType: MessageType, index: inout Int){
        let msg = self.removeIllegalCharacters(message: message)
        let nextIndex = self.getNextMessageTypeIndex(index: &index)
        xml += NEWLINE + "<printRecMessage  operator=\"1\" messageType=\"\(messageType.rawValue)\" index=\"\(nextIndex)\" font=\"\(font)\" message=\"\(msg)\" />"
    }
    
    func printRecFooter(footer: [String], messageType: MessageType, index: inout Int){
        for line in footer{
            let msg = self.removeIllegalCharacters(message: line)
            let nextIndex = self.getNextMessageTypeIndex(index: &index)
            xml += NEWLINE + "<printRecMessage  operator=\"1\" messageType=\"\(messageType.rawValue)\" index=\"\(nextIndex)\" font=\"\(font)\" message=\"\(msg)\" />"
        }
    }
    
    func printRecItem(description: String, quantity: Double, unitPrice: Double, department: Int){
        let desc = self.removeIllegalCharacters(message: description)
        xml +=  NEWLINE + "<printRecItem  operator=\"1\" font=\"\(font)\" description=\"\(desc)\" quantity=\"\(Util.DoubleToStringWithPointSeparator(quantity))\" unitPrice=\"\(Util.DoubleToStringWithPointSeparator(unitPrice))\" department=\"\(department)\" justification=\"1\" />"
    }
    
    func printRecItemAdjustment(description: String, adjustmentType: Int, amount: Double){
        let desc = self.removeIllegalCharacters(message: description)
        xml +=  NEWLINE + "<printRecItemAdjustment operator=\"1\" font=\"\(font)\" description=\"\(desc)\" adjustmentType=\"\(adjustmentType)\" amount=\"\(Util.DoubleToStringWithPointSeparator(amount))\" justification=\"2\" />"
    }
    
    func printRecSubtotalAdjustment(cart: ShoppingCart){
        if let effects = cart.effects{
            for effect in effects{
                    if effect.promotionId == nil{
                        let desc = self.removeIllegalCharacters(message: effect.promotionName ?? Util.getString("Discount"))
                        xml +=  NEWLINE + "<printRecSubtotalAdjustment operator=\"1\" font=\"\(font)\" description=\"\(desc)\" adjustmentType=\"\(1)\" amount=\"\(Util.DoubleToStringWithPointSeparator(effect.rowDiscountValue))\" justification=\"2\" />"
                    }
                }
            }
        }
    
    func printBarcodeAsQRCode(barcode: String){
        //let desc = removeIllegalCharacters(message: description)
        xml += NEWLINE + "<printBarCode operator=\"1\" qRCodeAlignment=\"1\" qRCodeSize =\"5\" qRCodeErrorCorrection=\"0\" codeType=\"QRCODE2\" code=\"\(barcode)\" />"
    }
    
    func printBarcode(barcode: String){
        //let desc = removeIllegalCharacters(message: description)
        
        let position = 901
        var width = 1
        let height = 90
        let hriPos = 2
        let hriFont = "A"
        var barcodeType = "CODE39"
        var barcode = barcode;
        if settings.storeSetupSettings.printerBarcodeType.uppercased() == "CODE128"
        {
            width = 2
            barcodeType = "CODE128"
            barcode = "{A" + barcode;
        }
        
        xml += NEWLINE + "<printBarCode  operator=\"1\" position=\"\(position)\" width=\"\(width)\" height=\"\(height)\" hRIPosition=\"\(hriPos)\" hRIFont=\"\(hriFont)\" codeType=\"\(barcodeType)\" code=\"\(barcode)\" />"
    }
    
    func printRecTotal(description: String, payment: Double, paymentType: Int, index: Int){
        let desc = self.removeIllegalCharacters(message: description)
        xml += NEWLINE + "<printRecTotal  operator=\"1\" font=\"\(font)\" description=\"\(desc)\" payment=\"\(Util.DoubleToStringWithPointSeparator(payment))\" paymentType=\"\(paymentType)\" index=\"\(index)\" justification=\"2\" />"
    }
    
    func printRecTotal(payments: [Payment], index: Int){
        //add cash payment at the end
        var cashPayment: Payment? = nil
        if payments.count > 1 {
            cashPayment = payments.first(where: {$0.paymentType.Code == PaymentTypeString.CASH})
        }
        
        for payment in payments{
            if payment.paymentType.CategoryCode == PaymentCategory.DISCOUNT && payment.amount < 0{
                continue
            }
            
            if cashPayment != nil && cashPayment?.paymentType.Code == payment.paymentType.Code{
                continue
            }
            
            var paymentType: Int = 0
            
            switch payment.paymentType.CategoryCode {
            case PaymentCategory.CASH:
                paymentType = 0
                break
            case PaymentCategory.CHECK:
                paymentType = 1
                break
            case PaymentCategory.EFT:
                paymentType = 2
                break
            case PaymentCategory.TICKET:
                paymentType = 0
                break
            case PaymentCategory.DISCOUNT:
                paymentType = 6
                break
            default:
                paymentType = 0
                break
            }
            
            var newIndex = index
            if payment.paymentType.CategoryCode == PaymentCategory.TICKET || payment.paymentType.CategoryCode == PaymentCategory.EFT{
                newIndex = 1
            }
            
            xml += NEWLINE + "<printRecTotal  operator=\"1\" font=\"\(font)\" description=\"\(payment.name!)\" payment=\"\(Util.DoubleToStringWithPointSeparator(payment.amount))\" paymentType=\"\(paymentType)\" index=\"\(newIndex)\" justification=\"2\" />"
        }
        
        if let cp = cashPayment{
            xml += NEWLINE + "<printRecTotal  operator=\"1\" font=\"\(font)\" description=\"\(cp.name!)\" payment=\"\(Util.DoubleToStringWithPointSeparator(cp.amount))\" paymentType=\"\(0)\" index=\"\(0)\" justification=\"2\" />"
        }
    }
    
    func displayText(description: String){
        let desc = self.removeIllegalCharacters(message: description)
        xml += NEWLINE + "<displayText  operator=\"1\" data=\"\(desc)\" />"
    }
    
    func endFiscalReceipt(){
        xml += NEWLINE + "<endFiscalReceipt  operator=\"1\" />"
            + NEWLINE + "</printerFiscalReceipt>"
            + NEWLINE + "</s:Body>"
            + NEWLINE + "</s:Envelope>"
    }
    
    func endNonFiscalReceipt(){
        xml += NEWLINE + "<endNonFiscal operator=\"1\" />"
            + NEWLINE + "</printerNonFiscal>"
            + NEWLINE + "</s:Body>"
            + NEWLINE + "</s:Envelope>"
    }
    
    func removeIllegalCharacters(message: String) -> String{
        var msg = message
        msg = msg.replacingOccurrences(of: "&", with: "&amp;")
        msg = msg.replacingOccurrences(of: "<", with: "&lt;")
        msg = msg.replacingOccurrences(of: ">", with: "&gt;")
        msg = msg.replacingOccurrences(of: "\"", with: "&quot;")
        msg = msg.replacingOccurrences(of: "'", with: "&apos;")
        
        return msg
    }
    
    func getNextMessageTypeIndex(index: inout Int) -> Int{
        index += 1
        return index
    }
    
    func sendLotteryCode(code: String){
        let lotteryCode = code + String.init(repeating: " ", count: 16 - code.count)
        xml += "<printerCommand>"
            + String.init(format: "<directIO command=\"1135\" data=\"01%@0000\" />", lotteryCode)
            + "</printerCommand>"
    }
}

class XMLWorkOrderNonFiscal{
    var xml: String
    var font: String{
        get{
            return "1" //settings.PrinterFont.description
        }
    }
    let NEWLINE = "\n"
    let emptyLine = "<printNormal  operator=\"1\" font=\"1\" data =\"\" comment=\"New line\" />"
    
    init() {
        xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
            + NEWLINE + "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">"
            + NEWLINE + "<s:Body>"
    }
    
    func beginNonFiscal(){
        xml += NEWLINE + "<printerNonFiscal>"
            + NEWLINE + "<beginNonFiscal operator=\"1\">"
    }
    
    func printNormal(message:String){
        let msg = removeIllegalCharacters(message: message)
        xml += NEWLINE + "<printNormal  operator=\"1\" font=\"\(font)\" data=\"\(msg)\" />"
    }
    
    func printNormalPaymentTypes(receiptPayments: [ReceiptPayment]){
        for receiptPayment in receiptPayments{
            let msg = removeIllegalCharacters(message: receiptPayment.posPaymentTypes.Name)
            xml += NEWLINE + "<printNormal  operator=\"1\" font=\"\(font)\" data=\"\(msg)\" />"
        }
    }
    
    func printCurrency(message:String){
        let msg = removeIllegalCharacters(message: message)
        let spaceWidth = settings.PrinterColumns - msg.count
        let string = String.init(repeating: " ", count: spaceWidth) + msg
        xml += NEWLINE + "<printNormal  operator=\"1\" font=\"\(font)\" data=\"\(string)\" />"
    }
    
    func printFooter(footer:[String]){
        if footer.count > 0 {
            self.printNormal(message: "")
            for line in footer{
                let msg = removeIllegalCharacters(message: line)
                xml += NEWLINE + "<printNormal  operator=\"1\" font=\"\(font)\" data=\"\(msg)\" />"
            }
        }
    }
    
    func printHeader(header:[String]){
        for line in header{
            let msg = removeIllegalCharacters(message: line)
            xml += NEWLINE + "<printNormal  operator=\"1\" font=\"\(font)\" data=\"\(msg)\" />"
        }
    }
    
    func displayText(description: String){
        let desc = removeIllegalCharacters(message: description)
        xml += NEWLINE + "<displayText  operator=\"1\" data=\"\(desc)\" />"
    }
    
    func printBarcodeAsQRCode(barcode: String){
        xml += NEWLINE + "<printBarCode operator=\"1\" qRCodeAlignment=\"1\" qRCodeSize =\"5\" qRCodeErrorCorrection=\"0\" codeType=\"QRCODE2\" code=\"\(barcode)\" />"
    }
    
    func printBarcode(barcode: String){
        let position = 901
        var width = 1
        let height = 90
        let hriPos = 2
        let hriFont = "A"
        var barcodeType = "CODE39"
        var barcode = barcode;
        if settings.storeSetupSettings.printerBarcodeType.uppercased() == "CODE128"
        {
            width = 2
            barcodeType = "CODE128"
            barcode = "{A" + barcode;
        }
        
        xml += NEWLINE + "<printBarCode  operator=\"1\" position=\"\(position)\" width=\"\(width)\" height=\"\(height)\" hRIPosition=\"\(hriPos)\" hRIFont=\"\(hriFont)\" codeType=\"\(barcodeType)\" code=\"\(barcode)\" />"
    }

    
    func endNonFiscalReceipt(){
        xml += NEWLINE + "<endNonFiscal operator=\"1\" />"
            + NEWLINE + "</printerNonFiscal>"
            + NEWLINE + "</s:Body>"
            + NEWLINE + "</s:Envelope>"
    }
    
    func removeIllegalCharacters(message: String) -> String{
        var msg = message
        msg = msg.replacingOccurrences(of: "&", with: "&amp;")
        msg = msg.replacingOccurrences(of: "<", with: "&lt;")
        msg = msg.replacingOccurrences(of: ">", with: "&gt;")
        msg = msg.replacingOccurrences(of: "\"", with: "&quot;")
        msg = msg.replacingOccurrences(of: "'", with: "&apos;")
        
        return msg
    }
    
}
class EpsonFiscalPrinter: IPrinter{
    
    var viewController: UIViewController{
        if let topController = UIApplication.shared.keyWindow?.rootViewController {
            if let presentedViewController = topController.presentedViewController {
                return presentedViewController
            }
            return topController
        }
        return UIViewController.init()
    }
    
    
    class PrinterStatus {
        var code: String = ""
        var msg: String = ""
        var isPrinterStateIdle: Bool = false
        var isPaperRollNearEnd: Bool = false
        var reqPrinterReset: Bool = false
        
    }
    
    class PrinterError {
        var code: String = ""
        var msg: String = ""
    }
    
    private func decodePrinterStatus(printerStatusCode: String) -> PrinterStatus{
        let printerStatus = PrinterStatus()
        printerStatus.code = printerStatusCode
        printerStatus.isPrinterStateIdle = true
        
        let newLine = "\n"
        var msgText: String = ""
        
        let bit1 = printerStatusCode[0..<1]
        let bit2 = printerStatusCode[1..<2]
        let bit3 = printerStatusCode[2..<3]
        let bit4 = printerStatusCode[3..<4]
        let bit5 = printerStatusCode[4..<5]
        
        switch bit1 {
        case "0":
            break
        case "2":
            printerStatus.isPaperRollNearEnd = true
            printerStatus.isPrinterStateIdle = true
            msgText += Util.getString("PaperRollNearToEnd") + newLine
            break
        case "3":
            printerStatus.isPrinterStateIdle = false
            msgText += Util.getString("PrinterOffLine") + newLine
            break
        default:
            break
        }
        
        switch bit2 {
        case "0":
            break
        case "1":
            printerStatus.isPrinterStateIdle = true
            msgText += Util.getString("PaperRollNearToEnd") + newLine
            break
        case "2":
            printerStatus.isPrinterStateIdle = false
            msgText += Util.getString("ElectronicJournalNotFormated") + newLine
            break
        case "3":
            printerStatus.isPrinterStateIdle = false
            msgText += Util.getString("ElectronicJournalNotCurrent") + newLine
            break
        case "4":
            printerStatus.isPrinterStateIdle = false
            msgText += Util.getString("ElectronicJournalOtherPrinter") + newLine
            break
        case "5":
            printerStatus.isPrinterStateIdle = false
            msgText += Util.getString("ElectronicJournalCompleted") + newLine
            break
        default:
            break
        }
        
        switch bit3 {
        case "0":
            break
        case "1":
            break
        default:
            break
        }
        
        switch bit4 {
        case "0":
            printerStatus.isPrinterStateIdle = false
            printerStatus.reqPrinterReset = true
            msgText += Util.getString("FiscalReceiptOpen") + newLine
            break
        case "1":
            break
        case "2":
            printerStatus.isPrinterStateIdle = false
            printerStatus.reqPrinterReset = true
            msgText += Util.getString("NonFiscalReceiptOpen") + newLine
            break
        case "3":
            printerStatus.reqPrinterReset = true
            msgText += Util.getString("PaymentPhaseOpen") + newLine
            break
        case "4":
            break
        case "5":
            printerStatus.isPrinterStateIdle = false
            printerStatus.reqPrinterReset = true
            msgText += Util.getString("FiscalReceiptNegativeAmount") + newLine
            break
        case "6":
            break
        case "7":
            printerStatus.isPrinterStateIdle = false
            printerStatus.reqPrinterReset = true
            msgText += Util.getString("WaitingForReceiptClose") + newLine
            break
        case "8":
            printerStatus.isPrinterStateIdle = false
            printerStatus.reqPrinterReset = true
            msgText += Util.getString("FiscalDocOpen") + newLine
            break
        case "A":
            break
        case "B":
            break
        default:
            break
        }

        
        switch bit5 {
        case "0":
            break
        case "1":
            printerStatus.isPrinterStateIdle = false
            printerStatus.reqPrinterReset = true
            msgText += Util.getString("PrinterOperatingXStatus") + newLine
            break
        case "2":
            printerStatus.isPrinterStateIdle = false
            printerStatus.reqPrinterReset = true
            msgText += Util.getString("PrinterOperatingZStatus") + newLine
            break
        case "3":
            printerStatus.isPrinterStateIdle = false
            printerStatus.reqPrinterReset = true
            msgText += Util.getString("PrinterOperatingSStatus") + newLine
            break
        default:
            break
        }
        
        printerStatus.msg = msgText
        
        return printerStatus
    }
    
    private func decodePrinterError(errorCode: String) -> PrinterError{
        let printerError = PrinterError()
        printerError.code = errorCode
        
        switch errorCode {
        case "EPTR_REC_EMPTY":
            printerError.msg = Util.getString("EPTR_REC_EMPTY")
            break
        case "EPTR_CUTTER":
            printerError.msg = Util.getString("EPTR_CUTTER")
            break
        case "EPTR_MECHANICAL":
            printerError.msg = Util.getString("EPTR_MECHANICAL")
            break
        case "EPTR_UNRECOVERABLE":
            printerError.msg = Util.getString("EPTR_UNRECOVERABLE")
            break
        case "EPTR_AUTOMATICAL":
            printerError.msg = Util.getString("EPTR_AUTOMATICAL")
            break
        case "EPTR_TIMEOUT":
            printerError.msg = Util.getString("EPTR_TIMEOUT")
            break
        case "EPTR_BADPORT":
            printerError.msg = Util.getString("EPTR_BADPORT")
            break
        case "PrinterSystemError":
            printerError.msg = Util.getString("PrinterSystemError")
            break
        case "DeviceNotFound":
            printerError.msg = Util.getString("DeviceNotFound")
            break
        case "SchemaError":
            printerError.msg = Util.getString("SchemaError")
            break
        case "NO_DATA", "NO_RAM", "PARSER_ERROR", "LAN_ERROR", "LAN_TIME_OUT", "CONFIGURATION_FILE_ERROR", "INCOMPLETE_FILE", "INVALID_XML_COMMAND":
            printerError.msg = Util.getString("InvalidXMLMessage")
            break
        case "FP_NO_ANSWER":
            printerError.msg = Util.getString("FP_NO_ANSWER")
            break
        case "PRINTER_ERROR":
            printerError.msg = Util.getString("PRINTER_ERROR")
            break
        case "EFT_POS_ERROR":
            printerError.msg = Util.getString("EFT_POS_ERROR")
            break
        default:
            printerError.msg = Util.getString("ErrorNotDecoded")
            break
        }
        
        printerError.msg = String.init(format: "%@ (%@: %@)", printerError.msg, Util.getString("ErrorCode"), printerError.code)
        
        return printerError
    }
    
    public func sendRequest(urlString: String, method: HTTPMethod, JSONString: String, wsCompletionHandler: @escaping (Bool?) -> Void) {
        Util.SetNetworkActivityIndicatorVisibilty(text: Util.getString("Please wait"), visible: true)
        
        Alamofire.request(urlString, method: method, parameters: [:], encoding: JSONString, headers: Defaults.headers ).response(completionHandler: { response in
            
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            
            var utf8Text = ""
            if let data = response.data, let utf8String = String(data: data, encoding: .utf8) {
                utf8Text = utf8String
            }
            
            let success = self.getFiscalPrinterResponse(xmlResponse: utf8Text)
            let printerStatus = self.getFiscalPrinterStatus(xmlResponse: utf8Text)
            State.receiptFiscalNumber = self.getReceiptFiscalNumber(xmlResponse: utf8Text)
            State.zReportNumber = self.getReceiptFiscalZNumber(xmlResponse: utf8Text)
            
            var decodedPrinterStatus: PrinterStatus? = nil
            if printerStatus != ""{
                decodedPrinterStatus = self.decodePrinterStatus(printerStatusCode: printerStatus)
            }
            
            if success == "" {
                wsCompletionHandler(nil)
            }
            else if success == "false" {
                let code = self.getFiscalPrinterCode(xmlResponse: utf8Text)
                let printerError = self.decodePrinterError(errorCode: code)
                var msg = printerError.msg
                
                if let decodedPrinterStatus = decodedPrinterStatus {
                    msg += "\n" + decodedPrinterStatus.msg
                }
                
                Util.GeneralAlertWithAction(viewController: self.viewController, message: msg, generalAction: {
                    wsCompletionHandler(false)
                })
            }
            else{
                if let decodedPrinterStatus = decodedPrinterStatus {
                    if decodedPrinterStatus.isPrinterStateIdle == false{
                        Util.GeneralAlertWithAction(viewController: self.viewController, message: decodedPrinterStatus.msg, generalAction: {
                            wsCompletionHandler(true)
                        })
                    }
                    else{
                        wsCompletionHandler(true)
                    }
                }
                else{
                    wsCompletionHandler(true)
                }
            }
        })
    }
    
    public func sendRequestGetText(urlString: String, method: HTTPMethod, JSONString: String, isLoadingPanelVisible: Bool, wsCompletionHandler: @escaping (String) -> Void) {
        Util.SetNetworkActivityIndicatorVisibilty(text: Util.getString("Please wait"), visible: isLoadingPanelVisible)
        
        Alamofire.request(urlString, method: method, parameters: [:], encoding: JSONString, headers: Defaults.headers ).response(completionHandler: { response in
            
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            
            var utf8Text = ""
            if let data = response.data, let utf8String = String(data: data, encoding: .utf8) {
                utf8Text = utf8String
            }
            
            let success = self.getFiscalPrinterResponse(xmlResponse: utf8Text)
            let printerStatus = self.getFiscalPrinterStatus(xmlResponse: utf8Text)
            State.receiptFiscalNumber = self.getReceiptFiscalNumber(xmlResponse: utf8Text)
            
            var decodedPrinterStatus: PrinterStatus? = nil
            if printerStatus != ""{
                decodedPrinterStatus = self.decodePrinterStatus(printerStatusCode: printerStatus)
            }
            
            if success == "" {
                wsCompletionHandler(utf8Text)
            }
            else if success == "false" {
                let code = self.getFiscalPrinterCode(xmlResponse: utf8Text)
                let printerError = self.decodePrinterError(errorCode: code)
                var msg = printerError.msg
                
                if let decodedPrinterStatus = decodedPrinterStatus {
                    msg += "\n" + decodedPrinterStatus.msg
                }
                
                Util.GeneralAlertWithAction(viewController: self.viewController, message: msg, generalAction: {
                    wsCompletionHandler(utf8Text)
                })
            }
            else{
                if let decodedPrinterStatus = decodedPrinterStatus {
                    if decodedPrinterStatus.isPrinterStateIdle == false{
                        Util.GeneralAlertWithAction(viewController: self.viewController, message: decodedPrinterStatus.msg, generalAction: {
                            wsCompletionHandler(utf8Text)
                        })
                    }
                    else{
                        wsCompletionHandler(utf8Text)
                    }
                }
                else{
                    wsCompletionHandler(utf8Text)
                }
            }
        })
    }
    
    public func isPrinterStateIdle(completionHandler: @escaping (Bool) -> Void){
        var text = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
            + "\n" + "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">"
            + "\n" + "<s:Body>"
        
        text += "<printerCommand>"
            + "\n" +  "<queryPrinterStatus operator=\"\" />"
            + "\n" +  "</printerCommand>"
        
        text += "\n" + "</s:Body>"
            +  "\n" + "</s:Envelope>"
        
        Util.SetNetworkActivityIndicatorVisibilty(text: Util.getString("CheckingPrinterStatus") + "...", visible: true)
        
        Alamofire.request(State.printerUrlString, method: .post, parameters: [:], encoding: text, headers: headers ).response(completionHandler: { response in
            
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            
            if let data = response.data, let utf8Text = String(data: data, encoding: .utf8) {
                print("Data: \(utf8Text)")
                
                let fpStatus = self.getFiscalPrinterStatus(xmlResponse: utf8Text)
                if fpStatus == "" {
                    Util.GeneralAlertWithAction(viewController: self.viewController, message: Util.getString("CannotReadPrinterStatus"), generalAction: {
                        completionHandler(false)
                        return
                    })
                }
                else {
                    var decodedPrinterStatus: PrinterStatus = self.decodePrinterStatus(printerStatusCode: fpStatus)
                    if decodedPrinterStatus.isPrinterStateIdle == false {
                        if decodedPrinterStatus.reqPrinterReset{
                            self.resetPrinter(completionHandler: { statusAfterReset in
                                decodedPrinterStatus = statusAfterReset
                                if decodedPrinterStatus.msg != ""{
                                    Util.GeneralAlertWithAction(viewController: self.viewController, message: decodedPrinterStatus.msg, generalAction: {
                                        completionHandler(decodedPrinterStatus.isPrinterStateIdle)
                                        return
                                    })
                                }
                                else{
                                    completionHandler(decodedPrinterStatus.isPrinterStateIdle)
                                    return
                                }
                            })
                        }
                        else{
                            if decodedPrinterStatus.msg != ""{
                                Util.GeneralAlertWithAction(viewController: self.viewController, message: decodedPrinterStatus.msg, generalAction: {
                                    completionHandler(decodedPrinterStatus.isPrinterStateIdle)
                                    return
                                })
                            }
                            else{
                                completionHandler(decodedPrinterStatus.isPrinterStateIdle)
                                return
                            }
                        }
                    }
                    else{
                        if decodedPrinterStatus.msg != ""{
                            Util.GeneralAlertWithAction(viewController: self.viewController, message: decodedPrinterStatus.msg, generalAction: {
                                completionHandler(true)
                                return
                            })
                        }
                        else{
                            completionHandler(true)
                            return
                        }
                    }
                }
            }
            else{
                completionHandler(false)
                return
            }
        })
    }
    
    private func resetPrinter(completionHandler: @escaping (PrinterStatus) -> Void) {
        var decodedPrinterStatus = PrinterStatus()
        
        var text = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
            + "\n" + "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">"
            + "\n" + "<s:Body>"
        
        text += "<printerCommand>"
            + "\n" +  "<resetPrinter operator=\"\" />"
            + "\n" +  "</printerCommand>"
        
        text += "\n" + "</s:Body>"
            +  "\n" + "</s:Envelope>"
        
        Alamofire.request(State.printerUrlString, method: .post, parameters: [:], encoding: text, headers: headers ).response(completionHandler: { response in
            if let data = response.data, let utf8Text = String(data: data, encoding: .utf8) {
                let printerStatus = self.getFiscalPrinterStatus(xmlResponse: utf8Text)
                if printerStatus != "" {
                    decodedPrinterStatus = self.decodePrinterStatus(printerStatusCode: printerStatus)
                }
                completionHandler(decodedPrinterStatus)
            }
        })
    }
    
    let headers: HTTPHeaders = [
        "Content-Type" : "text/xml"
    ]
    
    private var totalMedicalDevicesValue: Double = 0
    private let FISCALEXPENSETYPE_AD: String = "AD"
    private let FISCALEXPENSETYPE_AA: String = "AA"
    
    public func printWorkOrder(_ workOrder: WorkOrder, completionHandler: @escaping (Bool?) -> Void){
        let rec = XMLWorkOrderNonFiscal()
        
        rec.beginNonFiscal()
        
        rec.printNormal(message: "WorkOrder \(workOrder.OrderNumber)")
        rec.printNormal(message: "\(Util.DateToFullDateString(date: workOrder.CreateTime))")
        
        rec.printNormal(message: Util.getString("Client") + " \(workOrder.contact.FirstName) \(workOrder.contact.LastName)")
        
        if(workOrder.contact.FiscalCode != nil && workOrder.contact.FiscalCode != ""){
            rec.printNormal(message: Util.getString("Fiscal Code") + " \(workOrder.contact.FiscalCode!)")
        }
        rec.printNormal(message: "")
        rec.printCurrency(message: settings.userSettings.currencyId)
        for detail in workOrder.OrderDetail {
            if (detail.ParentOrderDetailId == nil) {
                rec.printNormal(message: "\(detail.ProductName!)  \(Util.DoubleToString(detail.OrderedQuantity)) x \(Util.DoubleToString(detail.GrossUnitValueVatIncluded))" )
                
                if let disc = detail.DiscountValue {
                    if (disc > 0) {
                        rec.printNormal(message: "  " + Util.getString("Discount") + "  \(Util.DoubleToString(disc))" )
                    }
                }
            }
            else {
                // print components as descriptions
                rec.printNormal(message: "  " + detail.ProductName!)
            }
        }
        rec.printNormal(message: Util.getString("TOTAL ORDER") + " \(Util.DoubleToString(workOrder.NetValueVatIncluded))")
        rec.printNormal(message: "")
        rec.printFooter(footer: settings.storeSetupSettings.footerLines)
        rec.printBarcode(barcode: workOrder.Barcode!)
        rec.printNormal(message: "")
        rec.displayText(description:Util.getString("Thank You!"))
        rec.endNonFiscalReceipt()
        print(rec.xml)
        
        self.sendRequest(urlString: State.printerUrlString, method: .post, JSONString: rec.xml, wsCompletionHandler: { result in
            completionHandler(result)
        })
    }
    
    private func getReceiptFiscalNumber(xmlResponse: String) -> Int{
        let xmlParse = SWXMLHash.parse(xmlResponse)
        
        if let receiptFiscalNumberString = xmlParse["soapenv:Envelope"]["soapenv:Body"]["response"]["addInfo"]["fiscalReceiptNumber"].element?.text {
            if let receiptFiscalNumber = Int(receiptFiscalNumberString){
                return receiptFiscalNumber
            }
        }
        return 0
    }
    
    private func getReceiptFiscalZNumber(xmlResponse: String) -> Int{
        let xmlParse = SWXMLHash.parse(xmlResponse)
        
        if let receiptFiscalNumberString = xmlParse["soapenv:Envelope"]["soapenv:Body"]["response"]["addInfo"]["zRepNumber"].element?.text {
            if let receiptFiscalNumber = Int(receiptFiscalNumberString){
                return receiptFiscalNumber
            }
        }
        return 0
    }
    
    private func getFiscalPrinterStatus(xmlResponse: String) -> String{
        let xmlParse = SWXMLHash.parse(xmlResponse)
        
        if let printerStatus = xmlParse["soapenv:Envelope"]["soapenv:Body"]["response"]["addInfo"]["printerStatus"].element?.text {
            return printerStatus
        }
        
        if let fpStatus = xmlParse["soapenv:Envelope"]["soapenv:Body"]["response"]["addInfo"]["fpStatus"].element?.text {
            return fpStatus
        }
        
        return ""
    }
    
    private func getFiscalPrinterResponse(xmlResponse: String) -> String{
        let xmlParse = SWXMLHash.parse(xmlResponse)
        
        if let response = xmlParse["soapenv:Envelope"]["soapenv:Body"]["response"].element?.attribute(by: "success")?.text {
            return response
        }
        return ""
    }
    
    private func getFiscalPrinterCode(xmlResponse: String) -> String{
        let xmlParse = SWXMLHash.parse(xmlResponse)
        
        if let printerCode = xmlParse["soapenv:Envelope"]["soapenv:Body"]["response"].element?.attribute(by: "code")?.text {
            return printerCode
        }
        return ""
    }
    
    public func printShoppingCart(_ cart: ShoppingCart, completionHandler: @escaping (Bool?) -> Void) {
        let rec = XMLReceiptFiscalPrinter()
        var additionalDescriptionInBodyIndex = 0
        var additionalRowBeforeMFIndex = 0
        rec.beginFiscalReceipt()
        
        self.PrintProduct(cart, rec, &additionalDescriptionInBodyIndex)
        
        rec.printRecSubtotalAdjustment(cart: cart)
        
        rec.printRecMessage(message: "", messageType: .additionalDescriptionInBody, index: &additionalDescriptionInBodyIndex)
        
        rec.printBarcode(barcode: State.transactionBarcode)
        
        if let lotteryCode = State.lotteryCode, lotteryCode.isEmpty == false, State.isLotteryActive {
            rec.sendLotteryCode(code: lotteryCode)
        }
        
        rec.printRecTotal(payments: cart.payments, index: 0)
        
        rec.printRecMessage(message: "", messageType: .additionalRowBeforeMF, index: &additionalRowBeforeMFIndex)
        
        rec.printRecMessage(message: "Tk. \(State.newTransactionNumber) / POS Mobile \(State.cashRegister)", messageType: .additionalRowBeforeMF, index: &additionalRowBeforeMFIndex)
        
        rec.printRecMessage(message: "", messageType: .additionalRowBeforeMF, index: &additionalRowBeforeMFIndex)
        
        self.addFidelityCardTrailerMessagesToList(rec: rec, cart: cart, index: &additionalRowBeforeMFIndex)
        
        self.addFiscalCodeTrailerMessagesToList(rec: rec, index: &additionalRowBeforeMFIndex)
        
        self.addGiftCardTrailerMessagesToList(rec: rec, cart: cart, index: &additionalRowBeforeMFIndex)
        
        if settings.storeSetupSettings.isOpticalClient && State.contactFiscalCodeForTransaction != nil && State.contactFiscalCodeForTransaction != ""{
            if State.isLotteryActive == false || State.lotteryCode == nil || State.lotteryCode == "" {
            
                if cart.allowSendToHealthInsurance == false && settings.userSettings.countryCode == "ITA"{
                    self.AddTSTrailerMessage(rec: rec, index: &additionalRowBeforeMFIndex)
                }
                self.calculateMedicalDeviceTotal(cart: cart)
                self.addMedicalDeviceTotalsMessagesToList(rec: rec, index: &additionalRowBeforeMFIndex)
            }
        }
        
        rec.printRecFooter(footer: settings.storeSetupSettings.footerLines, messageType: .additionalRowBeforeMF, index: &additionalRowBeforeMFIndex)
        
        rec.displayText(description: Util.getString("Thank You!"))
        rec.endFiscalReceipt()
        print(rec.xml)
        
        self.sendRequest(urlString: State.printerUrlString, method: .post, JSONString: rec.xml, wsCompletionHandler: { result in
            completionHandler(result)
        })
    }
    
    func printEffectVoucher(effectVoucher: EffectVoucher, completionHandler: @escaping (Bool?) -> Void) {
        let rec = XMLWorkOrderNonFiscal()
        rec.beginNonFiscal()

        let messages = effectVoucher.printableTicketLines
        
        for msg in messages {
            if let range = msg.range(of: "Barcode:(\\S+)", options: .regularExpression) {
                let barcodeMatch = msg[range]
                let barcode = String(barcodeMatch).replacingOccurrences(of: "Barcode:", with: "")
                rec.printBarcode(barcode: barcode)
            } else {
                rec.printNormal(message: msg)
            }
        }
        

        rec.endNonFiscalReceipt()

        print(rec.xml)

        self.sendRequest(urlString: State.printerUrlString, method: .post, JSONString: rec.xml, wsCompletionHandler: { result in
            completionHandler(result)
        })
    }


    internal func PrintProduct(_ cart: ShoppingCart, _ rec: XMLReceiptFiscalPrinter, _ additionalDescriptionInBodyIndex: inout Int) {
        for cartItem in cart.cartItems {
            var description = ""
            if settings.storeSetupSettings.isOpticalClient && cartItem.barcodeInfo.MedicalDevice != nil && cartItem.barcodeInfo.MedicalDevice == true{
                description = "(DM) "
            }
            description.append(cartItem.barcodeInfo.Name)
            rec.printRecItem(description: description, quantity: cartItem.Quantity, unitPrice: cartItem.GrossUnitValue, department: cartItem.barcodeInfo.FiscalPrinterDepartment!)
            
            var discountDescription = ""
            let discountKeyword = Util.getString("Discount") + " "
            if cartItem.DiscountValue > 0 {
                if let effects = cartItem.Effects{
                    if effects.count > 0 {
                        let effect = effects[0]
                        switch effect.effectCategory{
                        case "PDV":
                            discountDescription = Util.getString("Value")
                            break
                        case "PD%":
                            discountDescription = "\(Util.DoubleToStringWithPointSeparator(effect.rowDiscountPercent))%"
                            break
                        case "PPC":
                            discountDescription = Util.getString("PriceCut")
                            break
                        default:
                            discountDescription = Util.getString("Value")
                            break
                        }
                    }
                }
                else{
                    discountDescription = discountKeyword + discountDescription + " \(Util.DoubleToStringWithPointSeparator(cartItem.DiscountPercentage))%"
                }
                
                rec.printRecItemAdjustment(description: discountDescription, adjustmentType: 0, amount: cartItem.DiscountValue)
            }
            
            rec.printRecMessage(message: cartItem.barcodeInfo.Product, messageType: .additionalDescriptionInBody, index: &additionalDescriptionInBodyIndex)
        }
    }
    
    internal func replaceCharacters(text: String, startIndexOffsetBy: Int, endIndexOffsetBy: Int, with: String) -> String{
        if text.count <= endIndexOffsetBy {
            return text
        }
        
        var text = text
        let count: Int = text.count - endIndexOffsetBy
        
        let start = text.index(text.startIndex, offsetBy: startIndexOffsetBy)
        let end = text.index(text.startIndex, offsetBy: count)

        let star: String = String.init(repeating: with, count: count)
        text.replaceSubrange(start..<end, with: star)
        return text
    }
    
    internal func addFidelityCardTrailerMessagesToList(rec: XMLReceiptFiscalPrinter, cart: ShoppingCart, index: inout Int) {
        var addNewLine: Bool = false
        if let fidelityCard = cart.fidelityCard{
            rec.printRecMessage(message: "-----------------------------------", messageType: .additionalRowBeforeMF, index: &index)
            let cardBarcode = self.replaceCharacters(text: fidelityCard.cardBarcode, startIndexOffsetBy: 0, endIndexOffsetBy: 4, with: "*")
            rec.printRecMessage(message: Util.getString("CARD") + ": \(cardBarcode)", messageType: .additionalRowBeforeMF, index: &index)
            
            addNewLine = true
        }
        
        if let _ = cart.contact, let fidelityCard = cart.fidelityCard, let cardInfo = fidelityCard.cardInfo {
            /*
            COMMENTED 2020-12-11 - IN CEX s-a decis sa nu se mai tipareasca numele din motive de privacy pentru loterie.
            rec.printRecMessage(message: Util.getString("Name") + ": \(contact.getFullName())", messageType: .additionalRowBeforeMF, index: &index)
            */
            
            let previousPointsText = Util.getString("Saldo Punti Precedente")
            let previousPointsValue = "\(cardInfo.availablePointsAmount)"
            let previousPointsNewLine = previousPointsText.padding(toLength: 35 - previousPointsValue.count, withPad: " ", startingAt: 0) + previousPointsValue
        
            let acumulatedPointsText = Util.getString("Punti maturati")
            var acumulatedPointsValue = cart.gainedPoints
            for payment in cart.payments{
                if let voucher = payment.voucherInfo{
                    if settings.storeSetupSettings.clientName.uppercased() == "NAU!" && voucher.generator.voucherType == VoucherType.FIN && voucher.generator.categoryCode == VoucherCategory.GFT {
                        acumulatedPointsValue -= Int(voucher.amount)
                    }
                }
            }
            
            let acumulatedPointsNewLine = acumulatedPointsText.padding(toLength: 35 - acumulatedPointsValue.description.count, withPad: " ", startingAt: 0) + acumulatedPointsValue.description
            
            rec.printRecMessage(message: "-----------------------------------", messageType: .additionalRowBeforeMF, index: &index)
            if settings.storeSetupSettings.ECRMPrintPreviousPointsBalance {
                rec.printRecMessage(message: previousPointsNewLine, messageType: .additionalRowBeforeMF, index: &index)
            }
            rec.printRecMessage(message: acumulatedPointsNewLine, messageType: .additionalRowBeforeMF, index: &index)
            if settings.storeSetupSettings.ECRMFidelityMessage != ""{
                rec.printRecFooter(footer: settings.storeSetupSettings.ECRMFidelityMessageLines, messageType: .additionalRowBeforeMF, index: &index)
            }
            rec.printRecMessage(message: "-----------------------------------", messageType: .additionalRowBeforeMF, index: &index)
            
            addNewLine = true
        }
        
        if addNewLine {
            rec.printRecMessage(message: "", messageType: .additionalRowBeforeMF, index: &index)
        }
    }
    
    internal func addFiscalCodeTrailerMessagesToList(rec: XMLReceiptFiscalPrinter, index: inout Int) {
        if State.isLotteryActive && State.lotteryCode != nil && State.lotteryCode != "" {
            return
        }
        
        if(State.contactFiscalCodeForTransaction != nil && State.contactFiscalCodeForTransaction != "") {
            rec.printRecMessage(message: "************************************", messageType: .additionalRowBeforeMF, index: &index)
            rec.printRecMessage(message: Util.getString("PrintTicketFiscalCode"), messageType: .additionalRowBeforeMF, index: &index)
            rec.printRecMessage(message: "*********" + " \((State.contactFiscalCodeForTransaction)!) " + "*********", messageType: .additionalRowBeforeMF, index: &index)
            
            rec.printRecMessage(message: "", messageType: .additionalRowBeforeMF, index: &index)
        }
    }
    
    internal func addGiftCardTrailerMessagesToList(rec: XMLReceiptFiscalPrinter, cart: ShoppingCart, index: inout Int) {
        var voucherCount = 0
        for payment in cart.payments{
            if let voucher = payment.voucherInfo{
                if voucher.generator.categoryCode == VoucherCategory.GFT && voucher.voucherAction == .Redemption{
                    voucherCount += 1
                    let messages = self.getGiftCardTrailerMessage(voucher: voucher)
                    for message in messages{
                        rec.printRecMessage(message: message, messageType: .additionalRowBeforeMF, index: &index)
                    }
                }
            }
        }
        if voucherCount > 0 {
            rec.printRecMessage(message: "", messageType: .additionalRowBeforeMF, index: &index)
        }
    }
    
    internal func addWorkOrderGiftCardTrailerMessagesToList(rec: XMLReceiptFiscalPrinter, workOrder: WorkOrder, index: inout Int) {
        var voucherCount = 0
        for payment in workOrder.workOrderSale.payments{
            if let voucher = payment.voucherInfo{
                if voucher.generator.categoryCode == VoucherCategory.GFT && voucher.voucherAction == .Redemption{
                    voucherCount += 1
                    let messages = self.getGiftCardTrailerMessage(voucher: voucher)
                    for message in messages{
                        rec.printRecMessage(message: message, messageType: .additionalRowBeforeMF, index: &index)
                    }
                }
            }
        }
        if voucherCount > 0 {
            rec.printRecMessage(message: "", messageType: .additionalRowBeforeMF, index: &index)
        }
    }
    
    internal func getGiftCardTrailerMessage(voucher: VoucherInfo) -> [String]{
        var messages: [String] = []
        
        messages.append("\n")
        messages.append("**************************")
        
        let voucherCodeToPrint = self.replaceCharacters(text: voucher.voucherCode, startIndexOffsetBy: 0, endIndexOffsetBy: 4, with: "*")
        messages.append(String.init(format: Util.getString("VoucherCardInfo"), voucherCodeToPrint))
        
        var transactionTypeToPrint = ""
        if voucher.voucherAction == .Redemption{
            let remainingAmount = voucher.initialAmount - voucher.amount
            
            messages.append(String.init(format: Util.getString("VoucherInitialAmount"), settings.userSettings.currencyId, Util.DoubleToString(voucher.initialAmount)))
            messages.append(String.init(format: Util.getString("VoucherCreditUsed"), settings.userSettings.currencyId, Util.DoubleToString(voucher.amount)))
            messages.append(String.init(format: Util.getString("VoucherCreditLeft"), settings.userSettings.currencyId, Util.DoubleToString(remainingAmount)))
            transactionTypeToPrint = Util.getString("VoucherRedemption")
        }
        else if voucher.voucherAction == .Creation{
            let initialAmount: Double = 0
            let remainingAmount = voucher.initialAmount + voucher.amount
            
            messages.append(String.init(format: Util.getString("VoucherInitialAmount"), settings.userSettings.currencyId, Util.DoubleToString(initialAmount)))
            messages.append(String.init(format: Util.getString("VoucherCreditLoaded"), settings.userSettings.currencyId, Util.DoubleToString(voucher.amount)))
            messages.append(String.init(format: Util.getString("VoucherCreditLeft"), settings.userSettings.currencyId, Util.DoubleToString(remainingAmount)))
            transactionTypeToPrint = Util.getString("VoucherActivation")
        }
        
        if voucher.transactionNumber.isEmpty == false{
            messages.append(String.init(format: Util.getString("VoucherTransactionNumber"), voucher.transactionNumber))
        }
        
        if transactionTypeToPrint.isEmpty == false{
            messages.append(String.init(format: Util.getString("VoucherTransactionType"), transactionTypeToPrint.uppercased()))
        }
        
        if voucher.resultCode.isEmpty == false && voucher.resultMessage.isEmpty == false{
            messages.append(String.init(format: Util.getString("VoucherTransactionStatus"), voucher.resultCode.uppercased(), voucher.resultMessage.uppercased()))
        }
        
        messages.append("**************************")
        
        return messages
    }
    
    internal func calculateMedicalDeviceTotal(cart: ShoppingCart){
        self.totalMedicalDevicesValue = 0
        for item in cart.cartItems{
            if (item.fiscalExpenseTypeId != nil && (item.fiscalExpenseTypeCode == FISCALEXPENSETYPE_AD || item.fiscalExpenseTypeCode == FISCALEXPENSETYPE_AA)){
                self.totalMedicalDevicesValue += item.NetRowValue
            }
        }
        self.totalMedicalDevicesValue -= cart.getTotalDistributedDiscount()
    }
    
    
    internal func AddTSTrailerMessage(rec: XMLReceiptFiscalPrinter, index: inout Int)
    {
        rec.printRecMessage(message: "\n", messageType: .additionalRowBeforeMF, index:  &index)
        rec.printRecMessage(message: "Il paziente si oppone alla", messageType: .additionalRowBeforeMF, index:  &index)
        rec.printRecMessage(message: "trasmissione al Sistema TS ai sensi", messageType: .additionalRowBeforeMF, index:  &index)
        rec.printRecMessage(message: "dell'art.3 del DM 31-7-2015", messageType: .additionalRowBeforeMF, index:  &index)
    }

    
    internal func addMedicalDeviceTotalsMessagesToList(rec: XMLReceiptFiscalPrinter, index: inout Int) {
        if (self.totalMedicalDevicesValue != 0){
            rec.printRecMessage(message: "\n", messageType: .additionalRowBeforeMF, index:  &index)
            rec.printRecMessage(message: "------------------------------", messageType: .additionalRowBeforeMF, index: &index)
            rec.printRecMessage(message: "(DM)=DISPOSITIVO MEDICO", messageType: .additionalRowBeforeMF, index: &index)
            rec.printRecMessage(message: "Prod. con marcatura CE", messageType: .additionalRowBeforeMF, index: &index)
            rec.printRecMessage(message: "dir. 93/42/CEE e ss.mm", messageType: .additionalRowBeforeMF, index: &index)
            rec.printRecMessage(message: "------------------------------", messageType: .additionalRowBeforeMF, index: &index)
            rec.printRecMessage(message: "Valore tot. detraibile nella", messageType: .additionalRowBeforeMF, index: &index)
            rec.printRecMessage(message: String.init(format: "dich. dei redditi: %@ %@", Util.DoubleToString(self.totalMedicalDevicesValue), settings.userSettings.currencyId), messageType: .additionalRowBeforeMF, index: &index)
            rec.printRecMessage(message: "------------------------------", messageType: .additionalRowBeforeMF, index:  &index)
        }
    }
    
    public func printWorkOrderFiscal(_ workOrder: WorkOrder, parentId:String?, completionHandler: @escaping (Bool?) -> Void){
        let rec = XMLReceiptFiscalPrinter()
        var additionalDescriptionInBodyIndex = 0
        var additionalRowBeforeMFIndex = 0
        var valueToPay:Double = 0.00
    
        rec.beginFiscalReceipt()

        if parentId != nil{
            for detail in workOrder.OrderDetail {
                if let countryVat = getFiscalPrinterDepartment(vatId: detail.VatId){
                    detail.FiscalPrinterDepartment = countryVat
                }
                else{
                    completionHandler(false)
                    break
                }
                
                if (detail.OrderDetailId == parentId) {
                    
                    var description = ""
                    if settings.storeSetupSettings.isOpticalClient && detail.MedicalDevice != nil && detail.MedicalDevice == true{
                        description = "(DM) "
                    }
                    if let productName = detail.ProductName{
                        description.append(productName)
                    }
                    
                    if detail.ParentOrderDetailId == nil && detail.getNumberOfChild() > 0 && settings.storeSetupSettings.isOpticalClient{
                        // print wo parent as description and components as item
                        rec.printRecMessage(message: "*** " + description, messageType: .additionalDescriptionInBody, index: &additionalDescriptionInBodyIndex)
                    }
                    else{
                        rec.printRecItem(description: description, quantity: detail.OrderedQuantity, unitPrice: detail.GrossUnitValueVatIncluded, department: detail.FiscalPrinterDepartment!)
                    
                        if let disc = detail.DiscountValue {
                            if (disc > 0) {
                                rec.printRecItemAdjustment(description: "" + Util.getString("Discount"), adjustmentType: 0, amount: disc)
                            }
                        }
                    }
                    
                    valueToPay += detail.GrossUnitValueVatIncluded
                }
                else if detail.ParentOrderDetailId == parentId{
                    // print components as item
                    var description = ""
                    if settings.storeSetupSettings.isOpticalClient && detail.MedicalDevice != nil && detail.MedicalDevice == true{
                        description = "(DM) "
                    }
                    if let productName = detail.ProductName{
                        description.append(productName)
                    }
                    
                    rec.printRecItem(description: "" + description, quantity: detail.OrderedQuantity, unitPrice: detail.GrossUnitValueVatIncluded, department: detail.FiscalPrinterDepartment!)
                    
                    if let disc = detail.DiscountValue {
                        if (disc > 0) {
                            rec.printRecItemAdjustment(description: "" + Util.getString("Discount"), adjustmentType: 0, amount: disc)
                        }
                    }
                    
                    if let productCode = detail.ProductCode{
                        rec.printRecMessage(message: "" + productCode, messageType: .additionalDescriptionInBody, index: &additionalDescriptionInBodyIndex)
                    }
                }
            }
        }

        rec.printRecMessage(message: "", messageType: .additionalDescriptionInBody, index: &additionalDescriptionInBodyIndex)
        
        if let lotteryCode = State.lotteryCode, lotteryCode.isEmpty == false, State.isLotteryActive {
            rec.sendLotteryCode(code: lotteryCode)
        }
        
        rec.printRecTotal(payments: workOrder.payments, index: 0)
        
        rec.printRecMessage(message: "", messageType: .additionalRowBeforeMF, index: &additionalRowBeforeMFIndex)
        
        rec.printRecMessage(message: "TK. \(State.newTransactionNumber) / POS Mobile \(State.cashRegister)", messageType: .additionalRowBeforeMF, index: &additionalRowBeforeMFIndex)
        
        rec.printRecMessage(message: "", messageType: .additionalRowBeforeMF, index: &additionalRowBeforeMFIndex)
        
        self.addFidelityCardTrailerMessagesToList(rec: rec, workOrder: workOrder, index: &additionalRowBeforeMFIndex)
        
        self.addWorkOrderFiscalCodeTrailerMessagesToList(rec: rec, workOrder: workOrder, index: &additionalRowBeforeMFIndex)
        
        self.addWorkOrderGiftCardTrailerMessagesToList(rec: rec, workOrder: workOrder, index: &additionalRowBeforeMFIndex)
        
        if settings.storeSetupSettings.isOpticalClient && workOrder.contact.FiscalCode != nil && workOrder.contact.FiscalCode != ""{
            if State.isLotteryActive == false || State.lotteryCode == nil || State.lotteryCode == "" {
                if workOrder.AllowSendToHealthInsurance == false && settings.userSettings.countryCode == "ITA"{
                    self.AddTSTrailerMessage(rec: rec, index: &additionalRowBeforeMFIndex)
                }
                
                self.calculateMedicalDeviceTotal(workOder: workOrder, parentId: parentId)
                if self.totalMedicalDevicesValue > 0 {
                    self.addMedicalDeviceTotalsMessagesToList(rec: rec, index: &additionalRowBeforeMFIndex)
                }
            }
        }
        
        rec.printRecFooter(footer: settings.storeSetupSettings.footerLines, messageType: .additionalRowBeforeMF, index: &additionalRowBeforeMFIndex)
        
        rec.printBarcode(barcode: State.transactionBarcode)
        
        rec.displayText(description: Util.getString("Thank You!"))
        rec.endFiscalReceipt()
        print(rec.xml)
    
        self.sendRequest(urlString: State.printerUrlString, method: .post, JSONString: rec.xml, wsCompletionHandler: { result in
            completionHandler(result)
        })
    }
    
    
    internal func addFidelityCardTrailerMessagesToList(rec: XMLReceiptFiscalPrinter, workOrder: WorkOrder, index: inout Int) {
        var addNewLine: Bool = false
        if let fidelityCard = workOrder.contact.FidelityCard{
            rec.printRecMessage(message: "-----------------------------------", messageType: .additionalRowBeforeMF, index: &index)
            let cardBarcode = self.replaceCharacters(text: fidelityCard.cardBarcode, startIndexOffsetBy: 0, endIndexOffsetBy: 4, with: "*")
            rec.printRecMessage(message: Util.getString("CARD") + ": \(cardBarcode)", messageType: .additionalRowBeforeMF, index: &index)
            
            addNewLine = true
        }
        
        if let fidelityCard = workOrder.contact.FidelityCard, let cardInfo = fidelityCard.cardInfo {
            /*
            COMMENTED 2020-12-11 - IN CEX s-a decis sa nu se mai tipareasca numele din motive de privacy pentru loterie.
            rec.printRecMessage(message: Util.getString("Name") + ": \(contact.getFullName())", messageType: .additionalRowBeforeMF, index: &index)
            */
            
            let previousPointsText = Util.getString("Saldo Punti Precedente")
            let previousPointsValue = "\(cardInfo.availablePointsAmount)"
            let previousPointsNewLine = previousPointsText.padding(toLength: 35 - previousPointsValue.count, withPad: " ", startingAt: 0) + previousPointsValue
        
            let acumulatedPointsText = Util.getString("Punti maturati")
            let acumulatedPointsValue = workOrder.gainedPoints
            
//            for payment in workOrder.workOrderSale.payments{
//                if let voucher = payment.voucherInfo{
//                    if settings.storeSetupSettings.clientName.uppercased() == "NAU!" && voucher.generator.voucherType == VoucherType.FIN && voucher.generator.categoryCode == VoucherCategory.GFT {
//                        acumulatedPointsValue -= Int(voucher.amount)
//                    }
//                }
//            }
            
            let acumulatedPointsNewLine = acumulatedPointsText.padding(toLength: 35 - acumulatedPointsValue.description.count, withPad: " ", startingAt: 0) + acumulatedPointsValue.description
            
            rec.printRecMessage(message: "-----------------------------------", messageType: .additionalRowBeforeMF, index: &index)
            if settings.storeSetupSettings.ECRMPrintPreviousPointsBalance {
                rec.printRecMessage(message: previousPointsNewLine, messageType: .additionalRowBeforeMF, index: &index)
            }
            rec.printRecMessage(message: acumulatedPointsNewLine, messageType: .additionalRowBeforeMF, index: &index)
            if settings.storeSetupSettings.ECRMFidelityMessage != ""{
                rec.printRecFooter(footer: settings.storeSetupSettings.ECRMFidelityMessageLines, messageType: .additionalRowBeforeMF, index: &index)
            }
            rec.printRecMessage(message: "-----------------------------------", messageType: .additionalRowBeforeMF, index: &index)
            
            addNewLine = true
        }
        
        if addNewLine {
            rec.printRecMessage(message: "", messageType: .additionalRowBeforeMF, index: &index)
        }
    }
    
    private func addWorkOrderFiscalCodeTrailerMessagesToList(rec: XMLReceiptFiscalPrinter, workOrder: WorkOrder, index: inout Int) {
        if State.isLotteryActive && State.lotteryCode != nil && State.lotteryCode != "" {
            return
        }
        
        if(workOrder.contact.FiscalCode != nil && workOrder.contact.FiscalCode != ""){
            rec.printRecMessage(message: "************************************", messageType: .additionalRowBeforeMF, index: &index)
            rec.printRecMessage(message: Util.getString("PrintTicketFiscalCode"), messageType: .additionalRowBeforeMF, index: &index)
            rec.printRecMessage(message: "*********" + " \(workOrder.contact.FiscalCode!) " + "*********", messageType: .additionalRowBeforeMF, index: &index)
            
            rec.printRecMessage(message: "", messageType: .additionalRowBeforeMF, index: &index)
        }
    }
    
    private func calculateMedicalDeviceTotal(workOder: WorkOrder, parentId: String?){
        self.totalMedicalDevicesValue = 0
        
        guard let parentId = parentId else{
            return
        }
        
        guard let orderDetail = workOder.getOrderDetailByKey(orderDetailId: parentId) else{
            return
        }
        
        let components = orderDetail.getComponentsForDetailByKey()
        if components.count > 0 {
            for component in components{
                if(component.FiscalExpenseType?.fiscalExpenseTypeId != nil && (component.FiscalExpenseType?.code == FISCALEXPENSETYPE_AD || component.FiscalExpenseType?.code == FISCALEXPENSETYPE_AA)){
                    self.totalMedicalDevicesValue += component.NetRowValueVatIncluded
                }
            }
        }
        else{
            if orderDetail.OrderDetailId == parentId{
                if(orderDetail.FiscalExpenseType?.fiscalExpenseTypeId != nil && (orderDetail.FiscalExpenseType?.code == FISCALEXPENSETYPE_AD || orderDetail.FiscalExpenseType?.code == FISCALEXPENSETYPE_AA)){
                    self.totalMedicalDevicesValue += orderDetail.NetRowValueVatIncluded
                }
            }
        }
    }
    
    func getFiscalPrinterDepartment(vatId: Int?) -> Int?{
        if let countryVats = State.countryVats{
            for countryVat in countryVats{
                if countryVat.vatId == vatId{
                    return countryVat.fiscalPrinterDepartment
                }
            }
        }
        return nil
    }
    
    func printPaidAdvanceNonFiscal(_ workOrder: WorkOrder, completionHandler: @escaping (Bool?) -> Void){
        var actionSucceed = [Bool?]()
        for copyNr in 1...2{
            let rec = XMLWorkOrderNonFiscal()
            rec.beginNonFiscal()
            rec.printNormal(message: Util.getString("ADVANCE NR.") + " \(State.newTransactionNumber)")
            rec.printNormal(message: "")
            let formatter = DateFormatter()
            formatter.dateFormat = "dd/MM/yyyy"
            rec.printNormal(message: Util.getString("Date") + ": \(formatter.string(from: workOrder.CreateTime))")
            rec.printNormal(message: Util.getString("Order") + ": \(workOrder.OrderNumber)")
            
            rec.printNormal(message: Util.getString("Client") + ": \(workOrder.contact.getFullName())")
            
            if let fiscalCode = workOrder.contact.FiscalCode{
                rec.printNormal(message: Util.getString("PrintAdvanceFiscalCode") + ": \(fiscalCode)")
            }
            rec.printNormal(message: "")
            if let currency = workOrder.CurrencyId{
                rec.printNormal(message: Util.getString("Advance value") + ": \(Util.DoubleToString(workOrder.AdvanceRequiredValue!))" + " \(currency)")
                rec.printNormal(message: Util.getString("Total order") + ": \(Util.DoubleToString(workOrder.NetValueVatIncluded))" + " \(currency)")
            }
            else{
                rec.printNormal(message: Util.getString("Advance value") + ": \(Util.DoubleToString(workOrder.AdvancePayedValue!))" + " \(settings.userSettings.currencyId)")
                rec.printNormal(message: Util.getString("Total order") + ": \(Util.DoubleToString(workOrder.NetValueVatIncluded))" + " \(settings.userSettings.currencyId)")
            }
            
            if copyNr == 1{
                rec.printFooter(footer: settings.storeSetupSettings.advanceMessageLines1)
                rec.printFooter(footer: settings.storeSetupSettings.advanceMessageLines2)
                rec.printNormal(message: "")
                rec.printNormal(message: Util.getString("CustomerCopy"))
            }
            else{
                rec.printNormal(message: "")
                rec.printNormal(message: Util.getString("StoreCopy"))
            }
            rec.endNonFiscalReceipt()
            print(rec.xml)
            
            self.sendRequest(urlString: State.printerUrlString, method: .post, JSONString: rec.xml, wsCompletionHandler: { result in
                actionSucceed.append(result)
                
                if(actionSucceed.count == 2){
                    if((actionSucceed[0] == true) && (actionSucceed[1]) == true){
                        completionHandler(true)
                    }
                    else{
                        completionHandler(false)
                    }
                }
            })
        }
    }
    
    func printShoppingCartGiftReceipt(receipt: Receipt, movements: [Movement], receiptPayments: [ReceiptPayment], completionHandler: @escaping (Bool?) -> Void){
        let rec = XMLWorkOrderNonFiscal()
        rec.beginNonFiscal()
        for movement in movements {
            if let barcode = movement.barcodeInfo.Barcode{
                rec.printNormal(message: barcode)
            }
            rec.printNormal(message: movement.barcodeInfo.Name)
            rec.printNormal(message: "")
        }
    
        rec.printNormal(message: "")
        rec.printFooter(footer: settings.storeSetupSettings.footerLines)
        rec.printNormal(message: "")
        rec.printBarcode(barcode: receipt.receiptBarcode!)
        rec.printNormal(message: "")
        rec.printNormal(message: "Tk. \(receipt.receiptNumber!) / POS Mobile \(receipt.cashRegister!)")
        rec.printNormal(message: Util.DateToFullDateString(date: receipt.createTime))
        rec.displayText(description: Util.getString("Thank You!"))
        rec.endNonFiscalReceipt()
        print(rec.xml)
        
        self.sendRequest(urlString: State.printerUrlString, method: .post, JSONString: rec.xml, wsCompletionHandler: { result in
            completionHandler(result)
        })
    }
    
    func printIngenicoResponse(response: PTTransactionResult, completionHandler: @escaping (Bool?) -> Void){
        var actionSucceed: [Bool?] = [Bool?]()
        let ticketRows = response.ticket?.components(separatedBy: "\r\n")
        for copyNr in 1...2{
            let rec = XMLWorkOrderNonFiscal()
            rec.beginNonFiscal()
            rec.printNormal(message: "")
            if copyNr == 1{
                rec.printNormal(message: Util.getString("***STORE COPY***"))
            }
            else{
                rec.printNormal(message: Util.getString("***CLIENT COPY***"))
            }
            rec.printNormal(message: "")
            for row in ticketRows!{
                rec.printNormal(message: row)
            }
            rec.printNormal(message: "")
            if copyNr == 1{
                rec.printNormal(message: Util.getString("Customer signature"))
                rec.printNormal(message: "")
            }
            rec.printNormal(message: "Tk \(State.newTransactionNumber) POS Mobile \(State.cashRegister)")
            rec.printNormal(message: Util.DateToFullDateString(date: Date()))
            rec.printNormal(message: "")
            rec.endNonFiscalReceipt()
            
            self.sendRequest(urlString: State.printerUrlString, method: .post, JSONString: rec.xml, wsCompletionHandler: { result in
                actionSucceed.append(result)
                
                if(actionSucceed.count == 2){
                    if((actionSucceed[0] == true) && (actionSucceed[1]) == true){
                        completionHandler(true)
                    }
                    else{
                        completionHandler(false)
                    }
                }
            })
        }
    }
    
    func printIngenicoErrorResponse(response: PTTransactionResult, amount: Double, completionHandler: @escaping (Bool?) -> Void){
        let rec = XMLWorkOrderNonFiscal()
        rec.beginNonFiscal()
        rec.printNormal(message: "")
        rec.printNormal(message: "ACQUISTO")
        rec.printNormal(message: "DATA \(Util.DateToFullDateString(date: Date()))")
        rec.printNormal(message: "TML: \(settings.TerminalId)")
        rec.printNormal(message: "PAN: \(response.pan ?? "")")
        rec.printNormal(message: "SCAD. xx/xx/xx")
        rec.printNormal(message: "STAN: \(response.stan ?? "")")
        rec.printNormal(message: "")
        rec.printNormal(message: "\(settings.userSettings.currencyId) \(Util.DoubleToStringWithTwoDecimals(amount))")
        rec.printNormal(message: "")
        rec.printNormal(message: "************************")
        rec.printNormal(message: "\(response.transactionMessage ?? "")")
        rec.printNormal(message: "************************")
        rec.endNonFiscalReceipt()
        
        self.sendRequest(urlString: State.printerUrlString, method: .post, JSONString: rec.xml, wsCompletionHandler: { result in
            completionHandler(result)
        })
    }
    
    func printZReport(completionHandler: @escaping (Bool?) -> Void){
        var xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
            + "\n" + "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">"
            + "\n" + "<s:Body>"
        
        
        xml += "<printerFiscalReport>"
            + "\n" +  "<printZReport operator=\"1\" />"
            + "\n" +  "</printerFiscalReport>"
        
        xml += "\n" + "</s:Body>"
             + "\n" + "</s:Envelope>"
        
        self.sendRequest(urlString: State.printerUrlString, method: .post, JSONString: xml, wsCompletionHandler: { result in
            completionHandler(result)
        })
    }
    
    func getTotalSalesForDepartment(department: Int,completionHandler: @escaping (Double) -> Void){
        var xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
            + "\n" + "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">"
            + "\n" + "<s:Body>"
        
        xml += "<printerCommand>"
            + "\n" +  "<directIO command=\"2014\" data=\"0\(department)\" />"
            + "\n" +  "</printerCommand>"
        
        xml += "\n" + "</s:Body>"
            +  "\n" + "</s:Envelope>"
        
        self.sendRequestGetText(urlString: State.printerUrlString, method: .post, JSONString: xml, isLoadingPanelVisible: true, wsCompletionHandler: { result in
            let xmlParse = SWXMLHash.parse(result)
            
            if let dataResponse = xmlParse["soapenv:Envelope"]["soapenv:Body"]["response"]["addInfo"]["responseData"].element?.text {
                let start = dataResponse.index(dataResponse.startIndex, offsetBy: 11)
                let end = dataResponse.index(start, offsetBy: 9)
                let value = String(dataResponse[start..<end])
                
                let total: Double = Double.init(value)! / 10000
                
                completionHandler(total)
            }
            else{
                completionHandler(0)
            }
        })
    }
    
    func printVoucherMessageNonFiscal(voucherMessage: String, completionHandler: @escaping (Bool?) -> Void) {
        let rec = XMLWorkOrderNonFiscal()
        rec.beginNonFiscal()
        
        let messages = voucherMessage.components(separatedBy: "\n")
        for msg in messages{
            rec.printNormal(message: msg)
        }
        
        rec.endNonFiscalReceipt()
        
        print(rec.xml)
       
        self.sendRequest(urlString: State.printerUrlString, method: .post, JSONString: rec.xml, wsCompletionHandler: { result in
            completionHandler(result)
        })
    }
    
    func getFiscalPrinterSerialNumber(completionHandler: @escaping (String?) -> Void) {
        var serialNumber: String? = nil
        self.getFiscalPrinterDetails { response in
            if let reponseDetails = response{
                var start = reponseDetails.index(reponseDetails.startIndex, offsetBy: 2)
                var end = reponseDetails.index(start, offsetBy: 6)
                let printerNumber = String(reponseDetails[start..<end])
                
                start = reponseDetails.index(reponseDetails.startIndex, offsetBy: 8)
                end = reponseDetails.index(start, offsetBy: 2)
                let printerModel = String(reponseDetails[start..<end])
                
                start = reponseDetails.index(reponseDetails.startIndex, offsetBy: 10)
                end = reponseDetails.index(start, offsetBy: 2)
                let printerManufacturer = String(reponseDetails[start..<end])
                
                self.getPrinterRTType(completionHandler: { rtTypeResponse in
                    if let rtType = rtTypeResponse{
                        serialNumber = printerManufacturer + rtType + printerModel + printerNumber
                    }
                    completionHandler(serialNumber)
                })
            }
            else{
                completionHandler(serialNumber)
            }
        }
    }
    
    func getPrinterRTType(completionHandler: @escaping (String?) -> Void) {
        let cmd  = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
        + "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">"
        + "<s:Body>"
        + "<printerCommand>"
        + "<queryPrinterStatus operator=\"1\" statusType=\"1\" />"
        + "</printerCommand>"
        + "</s:Body>"
        + "</s:Envelope>"
        
        self.sendRequestGetText(urlString: State.printerUrlString, method: .post, JSONString: cmd, isLoadingPanelVisible: false) { text in
            let xmlParse = SWXMLHash.parse(text)
            var rtType: String? = nil
            if let text = xmlParse["soapenv:Envelope"]["soapenv:Body"]["response"]["addInfo"]["rtType"].element?.text {
                rtType = text
            }
            completionHandler(rtType)
        }
    }
    
    func getFiscalPrinterDetails(completionHandler: @escaping (String?) -> Void) {
        let cmd  = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
            + "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">"
            + "<s:Body>"
            + "<printerCommand>"
            + "<directIO command=\"3217\" data=\"01\" />"
            + "</printerCommand>"
            + "</s:Body>"
            + "</s:Envelope>"
        
        self.sendRequestGetText(urlString: State.printerUrlString, method: .post, JSONString: cmd, isLoadingPanelVisible: false) { text in
            let xmlParse = SWXMLHash.parse(text)
            
            var responseData: String? = nil
            if let text = xmlParse["soapenv:Envelope"]["soapenv:Body"]["response"]["addInfo"]["responseData"].element?.text {
                responseData = text
            }
            completionHandler(responseData)
        }
    }
    
    func printShoppingCartVoucherGift(_ cart: ShoppingCart, completionHandler: @escaping (Bool?) -> Void) {
        var actionSucceed = [Bool?]()
        let voucherInfo: VoucherInfo = cart.vouchersInfo[0]
        let payments = cart.payments
        for copyNr in 1...2{
            let rec = XMLWorkOrderNonFiscal()
            rec.beginNonFiscal()
            
            if copyNr == 1{
                rec.printNormal(message: Util.getString("CustomerCopy"))
            }
            else{
                rec.printNormal(message: Util.getString("StoreCopy"))
            }
            
            rec.printNormal(message: "")
            rec.printNormal(message: settings.userSettings.companyName)
            
            rec.printNormal(message: "")
            rec.printNormal(message: voucherInfo.generator.voucherGeneratorName)
            rec.printNormal(message: Util.DoubleToString(voucherInfo.amount) + settings.userSettings.currencyId)
            
            rec.printNormal(message: "")
            
            let contractName = String(payments[0].name)
            let contractLoanNo = payments[0].loanNo
            let contractNewLine = "N. " + contractName + ": " + (contractLoanNo ?? "")
            if payments.count == 1 && payments[0].paymentType.Code == PaymentTypeString.CR{
                rec.printNormal(message: contractNewLine)
            }
            
            var shouldAddNewLine = false
            if let fidelityCard = cart.contact?.FidelityCard{
                if settings.storeSetupSettings.clientName.uppercased() == "NAU!" && voucherInfo.generator.voucherType == VoucherType.FIN && voucherInfo.generator.categoryCode == VoucherCategory.GFT{
                    var availablePoints = 0
                    if let ap = fidelityCard.cardInfo?.availablePointsAmount{
                        availablePoints = ap
                    }
                    
                    let previousPointsText = Util.getString("Saldo Punti Precedente")
                    let previousPointsValue = "\(availablePoints)"
                    let previousPointsNewLine = previousPointsText.padding(toLength: 35 - previousPointsValue.count, withPad: " ", startingAt: 0) + previousPointsValue
                    
                    let acumulatedPointsText = Util.getString("Punti maturati")
                    let acumulatedPointsValue = Int(voucherInfo.amount)
                    let acumulatedPointsNewLine = acumulatedPointsText.padding(toLength: 35 - acumulatedPointsValue.description.count, withPad: " ", startingAt: 0) + acumulatedPointsValue.description
                    
                    
                    rec.printNormal(message: "-----------------------------------")
                    if settings.storeSetupSettings.ECRMPrintPreviousPointsBalance {
                        rec.printNormal(message: previousPointsNewLine)
                    }
                    rec.printNormal(message: acumulatedPointsNewLine)
                    if settings.storeSetupSettings.ECRMFidelityMessage != ""{
                        rec.printFooter(footer: settings.storeSetupSettings.ECRMFidelityMessageLines)
                    }
                    rec.printNormal(message: "-----------------------------------")
                    
                    shouldAddNewLine = true
                }
            }
                                   
            rec.printBarcode(barcode: voucherInfo.voucherCode)
            
            if shouldAddNewLine{
                rec.printNormal(message: "")
            }
            
            rec.printFooter(footer: voucherInfo.generator.messageLines)
            
            rec.printNormal(message: "")
            let formatter = DateFormatter()
            formatter.dateFormat = "dd/MM/yyyy"
            let message = String.init(format: Util.getString("ValidFromTo"), "\(formatter.string(from: voucherInfo.startDate))", "\(formatter.string(from: voucherInfo.endDate))")
            rec.printNormal(message: message)
            
            let ticketNumber = State.newTransactionNumber == 1 ? 0 : State.newTransactionNumber
            let ticketFooter = self.createTicketFooter(ticketNumber: ticketNumber)
            rec.printFooter(footer: ticketFooter)
            
            if voucherInfo.generator.categoryCode == .GFT && voucherInfo.voucherAction == .Creation{
                let messages = self.getGiftCardTrailerMessage(voucher: voucherInfo)
                for message in messages{
                    rec.printNormal(message: message)
                }
            }
            
            rec.endNonFiscalReceipt()
            print(rec.xml)
            
            self.sendRequest(urlString: State.printerUrlString, method: .post, JSONString: rec.xml, wsCompletionHandler: { result in
                actionSucceed.append(result)
                
                if(actionSucceed.count == 2){
                    if((actionSucceed[0] == true) && (actionSucceed[1]) == true){
                        completionHandler(true)
                    }
                    else{
                        completionHandler(false)
                    }
                }
            })
        }
    }
    
    func createTicketFooter(ticketNumber: Int) -> [String] {
        let line1 = String.init(format: "PDV.%@  C.%@", settings.StoreCode, settings.CashRegister)
        var line2 = ""
        if ticketNumber != 0 {
            if let userCode = settings.LoggedInUserCode{
                line2 = String.init(format: "TK.%@  OP.%@ \(Util.getString("Date")) %@", ticketNumber.description, userCode, Util.DateToShortDateString(date: Date()))
            }
        }
        else{
            if let userCode = settings.LoggedInUserCode{
                line2 = String.init(format: "OP.%@ \(Util.getString("Date")) %@", userCode, Util.DateToShortDateString(date: Date()))
            }
        }
        return [line1, line2]
    }
    
    func printShoppingCartRefund(_ cart: ShoppingCart, completionHandler: @escaping (Bool?) -> Void) {
        let rec = XMLReceiptFiscalPrinter()
        var additionalDescriptionInBodyIndex = 0
        var additionalRowBeforeMFIndex = 0
        rec.printerFiscalReceipt()
        
        let message = "PRATICA DI RESO \(State.nextCreditNoteNumber)"
        rec.beginRefundTicket(message: message, messageType: .additionalDescriptionInBody, index: &additionalDescriptionInBodyIndex)
        self.printReturnProduct(cart, rec, &additionalDescriptionInBodyIndex)
        rec.printRecSubtotalAdjustment(cart: cart)
        rec.printRecMessage(message: "", messageType: .additionalDescriptionInBody, index: &additionalDescriptionInBodyIndex)
        rec.printBarcode(barcode: State.transactionBarcode)
                
        if let lotteryCode = State.lotteryCode, lotteryCode.isEmpty == false, State.isLotteryActive {
            rec.sendLotteryCode(code: lotteryCode)
        }
        
        rec.printRecTotal(description: Util.getString("Total"), payment: abs(cart.netValue), paymentType: 0, index: 0)
        rec.printRecMessage(message: "", messageType: .additionalRowBeforeMF, index: &additionalRowBeforeMFIndex)
        self.addFidelityCardRefundTrailerMessagesToList(rec: rec, cart: cart, index: &additionalRowBeforeMFIndex)
        rec.printRecMessage(message: "", messageType: .additionalRowBeforeMF, index: &additionalRowBeforeMFIndex)
        rec.printRecMessage(message: "Tk. \(State.newTransactionNumber) / POS Mobile \(State.cashRegister)", messageType: .additionalRowBeforeMF, index: &additionalRowBeforeMFIndex)

        rec.endFiscalReceipt()
        print(rec.xml)

        self.sendRequest(urlString: State.printerUrlString, method: .post, JSONString: rec.xml, wsCompletionHandler: { result in
           completionHandler(result)
        })
    }
    
    internal func printReturnProduct(_ cart: ShoppingCart, _ rec: XMLReceiptFiscalPrinter, _ additionalDescriptionInBodyIndex: inout Int){
        for cartItem in cart.cartItems {
            let description = cartItem.barcodeInfo.Name
            let quantity = abs(cartItem.Quantity)
            let unitPrice = abs(cartItem.GrossUnitValue)
            let department = cartItem.barcodeInfo.FiscalPrinterDepartment!
            let barcode = cartItem.barcodeInfo.Product
            rec.printRecRefund(description: description, quantity: quantity, unitPrice: unitPrice, department: department)
            
            let discountKeyword = Util.getString("Discount") + " "
            if cartItem.DiscountValue > 0 {
                rec.printRecItemAdjustment(description: discountKeyword, adjustmentType: 0, amount: cartItem.DiscountValue)
            }
            
            rec.printRecMessage(message: barcode, messageType: .additionalDescriptionInBody, index: &additionalDescriptionInBodyIndex)
        }
    }
    
    internal func addFidelityCardRefundTrailerMessagesToList(rec: XMLReceiptFiscalPrinter, cart: ShoppingCart, index: inout Int){
        if let _ = cart.contact, let fidelityCard = cart.fidelityCard, let cardInfo = fidelityCard.cardInfo {
            /*
            COMMENTED 2020-12-11 - IN CEX s-a decis sa nu se mai tipareasca numele din motive de privacy pentru loterie.
            rec.printRecMessage(message: Util.getString("Name") + ": \(contact.getFullName())", messageType: .additionalRowBeforeMF, index: &index)
            */
            
            let previousPointsText = Util.getString("Saldo Punti Precedente")
            let previousPointsValue = "\(cardInfo.availablePointsAmount)"
            let previousPointsNewLine = previousPointsText.padding(toLength: 35 - previousPointsValue.count, withPad: " ", startingAt: 0) + previousPointsValue
        
            let acumulatedPointsText = Util.getString("Punti maturati")
            let acumulatedPointsValue = cart.gainedPoints * (-1)
            let acumulatedPointsNewLine = acumulatedPointsText.padding(toLength: 35 - acumulatedPointsValue.description.count, withPad: " ", startingAt: 0) + acumulatedPointsValue.description
            
            rec.printRecMessage(message: "-----------------------------------", messageType: .additionalRowBeforeMF, index: &index)
            if settings.storeSetupSettings.ECRMPrintPreviousPointsBalance {
                rec.printRecMessage(message: previousPointsNewLine, messageType: .additionalRowBeforeMF, index: &index)
            }
            rec.printRecMessage(message: acumulatedPointsNewLine, messageType: .additionalRowBeforeMF, index: &index)
            if settings.storeSetupSettings.ECRMFidelityMessage != ""{
                rec.printRecFooter(footer: settings.storeSetupSettings.ECRMFidelityMessageLines, messageType: .additionalRowBeforeMF, index: &index)
            }
            rec.printRecMessage(message: "-----------------------------------", messageType: .additionalRowBeforeMF, index: &index)
        }
    }
    
    func reprintReceipt(xml: String, barcode: String, completionHandler: @escaping (Bool?) -> Void) {
        completionHandler(true)
    }
    
    func getSOAPEnvelope(body: String) -> String{
        let command = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
            + "\n" + "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">"
            + "\n" + "<s:Body>"
            + body
            + "\n" + "</s:Body>"
            + "\n" + "</s:Envelope>"
        
        return command
    }
    
    func getFiscalPrinterFirmwareVersion(completionHandler: @escaping(String?) -> Void){
        var firmwareVersion: String? = nil
        let command = "<printerCommand>"
            + "\n"  + "<queryPrinterStatus operator=\"\" statusType=\"0\" />"
            + "\n" +  "</printerCommand>"
        let encoding = self.getSOAPEnvelope(body: command)
        
        Alamofire.request(State.printerUrlString, method: .post, parameters: [:], encoding: encoding, headers: headers ).response(completionHandler: { response in
            if let data = response.data, let utf8Text = String(data: data, encoding: .utf8) {
                let xmlParse = SWXMLHash.parse(utf8Text)
                let addInfo = xmlParse["soapenv:Envelope"]["soapenv:Body"]["response"]["addInfo"]
                if let cpuRel = addInfo["cpuRel"].element?.text {
                    firmwareVersion = cpuRel
                }
            }
            completionHandler(firmwareVersion)
        })
    }
}
