//
//  EpsonNonFiscalPrinter.swift
//  iPOS
//
//  Created by BBC on 13/06/17.
//  Copyright © 2017 BBC. All rights reserved.
//

import Foundation
import Alamofire

class Printer {
    var printer: Epos2Printer?
    var result: Int32 = EPOS2_SUCCESS.rawValue
    
    var target: String = ""
    var newLine = "\n"
    let barcodeWidth = 2
    let barcodeHeight = 80
    
    var receiptLines: String = ""
    
    init(){
        
    }
    
    init(delegate: Epos2PtrReceiveDelegate){
        self.printer = Epos2Printer(printerSeries: Int32(settings.PrinterRowNumber), lang: EPOS2_MODEL_ANK.rawValue)
        self.adjustPrinterUrl()
        self.printer?.setReceiveEventDelegate(delegate)
    }
    
    func adjustPrinterUrl(){
        if !(settings.FiscalPrinterUrl.hasPrefix("TCP")) && !(settings.FiscalPrinterUrl.hasPrefix("BT")){
            if settings.FiscalPrinterUrl.contains(".") {
                target = "TCP:" + settings.FiscalPrinterUrl
            }
            else if settings.FiscalPrinterUrl.contains(":"){
                target = "BT:" + settings.FiscalPrinterUrl
            }
        }
    }
    
    func setFont(){
        result = printer!.addTextFont(Int32(settings.PrinterFont))
    }
    
    func alignToCenter(){
        result = printer!.addTextAlign(EPOS2_ALIGN_CENTER.rawValue)
    }
    
    func alignToLeft(){
        result = printer!.addTextAlign(EPOS2_ALIGN_LEFT.rawValue)
    }
    
    func alignToRight(){
        result = printer!.addTextAlign(EPOS2_ALIGN_RIGHT.rawValue)
    }
    
    func changeTextSize(width: Int, height: Int){
        result = printer!.addTextSize(width, height: height)
    }
    
    func changeTextStyle(reverse: Int32, ul: Int32, em: Int32, color: Int32){
        result = printer!.addTextStyle(reverse, ul: ul, em: em, color: color)
    }
    
    func addCutFeed(){
        result = printer!.addCut(EPOS2_CUT_FEED.rawValue)
    }
    
    func addTextAndNL(_ string: String){
        result = printer!.addText(string + newLine)
        self.receiptLines += string + newLine
    }
    
    func addText(_ string: String){
        result = printer!.addText(string)
        self.receiptLines += string
    }
    
    func addLogo(key1: Int, key2: Int){
        alignToCenter()
        result = printer!.addLogo(key1, key2: key2)
        alignToLeft()
    }
    
    func addArray(array: [String]){
        for string in array{
            addTextAndNL(string)
        }
    }
    
    func beginReceipt(){
        setFont()
    }
    
    func addHeaders(headers:[String]){
        alignToCenter()
        if headers.count > 0 {
            addText(newLine)
            addArray(array: headers)
        }
        alignToLeft()
    }
    
    func addFooter(footer:[String]){
        alignToLeft()
        if footer.count > 0{
            addText(newLine)
            addArray(array: footer)
        }
        alignToLeft()
    }
    
    func addCurrency(){
        addText(newLine)
        addTextAndNL(getCurrencyString(currency: settings.userSettings.currencyId))
    }
    
    func addCurrencyAndTax(){
        addText(newLine)
        addTextAndNL(getCurrencyAndTaxString(currency: settings.userSettings.currencyId, tax: Util.getString("TaxAbbreviation")))
    }

    func addDiscount(discount: Double){
        alignToLeft()
        addTextToLeftAndPriceToRight(string: Util.getString("Discount"), price: -1 * discount)
    }
    
    func addDiscount(discount: Double, description: String){
        alignToLeft()
        addTextToLeftAndPriceToRight(string: description, price: -1 * discount)
    }
    
    func addDiscountAndTax(discount: Double, description: String, tax: String){
        alignToLeft()
        addTextToLeftAndPriceAndTaxToRight(string: description, price: -1 * discount, tax: tax)
    }
    
    func addProduct(productName: String, quantity: Double, unitPrice: Double){
        alignToLeft()
        if quantity > 1{
            let quantityAndPrice: String = Util.DoubleToStringNoDecimals(quantity) + "x  " + Util.DoubleToString(unitPrice)
            addTextAndNL(quantityAndPrice)
        }
        addTextToLeftAndPriceToRight(string: productName, price: quantity * unitPrice)
    }
    
    func addProductAndTax(productName: String, quantity: Double, unitPrice: Double, tax: String){
        alignToLeft()
        if quantity > 1{
            let quantityAndPrice: String = Util.DoubleToStringNoDecimals(quantity) + "x  " + Util.DoubleToString(unitPrice)
            addTextAndNL(quantityAndPrice)
        }
        addTextToLeftAndPriceAndTaxToRight(string: productName, price: quantity * unitPrice, tax: tax)
    }
    
    func addProductWithoutPrice(productName: String, quantity: Double){
        alignToLeft()
        if quantity > 1{
            addTextAndNL(Util.DoubleToStringNoDecimals(quantity) + "x  ")
        }
        addTextAndNL(productName)
    }
    
    func addTextToLeftAndPriceToRight(string: String, price: Double){
        addTextAndNL(getproductString(productName: string, price: price))
    }
    
    func addTextToLeftAndPriceAndTaxToRight(string: String, price: Double, tax: String){
        addTextAndNL(getproductString(productName: string, price: price, tax: tax))
    }
    
    func addTotal(text: String, payments: [Payment], total: Double, change: Double){
        addText(newLine)
        changeTextSize(width: 1, height: 2)
        addTextToLeftAndPriceToRight(string: text, price: total)
        changeTextSize(width: 1, height: 1)
        
        for payment in payments{
            addTextToLeftAndPriceToRight(string: payment.name, price: payment.amount)
        }
        
        addTextToLeftAndPriceToRight(string: Util.getString("CHANGE"), price: change)
    }
    
    func addTotalWithoutPrice(text: String, receiptPayments: [ReceiptPayment]){
        alignToLeft()
        changeTextSize(width: 1, height: 2)
        addTextAndNL(text)
        changeTextSize(width: 1, height: 1)
        for receiptPayment in receiptPayments{
            addText(newLine)
            addTextAndNL(receiptPayment.posPaymentTypes.Name)
        }
        addTextAndNL(Util.getString("CHANGE"))
    }
    
    func addContactFiscalCode(contactFiscalCode: String){
        alignToLeft()
        if(State.contactFiscalCodeForTransaction != nil && State.contactFiscalCodeForTransaction != "") {
            addText(newLine)
            addTextAndNL("************************************")
            addTextAndNL(Util.getString("PrintTicketFiscalCode"))
            addTextAndNL("*********" + " \((State.contactFiscalCodeForTransaction)!) " + "*********")
        }
    }
    
    func addContactFiscalCode(){
        alignToLeft()
        if(State.contactFiscalCodeForTransaction != nil && State.contactFiscalCodeForTransaction != "") {
            addText(newLine)
            addTextAndNL("************************************")
            addTextAndNL(Util.getString("PrintTicketFiscalCode"))
            addTextAndNL("*********" + " \((State.contactFiscalCodeForTransaction)!) " + "*********")
        }
    }
    
    func addWorkOrderFiscalCode(fiscalCode: String){
        alignToLeft()
        addText(newLine)
        addTextAndNL("************************************")
        addTextAndNL(Util.getString("PrintTicketFiscalCode"))
        addTextAndNL("*********" + " \(fiscalCode) " + "*********")
    }
    
    func addBarcode(barcode: String, type: Epos2Barcode){
        if (barcode.count * barcodeWidth) > settings.PrinterColumns{
            addSymbol(barcode: barcode)
        }
        else{
            alignToCenter()
            addText(newLine)
            result = printer!.addBarcode(barcode, type:type.rawValue, hri:EPOS2_HRI_BELOW.rawValue, font:EPOS2_FONT_A.rawValue, width:barcodeWidth, height:barcodeHeight)
            alignToLeft()
        }
    }
    
    func addSymbol(barcode: String){
        alignToCenter()
        addText(newLine)
        result = printer!.addSymbol(State.transactionBarcode, type: EPOS2_SYMBOL_QRCODE_MODEL_2.rawValue, level: EPOS2_PARAM_DEFAULT, width: 5, height: 5, size: 5)
        addText(newLine)
        var barcodeWithSpaces: String = " "
        for char in barcode{
            barcodeWithSpaces.append(char)
            barcodeWithSpaces.append(" ")
        }
        result = printer!.addTextFont(Int32(1))
        addText(barcodeWithSpaces)
        setFont()
        alignToLeft()
    }
    
    func addTransaction(){
        alignToLeft()
        addText(newLine)
        addTextAndNL("Tk. \(State.newTransactionNumber) / POS Mobile \(State.cashRegister)")
    }
    
    func addDate(){
        alignToLeft()
        addText(newLine)
        addTextAndNL(Util.DateToShortDateStringNonFiscalPrinter(date: Date()))
    }
    
    func addTransactionAndDate(transactionNumber: Int, cashRegister: Int, transactionDate: Date){
        alignToLeft()
        addTextAndNL("Tk. \(transactionNumber) / POS Mobile \(cashRegister)")
        addTextAndNL(Util.DateToShortDateStringNonFiscalPrinter(date: transactionDate))
    }
    
    func endReceipt(){
        alignToCenter()
        addText(newLine)
        alignToLeft()
        addCutFeed()
    }
    
    func isShoppingCartBarcodeEnabled() -> Bool{
        for printerRowNumber in PrinterData.insufficientPaperWidthPrinters{
            if printerRowNumber == settings.PrinterRowNumber{
                return false
            }
        }
        return true
    }
    
    func getproductString(productName: String, price: Double) -> String{
        let lineWidth = settings.PrinterColumns
        let maxValueWidth = 10
        let maxNameWidth = lineWidth - maxValueWidth - 1
        var name = productName
        let valueString = Util.DoubleToString(price)
        if name.count > maxNameWidth {
            let index = name.index(name.startIndex, offsetBy: maxNameWidth)
            name = String(name[..<index])
        }
        let spaceWidth = lineWidth - name.count - valueString.count
        let string = name + String.init(repeating: " ", count: spaceWidth) + valueString
        return string
    }
    
    func getproductString(productName: String, price: Double, tax: String) -> String{
        var tax = tax
        if tax.count > 3 {
            let index = tax.index(tax.startIndex, offsetBy: 3)
            tax = String(tax[..<index])
        }
        
        let taxSpaceWidth = 3 - tax.count
        let newTax =  String.init(repeating: " ", count: taxSpaceWidth) + tax
        
        let lineWidth = settings.PrinterColumns
        let maxValueWidth = 10
        let maxNameWidth = lineWidth - maxValueWidth - 1
        var name = productName
        let valueString = Util.DoubleToString(price)
        if name.count > maxNameWidth {
            let index = name.index(name.startIndex, offsetBy: maxNameWidth)
            name = String(name[..<index])
        }
        let spaceWidth = lineWidth - name.count - valueString.count - newTax.count - 1
        let string = name + String.init(repeating: " ", count: spaceWidth) + valueString + " " + newTax
        return string
    }
    
    func getCurrencyString(currency: String) -> String{
        let lineWidth = settings.PrinterColumns
        let spaceWidth = lineWidth - currency.count
        let string = String.init(repeating: " ", count: spaceWidth) + currency
        return string
    }
    
    func getCurrencyAndTaxString(currency: String, tax: String) -> String{
        var tax = tax
        if tax.count > 3 {
            let index = tax.index(tax.startIndex, offsetBy: 3)
            tax = String(tax[..<index])
        }
        
        let taxSpaceWidth = 3 - tax.count
        let newTax =  String.init(repeating: " ", count: taxSpaceWidth) + tax
        
        let lineWidth = settings.PrinterColumns
        let spaceWidth = lineWidth - currency.count - newTax.count - 1
        let string = String.init(repeating: " ", count: spaceWidth) + currency + " " + newTax
        
        return string
    }
    
    func connect(){
        result = printer!.connect(target, timeout: 15000)
    }
    
    func beginTransaction(){
        result = printer!.beginTransaction()
    }
    
    func endTransaction(){
        result = printer!.endTransaction()
    }
    
    func getStatus() -> Epos2PrinterStatusInfo{
        return printer!.getStatus()
    }

    func print(){
        result = printer!.sendData(10000)
    }
    
    func disconnect(){
        result = printer!.disconnect()
        printer!.clearCommandBuffer()
    }
    
    func connectAndPrint() -> Int32{
        connect()
        if result != EPOS2_SUCCESS.rawValue{
            disconnect()
            return EPOS2_ERR_FAILURE.rawValue
        }
        let status = getStatus()
        if status.connection != 1 || status.errorStatus != 0{
            disconnect()
            return EPOS2_ERR_FAILURE.rawValue
        }
        beginTransaction()
        if result != EPOS2_SUCCESS.rawValue{
            disconnect()
            return EPOS2_ERR_FAILURE.rawValue
        }
        print()
        if result != EPOS2_SUCCESS.rawValue{
            disconnect()
            return EPOS2_ERR_FAILURE.rawValue
        }
        endTransaction()
        if result != EPOS2_SUCCESS.rawValue{
            disconnect()
            return EPOS2_ERR_FAILURE.rawValue
        }
        return result
    }
}

class EpsonNonFiscalPrinter:  NSObject, Epos2PtrReceiveDelegate, IPrinter {
    
    var completionHandler: (Bool?) -> Void = { (arg: Bool?) -> Void in}
    
    var epson: Printer = Printer()
    
    private var totalMedicalDevicesValue: Double = 0
    private let FISCALEXPENSETYPE_AD: String = "AD"
    private let FISCALEXPENSETYPE_AA: String = "AA"
    
    override init(){
        super.init()
        epson = Printer(delegate: self as Epos2PtrReceiveDelegate)
    }
    
    public func printWorkOrder(_ workOrder: WorkOrder, completionHandler: @escaping (Bool?) -> Void){
        self.completionHandler = completionHandler
        if epson.printer == nil{
            completionHandler(false)
        }
        Util.SetNetworkActivityIndicatorVisibilty(text: Util.getString("Printing") + "...", visible: true)
        epson.beginReceipt()
        epson.addLogo(key1: 48, key2: 49)
        epson.addHeaders(headers: settings.storeSetupSettings.headerLines)
        epson.addTextAndNL("WorkOrder \(workOrder.OrderNumber) ")
        epson.addTextAndNL("\(Util.DateToShortDateStringNonFiscalPrinter(date: workOrder.CreateTime))")
        epson.alignToLeft()
        
        epson.addTextAndNL("\(workOrder.contact.FirstName) \(workOrder.contact.LastName)")
        if(workOrder.contact.FiscalCode != nil && workOrder.contact.FiscalCode != ""){
            epson.addTextAndNL(Util.getString("Fiscal Code") + " \(workOrder.contact.FiscalCode!)")
        }
        
        epson.addCurrency()
        for detail in workOrder.OrderDetail{
            if (detail.ParentOrderDetailId == nil) {
                epson.addProduct(productName: detail.ProductName!, quantity: detail.OrderedQuantity, unitPrice: detail.GrossUnitValueVatIncluded)
                    
                if let disc = detail.DiscountValue {
                    if (disc > 0) {
                        epson.addDiscount(discount: disc)
                    }
                }
            }
            else {
                epson.addTextAndNL("  " + detail.ProductName!)
            }
        }
        epson.changeTextSize(width: 1, height: 2)
        epson.addTextToLeftAndPriceToRight(string: Util.getString("TOTAL ORDER"), price: workOrder.NetValueVatIncluded)
        epson.changeTextSize(width: 1, height: 1)
        
        epson.addText(epson.newLine)
        epson.addTransaction()
        
        epson.addFooter(footer: settings.storeSetupSettings.footerLines)
        
        epson.addText(epson.newLine)
        epson.addDate()
        
        epson.addText(epson.newLine)
        epson.addBarcode(barcode: workOrder.Barcode!, type: EPOS2_BARCODE_CODE93)
        epson.endReceipt()
        
        if epson.result != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
        else if epson.connectAndPrint() != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
    }
    
    func printWorkOrderFiscal(_ workOrder: WorkOrder, parentId:String?, completionHandler: @escaping (Bool?) -> Void){
        var valueToPay: Double = 0.00
        self.completionHandler = completionHandler
        if epson.printer == nil{
            completionHandler(false)
        }
        Util.SetNetworkActivityIndicatorVisibilty(text: Util.getString("Printing") + "...", visible: true)
        epson.beginReceipt()
        epson.addHeaders(headers: settings.storeSetupSettings.headerLines)
        epson.addCurrencyAndTax()
        
        if parentId != nil{
            for detail in workOrder.OrderDetail {
                if (detail.ParentOrderDetailId == parentId) {
                    
                    var description = ""
                    if settings.storeSetupSettings.isOpticalClient && detail.MedicalDevice != nil && detail.MedicalDevice == true{
                        description = "(DM) "
                    }
                    if let productName = detail.ProductName{
                        description.append(productName)
                    }
                    
                    var countryVatCode: String = ""
                    if let vatId = detail.VatId{
                        countryVatCode = VatDetail.GetVatDetailCode(vatId: vatId)
                    }
                    
                    if detail.ParentOrderDetailId == parentId && settings.storeSetupSettings.isOpticalClient{
                        epson.addProductAndTax(productName: description, quantity: detail.OrderedQuantity, unitPrice: detail.grossRowValueVatIncluded, tax: countryVatCode)
                    }
                    
                    if let productCode = detail.ProductCode{
                        epson.addTextAndNL(productCode)
                    }
                    
                    if let disc = detail.DiscountValue {
                        if (disc > 0) {
                            epson.addDiscountAndTax(discount: disc, description: Util.getString("Discount"), tax: "")
                        }
                    }
                    
                    valueToPay += detail.NetRowValueVatIncluded
                }
                else if (detail.OrderDetailId == parentId) {
                    // print header as descriptions
                    var description = ""
                    if settings.storeSetupSettings.isOpticalClient && detail.MedicalDevice != nil && detail.MedicalDevice == true{
                        description = "(DM) "
                    }
                    
                    if let productName = detail.ProductName{
                        description.append(productName)
                    }
                    
                    if detail.OrderDetailId == parentId{
                        epson.addTextAndNL("*** " + description)
                    }
                }
            }
        }
        epson.addTotal(text: Util.getString("TOTAL") + " " + settings.userSettings.currencyId, payments: workOrder.payments, total: valueToPay, change: workOrder.change)
        
        printVatDetails(workOrder, parentId)
        
        epson.addTransaction()
        
        if(workOrder.contact.FiscalCode != nil && workOrder.contact.FiscalCode != ""){
            epson.addWorkOrderFiscalCode(fiscalCode: workOrder.contact.FiscalCode!)
        }
        
        if settings.storeSetupSettings.isOpticalClient{
            self.calculateMedicalDeviceTotal(workOder: workOrder, parentId: parentId)
            self.addMedicalDeviceTotalsMessagesToList()
        }
        
        epson.addFooter(footer: settings.storeSetupSettings.footerLines)
        
        epson.addDate()
        
        epson.addBarcode(barcode: State.transactionBarcode, type: EPOS2_BARCODE_CODE93)
        
        epson.endReceipt()
        
        let stringWithEnter = epson.receiptLines.replacingOccurrences(of: "\n", with: "\r", options: .regularExpression)
        workOrder.workOrderSale.receiptLines = stringWithEnter
        
        if epson.result != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
        else if epson.connectAndPrint() != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
    }
    
    public func printShoppingCart(_ cart: ShoppingCart, completionHandler: @escaping (Bool?) -> Void){
        self.completionHandler = completionHandler
        if epson.printer == nil{
            completionHandler(false)
        }
        Util.SetNetworkActivityIndicatorVisibilty(text: Util.getString("Printing") + "...", visible: true)
        epson.beginReceipt()
        epson.addLogo(key1: 48, key2: 49)
        epson.addHeaders(headers: settings.storeSetupSettings.headerLines)
        epson.addCurrencyAndTax()
        for cartItem in cart.cartItems{
            var productName = ""
            if settings.storeSetupSettings.isOpticalClient && cartItem.barcodeInfo.MedicalDevice != nil && cartItem.barcodeInfo.MedicalDevice == true{
                productName = "(DM) "
            }
            productName.append(cartItem.barcodeInfo.Name)
            
            var countryVatCode: String = ""
            if let vatId = cartItem.barcodeInfo.VatId{
                countryVatCode = VatDetail.GetVatDetailCode(vatId: vatId)
            }
            epson.addProductAndTax(productName: productName, quantity: cartItem.Quantity, unitPrice: cartItem.GrossUnitValue, tax: countryVatCode)
            
            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 = discountKeyword + "\(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))%"
                }
                epson.addDiscountAndTax(discount: cartItem.DiscountValue, description: discountDescription, tax: "")
            }
            epson.addTextAndNL(cartItem.barcodeInfo.Product)
        }
        epson.addTotal(text: Util.getString("TOTAL") + " " + settings.userSettings.currencyId, payments: cart.payments, total: cart.netValue, change: cart.change)
        
        printVatDetails(cart)
        
        epson.addTransaction()
        
        epson.addContactFiscalCode()
        
        if settings.storeSetupSettings.isOpticalClient{
            self.calculateMedicalDeviceTotal(cart: cart)
            if self.totalMedicalDevicesValue > 0 {
                self.addMedicalDeviceTotalsMessagesToList()
            }
        }
        
        epson.addFooter(footer: settings.storeSetupSettings.footerLines)
       
        epson.addDate()
        
        epson.addBarcode(barcode: State.transactionBarcode, type: EPOS2_BARCODE_CODE93)
        
        epson.endReceipt()
        
        let stringWithEnter = epson.receiptLines.replacingOccurrences(of: "\n", with: "\r", options: .regularExpression)
        cart.receiptLines = stringWithEnter
        
        if epson.result != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
        else if epson.connectAndPrint() != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
    }
    
    func getFiscalPrinterDepartment(vatId: Int?) -> CountryVat?{
        if let countryVats = State.countryVats{
            for countryVat in countryVats{
                if countryVat.vatId == vatId{
                    return countryVat
                }
            }
        }
        return nil
    }
    
    private func printVatDetails(_ workOrder: WorkOrder,_ parentId: String?){
        epson.addText(epson.newLine)
        epson.addTextAndNL(Util.getString("VATDetail"))
        let line = self.addLineDelimitation()
        epson.addTextAndNL(line)
        var detailLine = self.addVatValueDetailLines(Util.getString("Tax"), Util.getString("VATBase"), Util.getString("VAT"), Util.getString("Amount"))
        epson.addTextAndNL(detailLine)
        
        let vatDetails = VatDetail.GetGroupedVatDetails(order: workOrder, parentId: parentId)
        for detail in vatDetails{
            let totalVatValueLine = Util.DoubleToStringNoDecimals(detail.vatRate * 100) + "%:" + Util.DoubleToString(detail.vatValue)
            let netValueVatExcluded = Util.DoubleToString(detail.totalNetValueVatExcluded)
            let netValueVatIncluded = Util.DoubleToString(detail.totalNetValueVatIncluded)
            detailLine = self.addVatValueDetailLines(detail.code, netValueVatExcluded, totalVatValueLine, netValueVatIncluded)
            
            epson.addTextAndNL(detailLine)
        }
        
        epson.addTextAndNL(line)
    }
    
    
    private func printVatDetails(_ cart: ShoppingCart){
        epson.addText(epson.newLine)
        epson.addTextAndNL(Util.getString("VATDetail"))
        let line = self.addLineDelimitation()
        epson.addTextAndNL(line)
        var detailLine = self.addVatValueDetailLines(Util.getString("Tax"), Util.getString("VATBase"), Util.getString("VAT"), Util.getString("Amount"))
        epson.addTextAndNL(detailLine)
        
        let vatDetails = VatDetail.GetGroupedVatDetails(cart: cart)
        for detail in vatDetails{
            let totalVatValueLine = Util.DoubleToStringNoDecimals(detail.vatRate * 100) + "%:" + Util.DoubleToString(detail.vatValue)
            let netValueVatExcluded = Util.DoubleToString(detail.totalNetValueVatExcluded)
            let netValueVatIncluded = Util.DoubleToString(detail.totalNetValueVatIncluded)
            detailLine = self.addVatValueDetailLines(detail.code, netValueVatExcluded, totalVatValueLine, netValueVatIncluded)
            
            epson.addTextAndNL(detailLine)
        }
        
        epson.addTextAndNL(line)
    }
    
    private func addVatValueDetailLines(_ col0: String, _ col1: String, _ col2: String, _ col3: String) -> String{
        let lineWidth: Int = (settings.PrinterColumns - 3) / 3
        var col0 = col0
        if(col0.count > 3){
            let index = col0.index(col0.startIndex, offsetBy: 3)
            col0 = String(col0[..<index])
        }
        let s0 = 3 - col0.count
        let c0: String =  String.init(repeating: " ", count: max(0,s0)) + col0
        
        let s1 = lineWidth - col1.count
        let c1: String = String.init(repeating: " ", count: max(0,s1)) + col1
        
        let s2 = lineWidth - col2.count
        let c2: String = String.init(repeating: " ", count: max(0,s2)) + col2
        
        let s3 = lineWidth - col3.count
        let c3: String = String.init(repeating: " ", count: max(0,s3)) + col3
        
        let line: String = c0 + c1 + c2 + c3
        return line
    }
    
    private func addLineDelimitation() -> String{
        let lineWidth: Int = settings.PrinterColumns
        let line: String = String.init(repeating: "-", count: lineWidth)
        return line
    }
    
    private func calculateMedicalDeviceTotal(workOder: WorkOrder, parentId: String?){
        self.totalMedicalDevicesValue = 0
        
        if settings.userSettings.countryCode != "ITA" {
            return
        }
        
        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
                }
            }
        }
    }
    
    private func calculateMedicalDeviceTotal(cart: ShoppingCart){
        self.totalMedicalDevicesValue = 0
        if settings.userSettings.countryCode != "ITA" {
            return
        }
        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()
    }
    
    private func addMedicalDeviceTotalsMessagesToList() {
        if (self.totalMedicalDevicesValue != 0){
            epson.addTextAndNL("")
            epson.addTextAndNL("------------------------------")
            epson.addTextAndNL("(DM)=DISPOSITIVO MEDICO")
            epson.addTextAndNL("Prod. con marcatura CE")
            epson.addTextAndNL("dir. 93/42/CEE e ss.mm")
            epson.addTextAndNL("------------------------------")
            epson.addTextAndNL("Valore tot. detraibile nella")
            epson.addTextAndNL(String.init(format: "dich. dei redditi: %@ %@", Util.DoubleToString(self.totalMedicalDevicesValue), settings.userSettings.currencyId))
            epson.addTextAndNL("------------------------------")
        }
    }
    
    public func printShoppingCartGiftReceipt(receipt: Receipt, movements: [Movement], receiptPayments: [ReceiptPayment], completionHandler: @escaping (Bool?) -> Void){
        self.completionHandler = completionHandler
        if epson.printer == nil{
            completionHandler(false)
        }
        Util.SetNetworkActivityIndicatorVisibilty(text: Util.getString("Printing") + "...", visible: true)
        epson.beginReceipt()
        epson.addLogo(key1: 48, key2: 49)
        epson.addHeaders(headers: settings.storeSetupSettings.headerLines)
        for movement in movements{
            if let barcode = movement.barcodeInfo.Barcode{
                epson.addProductWithoutPrice(productName: barcode, quantity: 0)
            }
            epson.addProductWithoutPrice(productName: movement.barcodeInfo.Name, quantity: movement.quantity!)
            epson.addText(epson.newLine)
        }
        
        epson.addFooter(footer: settings.storeSetupSettings.footerLines)
        
        epson.addBarcode(barcode: receipt.receiptBarcode!, type: EPOS2_BARCODE_CODE93)
        epson.addText(epson.newLine)

        let ticketFooter = self.createTicketFooter(ticketNumber: 0)
        epson.addTextAndNL(ticketFooter)
        
        epson.endReceipt()
        
        if epson.result != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
        else if epson.connectAndPrint() != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
    }
    
    func printPaidAdvanceNonFiscal(_ workOrder: WorkOrder, completionHandler: @escaping (Bool?) -> Void){
        self.completionHandler = completionHandler
        if epson.printer == nil{
            completionHandler(false)
        }
        Util.SetNetworkActivityIndicatorVisibilty(text: Util.getString("Printing") + "...", visible: true)
        epson.beginReceipt()
        for copyNr in 1...2{
            epson.addHeaders(headers: settings.storeSetupSettings.headerLines)
            epson.addText(epson.newLine)
            epson.alignToLeft()
            epson.addTextAndNL(Util.getString("ADVANCE NR.") + " \(State.newTransactionNumber)")
            epson.addText(epson.newLine)
            
            let formatter = DateFormatter()
            formatter.dateFormat = "dd/MM/yyyy"
            
            epson.addTextAndNL(Util.getString("Date") + ": \(formatter.string(from: workOrder.CreateTime))")
            epson.addTextAndNL(Util.getString("Order") + ": \(workOrder.OrderNumber)")
            
            epson.addTextAndNL(Util.getString("Client") + ": \(workOrder.contact.getFullName())")
            
            if let fiscalCode = workOrder.contact.FiscalCode{
                epson.addTextAndNL(Util.getString("PrintAdvanceFiscalCode") + ": \(fiscalCode)")
            }
            epson.addText(epson.newLine)
            epson.addTextAndNL(Util.getString("Advance value") + ": \(Util.DoubleToString(workOrder.AdvancePayedValue!))" + " \(settings.userSettings.currencyId)")
            epson.addTextAndNL(Util.getString("Total order") + ": \(Util.DoubleToString(workOrder.NetValueVatIncluded))" + " \(settings.userSettings.currencyId)")

            if copyNr == 1{
                epson.addFooter(footer: settings.storeSetupSettings.advanceMessageLines1)
                epson.addFooter(footer: settings.storeSetupSettings.advanceMessageLines2)
                epson.addText(epson.newLine)
                epson.addTextAndNL(Util.getString("***CLIENT COPY***"))
            }
            else{
                epson.addText(epson.newLine)
                epson.addTextAndNL(Util.getString("***STORE COPY***"))
            }
            
            epson.endReceipt()
        }
        if epson.result != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
        else if epson.connectAndPrint() != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
    }
    
    func printIngenicoResponse(response: PTTransactionResult, completionHandler: @escaping (Bool?) -> Void){
        self.completionHandler = completionHandler
        if epson.printer == nil{
            completionHandler(false)
        }
        Util.SetNetworkActivityIndicatorVisibilty(text: Util.getString("Printing") + "...", visible: true)
        let ticketRows = response.ticket?.components(separatedBy: "\r\n")
        epson.beginReceipt()
        for copyNr in 1...2{
            epson.addText(epson.newLine)
            epson.alignToLeft()
            if copyNr == 1{
                epson.addTextAndNL(Util.getString("***STORE COPY***"))
            }
            else{
                epson.addTextAndNL(Util.getString("***CLIENT COPY***"))
            }
            epson.addText(epson.newLine)
            for row in ticketRows!{
                epson.addTextAndNL(row)
            }
            epson.addText(epson.newLine)
            if copyNr == 1{
                epson.addTextAndNL(Util.getString("Customer signature"))
                epson.addText(epson.newLine)
            }
            
            epson.addTransaction()
            epson.addText(epson.newLine)
            epson.addDate()
            
            epson.addText(epson.newLine)
            epson.addCutFeed()
        }
        if epson.result != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
        else if epson.connectAndPrint() != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
    }
    
    func printIngenicoErrorResponse(response: PTTransactionResult, amount: Double, completionHandler: @escaping (Bool?) -> Void){
        self.completionHandler = completionHandler
        if epson.printer == nil{
            completionHandler(false)
        }
        Util.SetNetworkActivityIndicatorVisibilty(text: Util.getString("Printing") + "...", visible: true)
        epson.beginReceipt()
        epson.addText(epson.newLine)
        epson.alignToLeft()
        epson.changeTextSize(width: 1, height: 2)
        epson.addTextAndNL("ACQUISTO")
        epson.changeTextSize(width: 1, height: 1)
        epson.addTextAndNL("DATA \(Util.DateToFullDateString(date: Date()))")
        epson.addTextAndNL("TML: \(settings.TerminalId)")
        epson.addTextAndNL("PAN: \(response.pan ?? "")")
        epson.addTextAndNL("SCAD. xx/xx/xx")
        epson.addTextAndNL("STAN: \(response.stan ?? "")")
        epson.addText(epson.newLine)
        epson.addTextAndNL("\(settings.userSettings.currencyId) \(Util.DoubleToStringWithTwoDecimals(amount))")
        epson.addText(epson.newLine)
        epson.changeTextStyle(reverse: 0, ul: 0, em: 1, color: 0)
        epson.addTextAndNL("************************")
        epson.addTextAndNL("\(response.transactionMessage ?? "")")
        epson.addTextAndNL("************************")
        epson.changeTextStyle(reverse: 0, ul: 0, em: 0, color: 0)
        epson.addText(epson.newLine)
        epson.addCutFeed()
        
        if epson.result != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
        else if epson.connectAndPrint() != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
    }
    
    func testPrinter() -> Int32{
        if epson.printer == nil{
            return EPOS2_ERR_FAILURE.rawValue
        }
        epson.connect()
        if epson.result != EPOS2_SUCCESS.rawValue{
            epson.disconnect()
            return EPOS2_ERR_FAILURE.rawValue
        }
        let status = epson.getStatus()
        if status.connection != 1 || status.errorStatus != 0{
            epson.disconnect()
            return EPOS2_ERR_FAILURE.rawValue
        }
        epson.disconnect()
        if epson.result != EPOS2_SUCCESS.rawValue{
            return epson.result
        }
        return epson.result
    }
    
    func onPtrReceive(_ printerObj: Epos2Printer!, code: Int32, status: Epos2PrinterStatusInfo!, printJobId: String!) {
        epson.disconnect()
        if code == EPOS2_CODE_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(true)
        }
        else{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
    }
    
    func printZReport(completionHandler: @escaping (Bool?) -> Void) {
        completionHandler(true)
    }
    
    func getTotalSalesForDepartment(department: Int, completionHandler: @escaping (Double) -> Void) {
        completionHandler(0)
    }
    
    func printVoucherMessageNonFiscal(voucherMessage: String, completionHandler: @escaping (Bool?) -> Void) {
        completionHandler(true)
    }
    
    func isPrinterStateIdle(completionHandler: @escaping (Bool) -> Void) {
        completionHandler(true)
    }
    
    func printShoppingCartVoucherGift(_ cart: ShoppingCart, completionHandler: @escaping (Bool?) -> Void) {
        self.completionHandler = completionHandler
        if epson.printer == nil{
            completionHandler(false)
        }
        Util.SetNetworkActivityIndicatorVisibilty(text: Util.getString("Printing") + "...", visible: true)
        epson.beginReceipt()
        let voucherInfo: VoucherInfo = cart.vouchersInfo[0]
        for copyNr in 1...2{
            epson.addHeaders(headers: settings.storeSetupSettings.headerLines)
            epson.addText(epson.newLine)
            epson.alignToLeft()
            
            if copyNr == 1{
                epson.addTextAndNL(Util.getString("***CLIENT COPY***"))
            }
            else{
                epson.addTextAndNL(Util.getString("***STORE COPY***"))
            }
            
            epson.addText(epson.newLine)
            epson.addTextAndNL(voucherInfo.generator.voucherGeneratorName)
            epson.addTextAndNL(Util.DoubleToString(voucherInfo.amount) + settings.userSettings.defaultCurrency)
            
            epson.addText(epson.newLine)
            epson.addBarcode(barcode: voucherInfo.voucherCode, type: EPOS2_BARCODE_CODE93)
            
            epson.addText(epson.newLine)
            epson.addFooter(footer: voucherInfo.generator.messageLines)
            
            epson.addText(epson.newLine)
            let formatter = DateFormatter()
            formatter.dateFormat = "dd/MM/yyyy"
            if let startDate =  voucherInfo.validityStartDate, var endDate = voucherInfo.validityEndDate{
                endDate = Calendar.current.date(byAdding: .day, value: 360, to: endDate) ?? endDate
                let message = String.init(format: Util.getString("ValidFromTo"), "\(formatter.string(from: startDate))", "\(formatter.string(from: endDate))")
                epson.addTextAndNL(message)
            }
            
            epson.addText(epson.newLine)
            let ticketFooter = self.createTicketFooter(ticketNumber: 0)
            epson.addTextAndNL(ticketFooter)
            
            epson.endReceipt()
        }
        if epson.result != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
        else if epson.connectAndPrint() != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            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.DateToShortDateStringNonFiscalPrinter(date: Date()))
            }
        }
        else{
            if let userCode = settings.LoggedInUserCode{
                line2 = String.init(format: "OP.%@ \(Util.getString("Date")) %@", userCode, Util.DateToShortDateStringNonFiscalPrinter(date: Date()))
            }
        }
        return line1 + "\n" + line2
    }

    func getFiscalPrinterSerialNumber(completionHandler: @escaping (String?) -> Void) {
        completionHandler(nil)
    }
    
    func printShoppingCartRefund(_ cart: ShoppingCart, completionHandler: @escaping (Bool?) -> Void) {
        self.completionHandler = completionHandler
        if epson.printer == nil{
            completionHandler(false)
        }
        Util.SetNetworkActivityIndicatorVisibilty(text: Util.getString("Printing") + "...", visible: true)
        epson.beginReceipt()
        epson.addHeaders(headers: settings.storeSetupSettings.headerLines)
        epson.addCurrency()
        
        let message = "PRATICA DI RESO \(State.nextCreditNoteNumber)"
        epson.addTextAndNL(message)
        self.printReturnProduct(cart)
        let total = Util.getString("TOTAL") + " " + settings.userSettings.currencyId
        epson.addTotal(text: total, payments: cart.payments, total: cart.netValue, change: cart.change)
        epson.addDate()
        epson.addBarcode(barcode: State.transactionBarcode, type: EPOS2_BARCODE_CODE93)
        epson.endReceipt()
        
        let stringWithEnter = epson.receiptLines.replacingOccurrences(of: "\n", with: "\r", options: .regularExpression)
        cart.receiptLines = stringWithEnter
        
        if epson.result != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
        else if epson.connectAndPrint() != EPOS2_SUCCESS.rawValue{
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(false)
        }
    }
    
    internal func printReturnProduct(_ cart: ShoppingCart){
        for cartItem in cart.cartItems {
            let description = cartItem.barcodeInfo.Name
            let quantity = abs(cartItem.Quantity)
            let unitPrice = abs(cartItem.GrossUnitValue)
            let barcode = cartItem.barcodeInfo.Product
            epson.addProduct(productName: description, quantity: quantity, unitPrice: unitPrice)
            let discountKeyword = Util.getString("Discount") + " "
            if cartItem.DiscountValue > 0 {
                epson.addDiscount(discount: cartItem.DiscountValue, description: discountKeyword)
            }
            epson.addTextAndNL(barcode)
        }
    }
    
    func reprintReceipt(xml: String, barcode: String, completionHandler: @escaping (Bool?) -> Void) {
        Util.SetNetworkActivityIndicatorVisibilty(text: Util.getString("Printing") + "...", visible: true)
        
        var xmlString = self.beginReceipt()
        xmlString += self.addLogo()
        xmlString += self.setTextAlignCenter()
        xmlString += self.printTitle()
        xmlString += self.setTextAlignLeft()
        
        let lines = xml.components(separatedBy: "\r\n")
        for line in lines{
            xmlString += self.addTextTag(line)
        }
        
        xmlString += self.endReceipt(barcode: barcode)
        
        print(xmlString)
        let headers: HTTPHeaders = [
            "Content-Type" : "text/xml"
        ]
        
        Alamofire.request(State.printerUrlString, method: .post, parameters: [:], encoding: xmlString, headers: headers ).response(completionHandler: { response in
            Util.SetNetworkActivityIndicatorVisibilty(text: nil, visible: false)
            completionHandler(true)
        })
    }
    
    func beginReceipt() -> String {
        let xml = "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">"
        + "<s:Body>"
        + "<epos-print xmlns=\"http://www.epson-pos.com/schemas/2011/03/epos-print\">"
        return xml
    }
    
    func addLogo() -> String{
        return "<logo key1=\"48\" key2=\"49\"/>"
    }
    
    func printTitle() -> String {
        let xml = "<text dw=\"false\" dh=\"true\"/>"
            + addTextTag(Util.getString("REPRINT"))
            + "<text dw=\"false\" dh=\"false\"/>"
            + addTextTag("")
        return xml
    }
    
    func setTextAlignCenter() -> String {
        return "<text align=\"center\"/>"
    }
       
    func setTextAlignLeft() -> String {
        return "<text align=\"left\"/>"
    }
    
    func addTextTag(_ text: String) -> String {
        let newline = "&#10;"
        return "<text>\(text)\(newline)</text>"
    }

    func endReceipt(barcode: String) -> String {
        let xml = "<text align=\"center\"/>"
        + "<barcode type=\"code93\" hri=\"below\" font=\"font_a\" width=\"2\" height=\"80\">\(barcode)</barcode>"
        + "<cut type=\"feed\"/>"
        + "</epos-print>"
        + "</s:Body>"
        + "</s:Envelope>"
        
        return xml
    }
    
    func getFiscalPrinterFirmwareVersion(completionHandler: @escaping (String?) -> Void) {
        completionHandler(nil)
    }
}
