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

import Foundation
import ObjectMapper

enum EnumOrderSaleState: Int{
    case Quotation = 0
    case NotConfirmed = 1
    case Preparing = 2
    case PartiallyReady = 3
    case Ready = 4
    case Closed = 5
    case Canceled = 6
}

class WorkOrder: Mappable {
    var OrderId : String
    var OrderNumber : Int
    var Name : String?
    var ExternalCode : String?
    var Barcode : String?
    var CreateContactId : String?
    var CreateStoreId : Int?
    var CreateCompanyId : Int?
    var AlternativeAddressId : Int?
    var DestinationStoreId : Int?
    var DeliveryStoreId : Int?
    var CreateTime : Date
    var CreateUserId : String?
    var DeliveryDate : Date?
    var OrderTypeId : Int?
    var PaymentTypeId : Int?
    var CertifyTime : Date?
    var Notes : String?
    var CloseTime : Date?
    var SupplierCompanyId : Int?
    var ExpireTime : Date?
    var IsInvoiceMandatory : Bool?
    var PrintInvoice : Bool?
    var CancelTime : Date?
    var VoucherValue : Double?
    var NetValueVatIncluded : Double = 0
    var LastActionIndex : Int?
    var TotalGrossValueVatExcluded : Double?
    var TrackingNumber : String?
    var GrossValueVatIncluded : Double = 0
    var DiscountValue : Double?
    var AdvanceRequiredValue : Double?
    var AdvancePayedValue : Double?
    var CurrencyId : String?
    var SaleState : Int = 0
    var ModifyTime : Date?
    var TransferTime : Date?
    var ReceivedTime : Date?
    var ReceivedState : Int?
    var VatId : Int?
    var contact: Contact
    var OrderDetail: [WorkOrderDetail]
    var OrderAction: [WorkOrderAction]
    var payments: [Payment] = [Payment]()
    var AllowSendToHealthInsurance: Bool?
    var posAllowModifyContact : Bool?
    var posAllowAddProducts : Bool?
    var posAllowChangePrices : Bool?
    var posAllowApplyPromotions : Bool?
    var VoucherCode: String? = nil
    var VoucherUnlockCode: String? = nil
    
    //not mapped
    var isRecalculated:Bool = false
    var totalPayed: Double = 0
    var change: Double = 0
    var voucherInfo: VoucherInfo? = nil
    var isVoucherCumulative : Bool?
    
    //Used to save transaction
    var workOrderSale: WorkOrderSale = WorkOrderSale()
    
    var advanceRemainingValue: Double{
        get{
            var val: Double = 0
            for action in self.OrderAction{
                if action.ActionState != 1{
                    continue
                }
                
                if (action.ActionType == "RA1" || action.ActionType == "RAN") && action.VoucherValue != nil{
                    val += Double(action.VoucherValue!)
                }
                else if action.ActionType == "RVS" && action.VoucherValue != nil{
                    val -= Double(action.VoucherValue!)
                }
                else if action.ActionType == "EBC" && action.VoucherValue != nil{
                    val -= Double(action.VoucherValue!)
                }
            }
            return val
        }
    }
    
    var deliveredValue: Double{
        get{
            var val: Double = 0
            for detail in self.OrderDetail{
                if detail.ParentOrderDetailId == nil {
                    if detail.DeliveredQuantity == nil || detail.DeliveredQuantity == 0 || detail.OrderedQuantity == 0{
                        continue
                    }
                    
                    var qty: Double = Double(detail.DeliveredQuantity!)
                    
                    if detail.ReturnedQuantity != nil {
                        qty -= Double(detail.ReturnedQuantity!)
                    }
                    
                    val += qty * (Double(detail.NetRowValueVatIncluded) / Double(detail.OrderedQuantity))
                }
            }
            return val
        }
    }
    
    var remainingValueToDeliver: Double{
        get{
            return Double(self.NetValueVatIncluded) - self.deliveredValue
        }
    }
    
    var originalVatChanged: Bool{
        get{
            return self.VatId != nil
        }
    }
    
    var gainedPoints: Int{
        get{
            var gainedPoints = 0
            if let fidelityCard = self.contact.FidelityCard, let _ = fidelityCard.cardInfo{
                if let spendAmountForPoint = fidelityCard.fidelityCardType?.spendAmountForPoint{
                    
                    var value = self.NetValueVatIncluded
                    for payment in self.workOrderSale.payments{
                        if let voucher = payment.voucherInfo{
                            if settings.storeSetupSettings.clientName.uppercased() == "NAU!" && voucher.generator.voucherType == VoucherType.FIN && voucher.generator.categoryCode == VoucherCategory.GFT {
                                value -= voucher.amount
                            }
                        }
                    }
                    
                    gainedPoints = Int(value / spendAmountForPoint)
                }
            }
            return gainedPoints
        }
    }
    
    func mapping(map: Map) {
        OrderId <- map["OrderId"]
        OrderNumber <- map["OrderNumber"]
        Name <- map["Name"]
        ExternalCode <- map["ExternalCode"]
        Barcode <- map["Barcode"]
        CreateContactId <- map["CreateContactId"]
        CreateStoreId <- map["CreateStoreId"]
        CreateCompanyId <- map["CreateCompanyId"]
        AlternativeAddressId <- map["AlternativeAddressId"]
        DestinationStoreId <- map["DestinationStoreId"]
        DeliveryStoreId <- map["DeliveryStoreId"]
        CreateTime <- (map["CreateTime"], Util.CustomDateTransform())
        CreateUserId <- map["CreateUserId"]
        DeliveryDate <- map["DeliveryDate"]
        OrderTypeId <- map["OrderTypeId"]
        PaymentTypeId <- map["PaymentTypeId"]
        CertifyTime <- (map["CertifyTime"], Util.CustomDateTransform())
        Notes <- map["Notes"]
        CloseTime <- map["CloseTime"]
        SupplierCompanyId <- map["SupplierCompanyId"]
        ExpireTime <- map["ExpireTime"]
        IsInvoiceMandatory <- map["IsInvoiceMandatory"]
        PrintInvoice <- map["PrintInvoice"]
        CancelTime <- map["CancelTime"]
        VoucherValue <- (map["VoucherValue"], Util.CustomDoubleTransform())
        NetValueVatIncluded <- (map["NetValueVatIncluded"], Util.CustomDoubleTransform())
        LastActionIndex <- map["LastActionIndex"]
        TotalGrossValueVatExcluded <- map["TotalGrossValueVatExcluded"]
        TrackingNumber <- map["TrackingNumber"]
        GrossValueVatIncluded <- (map["GrossValueVatIncluded"], Util.CustomDoubleTransform())
        DiscountValue <- (map["DiscountValue"], Util.CustomDoubleTransform())
        AdvanceRequiredValue <- (map["AdvanceRequiredValue"], Util.CustomDoubleTransform())
        AdvancePayedValue <- (map["AdvancePayedValue"], Util.CustomDoubleTransform())
        CurrencyId <- map["CurrencyId"]
        SaleState <- map["SaleState"]
        ModifyTime <- (map["ModifyTime"], Util.CustomDateTransform())
        TransferTime <- (map["TransferTime"], Util.CustomDateTransform())
        ReceivedTime <- (map["ReceivedTime"], Util.CustomDateTransform())
        ReceivedState <- map["ReceivedState"]
        VatId <- map["VatId"]
        contact <- map["Contacts"]
        OrderDetail <- map["OrderDetails"]
        OrderAction <- map["OrderActions"]
        AllowSendToHealthInsurance <- map["AllowSendToHealthInsurance"]
        payments <- map["Payments"]
        workOrderSale <- map["OrderSale"]
        posAllowModifyContact <- map["PosAllowModifyContact"]
        posAllowAddProducts <- map["PosAllowAddProducts"]
        posAllowChangePrices <- map["PosAllowChangePrices"]
        posAllowApplyPromotions <- map["PosAllowApplyPromotions"]
        VoucherCode <- map["VoucherCode"]
        VoucherUnlockCode <- map["VoucherUnlockCode"]
    }
    
    required init?(map: Map) {
        OrderId = UUID().description
        CreateTime = Date()
        OrderNumber = 1
        OrderDetail = [WorkOrderDetail]()
        OrderAction = [WorkOrderAction]()
        contact = Contact()
    }
    
    init() {
        OrderId = UUID().description
        CreateTime = Date()
        OrderNumber = 1
        OrderDetail = [WorkOrderDetail]()
        OrderAction = [WorkOrderAction]()
        contact = Contact()
    }

    func addItem(barcodeInfo: WSBarcodeInfo){
        let item = WorkOrderDetail()
        item.OrderId = State.workOrder.OrderId
        item.OrderedQuantity = barcodeInfo.quantity
        item.SaleState = 1
        item.OrderDetailRowNumber = self.OrderDetail.count + 1
        item.RowType = "OTH"
        item.OperationType = "V"
        item.PrintType = "F"
        item.UnitOfMeasureName = barcodeInfo.UnitOfMeasure
        
        item.StyleId = barcodeInfo.StyleId!
        item.GrossUnitValueVatIncluded = barcodeInfo.SalePrice
        item.NetRowValueVatIncluded = barcodeInfo.SalePrice
        item.ProductName = barcodeInfo.Name
        item.ProductCode = barcodeInfo.Code
        item.Barcode = barcodeInfo.Barcode
        item.VatId = barcodeInfo.VatId
        item.VatRate = barcodeInfo.VatRate
        item.VatValue = Util.DoubleToDoubleRoundedWithTwoDecimalPlaces(barcodeInfo.SalePrice * barcodeInfo.VatRate!)
        item.FiscalExpenseTypeId = barcodeInfo.FiscalExpenseTypeId
        item.MedicalDevice = barcodeInfo.MedicalDevice
        item.applyPromoEngine = true
        
        State.workOrder.OrderDetail.append(item)
    }
    
    func removeItem(at: Int){
        let orderDetail = OrderDetail[at]
        if orderDetail.getNumberOfChild() > 0 {
            for _ in at...at + orderDetail.getNumberOfChild() {
                OrderDetail[at].OrderedQuantity = 0
                OrderDetail.remove(at: at)
            }
        }
        else{
            OrderDetail.remove(at: at)
        }
        for i in 0..<OrderDetail.count{
            OrderDetail[i].OrderDetailRowNumber = i + 1
        }
    }
    
    func recalculate(){
        self.GrossValueVatIncluded = 0
        self.NetValueVatIncluded = 0
        self.DiscountValue = 0

        for item in self.OrderDetail{
            if(item.ParentOrderDetailId == nil){
                self.GrossValueVatIncluded += item.GrossUnitValueVatIncluded * item.OrderedQuantity
                if let discount = item.DiscountValue{
                    self.DiscountValue! += discount
                }
                self.NetValueVatIncluded += item.NetRowValueVatIncluded
            }
        }
    }
    
    func setCanApplyPromotions(){
        if let isVoucherCumulative = self.isVoucherCumulative, isVoucherCumulative == false{
            for item in self.OrderDetail{
                item.canApplyPromotions = false
            }
        }
    }
    
    func recalculateOutsideConfigurator(completionHandler: @escaping () -> Void){
        self.GrossValueVatIncluded = 0
        self.NetValueVatIncluded = 0
        self.DiscountValue = 0
        
        self.setCanApplyPromotions()
        let promoCart = self.createPromoShoppingCartOutsideConfigurator()
        State.ApplyPromoEngine(promoCart: promoCart, completionHandler: { promoEngineResponse in
            self.importPromoShoppingCartOutsideConfigurator(promoEngineResponse.shoppingCart)
            self.isRecalculated = true
            completionHandler()
        })
    }
    
    func recalculate(completionHandler: @escaping () -> Void){
        self.GrossValueVatIncluded = 0
        self.NetValueVatIncluded = 0
        self.DiscountValue = 0
        
        self.setCanApplyPromotions()
        let promoCart = self.createPromoShoppingCart()
        State.ApplyPromoEngine(promoCart: promoCart, completionHandler: { promoEngineResponse in
            self.importPromoShoppingCart(promoEngineResponse.shoppingCart)
            self.isRecalculated = true
            completionHandler()
        })
    }
    
    func recalculate(canApplyPromoEngine: Bool, completionHandler: @escaping () -> Void){
        if(canApplyPromoEngine){
            self.GrossValueVatIncluded = 0
            self.NetValueVatIncluded = 0
            self.DiscountValue = 0
            
            self.setCanApplyPromotions()
            let promoCart = self.createPromoShoppingCart()
            State.ApplyPromoEngine(promoCart: promoCart, completionHandler: { promoEngineResponse in
                self.importPromoShoppingCart(promoEngineResponse.shoppingCart)
                self.isRecalculated = true
                completionHandler()
            })
        }
        else{
            self.recalculate()
            completionHandler()
        }
    }
    
    func importPromoShoppingCart(_ promoShoppingCart: PromoShoppingCart )  {
        for promoItem in promoShoppingCart.items {
            if var detail = findByRowNumber(rowNumber: promoItem.rowNumber){
                detail.GrossUnitValueVatIncluded = promoItem.grossUnitValueVatIncluded!
                //detail.DiscountValue = promoItem.rowDiscountValue! // Discount will be calculated in addOrderDetailDiscounts
                //detail.NetRowValueVatIncluded = promoItem.netRowValueVatIncluded! // Net value will be calculated later

                self.removeOrderDetailDiscounts(promoItem: promoItem, item: &detail)
                self.addOrderDetailDiscounts(promoItem: promoItem, item: &detail)
            }
        }
    }
    
    func importPromoShoppingCartOutsideConfigurator(_ promoShoppingCart: PromoShoppingCart )  {
        for promoItem in promoShoppingCart.items {
            if var detail = findByRowNumber(rowNumber: promoItem.rowNumber){
                detail.GrossUnitValueVatIncluded = promoItem.grossUnitValueVatIncluded!
                //detail.DiscountValue = promoItem.rowDiscountValue! // Discount will be calculated in addOrderDetailDiscounts
                //detail.NetRowValueVatIncluded = promoItem.netRowValueVatIncluded! // Net value will be calculated later

                self.removeOrderDetailDiscounts(promoItem: promoItem, item: &detail)
                self.addOrderDetailDiscounts(promoItem: promoItem, item: &detail)
            }
        }
    }
    
    func findByRowNumber(rowNumber: Int) -> WorkOrderDetail?{
        for detail in self.OrderDetail{
            if detail.OrderDetailRowNumber == rowNumber{
                return detail
            }
        }
        return nil
    }
    
    private func removeOrderDetailDiscounts(promoItem: PromoCartItem, item: inout WorkOrderDetail){
        if let promoEffects = promoItem.effects {
            if promoEffects.count > 0 {
                for promoEffect in promoEffects {
                    var discountType = enumDiscountTypes.PC
                    
                    if promoEffect.effectCategory == "KC"{
                        discountType = enumDiscountTypes.KC
                    }
                    else if promoEffect.effectCategory == "KT"{
                        discountType = enumDiscountTypes.KT
                    }
                    else if (promoEffect.effectCategory == "VRV" || promoEffect.effectCategory == "VR%") && promoEffect.triggerVoucherCode?.isEmpty == false{
                        discountType = enumDiscountTypes.VC
                    }
                    /*else if promoEffect.effectCategory == "PR"{
                        discountType = enumDiscountTypes.PR
                    }*/
                    
                    else if item.RowType == "GL" || item.RowType == "CL" || item.RowType == "OTH" {
                        discountType = enumDiscountTypes.PR
                    }
                    
                    self.clearOrderDetailDiscount(orderDetail: &item, discountType: discountType)
                }
            }
        }
    }
    
    func clearOrderDetailDiscount(orderDetail: inout WorkOrderDetail, discountType: enumDiscountTypes){
        if let discounts = orderDetail.discounts{
            for discount in discounts{
                if discount.DiscountType == discountType.rawValue{
                    orderDetail.discounts?.removeAll(where: {$0.OrderDiscountId == discount.OrderDiscountId})
                    if orderDetail.DiscountValue != nil {
                        orderDetail.DiscountValue! -= discount.DiscountValue!
                        
                        orderDetail.NetRowValueVatIncluded = orderDetail.OrderedQuantity * orderDetail.GrossUnitValueVatIncluded - orderDetail.DiscountValue!
                        if let vatRate = orderDetail.VatRate {
                            let netValueVatExcluded = (orderDetail.NetRowValueVatIncluded / (1 + vatRate)).rounded(toPlaces: 2)
                            orderDetail.VatValue =  (netValueVatExcluded * vatRate).rounded(toPlaces: 2)
                        }
                    }
                }
            }
        }
        
        for var detail in self.getChildCollection(parentId: orderDetail.OrderDetailId){
            if detail.applyPromoEngine {
                self.clearOrderDetailDiscount(orderDetail: &detail, discountType: discountType)
            }
        }
    }
    
    private func addOrderDetailDiscounts(promoItem: PromoCartItem, item: inout WorkOrderDetail){
        if let promoEffects = promoItem.effects {
            if promoEffects.count > 0 {
                for promoEffect in promoEffects {
                    var discountType = enumDiscountTypes.PC
                    
                    if promoEffect.effectCategory == "KC"{
                        discountType = enumDiscountTypes.KC
                    }
                    else if promoEffect.effectCategory == "KT"{
                        discountType = enumDiscountTypes.KT
                    }
                    else if (promoEffect.effectCategory == "VRV" || promoEffect.effectCategory == "VR%") && promoEffect.triggerVoucherCode?.isEmpty == false{
                        discountType = enumDiscountTypes.VC
                    }
                    /*else if promoEffect.effectCategory == "PR"{
                        discountType = enumDiscountTypes.PR
                    }*/
                    else if item.RowType == "GL" || item.RowType == "CL" || item.RowType == "OTH" {
                        discountType = enumDiscountTypes.PR
                    }
                    
                    self.addOrderDetailDiscount(orderDetail: &item, discountCauseId: promoEffect.discountCauseId, discountValue: promoEffect.rowDiscountValue, discountType: discountType, promotionId: promoEffect.promotionId)
                }
            }
        }
    }
    
    func addOrderDetailDiscount(orderDetail: inout WorkOrderDetail, discountCauseId: Int, discountValue: Double,  discountType: enumDiscountTypes, promotionId: Int?){
        let discount = WorkOrderDetailDiscounts()
        
        discount.OrderDetailId = UUID.init(uuidString: orderDetail.OrderDetailId)!
        discount.DiscountCauseId = discountCauseId
        discount.DiscountType = discountType.rawValue
        discount.DiscountValue = discountValue
        discount.PromotionId = promotionId
        
        if orderDetail.discounts == nil{
            orderDetail.discounts = []
        }
        
        orderDetail.discounts?.append(discount)
        
        if orderDetail.DiscountValue != nil {
            orderDetail.DiscountValue! += discountValue
        }
        else{
            orderDetail.DiscountValue = discountValue
        }
    }
    
    private func recalculateParentTotals(parent: WorkOrderDetail){
        let childs = self.getChildCollection(parentId: parent.OrderDetailId)
        if childs.count > 0{
            parent.NetRowValueVatIncluded = 0
            parent.GrossUnitValueVatIncluded  = 0
            parent.DiscountValue  = 0
        
            for child in childs{
                parent.NetRowValueVatIncluded += child.NetRowValueVatIncluded
                parent.GrossUnitValueVatIncluded += child.GrossUnitValueVatIncluded * child.OrderedQuantity
                if let discount = child.DiscountValue{
                    parent.DiscountValue! += discount
                }                
            }
        }
    }
    
    func createPromoCartVouchers(promoCart: PromoShoppingCart){
        promoCart.vouchers = []
        if let voucherCode = self.VoucherCode{
            let cartVouchers = CartVouchers()
            cartVouchers.voucherCode = voucherCode
            cartVouchers.amount = self.VoucherValue
            promoCart.vouchers.append(cartVouchers)
        }
    }
    
    func createPromoShoppingCart() -> PromoShoppingCart {
        let promoCart = PromoShoppingCart()
        //self.createPromoCartVouchers(promoCart: promoCart)
        promoCart.storeId = State.storeId
        promoCart.cashRegister = State.cashRegister
        promoCart.contactId = UUID.init(uuidString: contact.ContactId)
        
        if let fidelity = contact.FidelityCard{
            promoCart.fidelityCardId = UUID.init(uuidString: fidelity.contactId)
            
            promoCart.paybackCard = PaybackCard()
            promoCart.paybackCard?.cardNumber = fidelity.cardBarcode
            promoCart.paybackCard?.fidelityCardId = UUID.init(uuidString: fidelity.contactId)
        }

        for var item in self.OrderDetail {
            if item.RowType == rowTypeEnum.glasses.rawValue{
                continue
            }
            
            if item.canApplyPromotions{
                self.clearOrderDetailDiscount(orderDetail: &item, discountType: enumDiscountTypes.MC)
                self.clearOrderDetailDiscount(orderDetail: &item, discountType: enumDiscountTypes.MA)
            }
            
            let promoItem = PromoCartItem()
            promoItem.rowNumber = item.OrderDetailRowNumber
            promoItem.productCode = item.ProductCode
            promoItem.styleId = item.StyleId
            
            promoItem.barcode = item.Barcode
            
            //Used for calculating the promotions
            promoItem.originalUnitValueVatIncluded = Decimal(item.GrossUnitValueVatIncluded)
            //Used to save the transaction. Not used by promo engine
            promoItem.grossUnitValueVatIncluded = item.GrossUnitValueVatIncluded
            promoItem.rowDiscountValue = item.DiscountValue
            promoItem.netRowValueVatIncluded = item.NetRowValueVatIncluded
            
            promoItem.quantity = item.OrderedQuantity
            promoItem.canApplyPromotions = item.canApplyPromotions
            promoItem.fiscalExpenseTypeId = item.FiscalExpenseTypeId
            
            promoItem.rowType = item.RowType ?? ""
            promoItem.itemTemplateCode = item.itemTemplateCode
            
            promoCart.items.append(promoItem)
        }
        return promoCart
    }
    
    func createPromoShoppingCartOutsideConfigurator() -> PromoShoppingCart {
        let promoCart = PromoShoppingCart()
        self.createPromoCartVouchers(promoCart: promoCart)
        promoCart.storeId = State.storeId
        promoCart.cashRegister = State.cashRegister
        promoCart.contactId = UUID.init(uuidString: contact.ContactId)
        
        if let fidelity = contact.FidelityCard{
            promoCart.fidelityCardId = UUID.init(uuidString: fidelity.contactId)
            
            promoCart.paybackCard = PaybackCard()
            promoCart.paybackCard?.cardNumber = fidelity.cardBarcode
            promoCart.paybackCard?.fidelityCardId = UUID.init(uuidString: fidelity.contactId)
        }
        
        for item in self.OrderDetail {
            if item.ParentOrderDetailId != nil{
                continue
            }
                        
            let promoItem = PromoCartItem()
            promoItem.rowNumber = item.OrderDetailRowNumber
            promoItem.productCode = item.ProductCode
            promoItem.styleId = item.StyleId
            
            promoItem.barcode = item.Barcode
            
            //Used for calculating the promotions
            promoItem.originalUnitValueVatIncluded = Decimal(item.GrossUnitValueVatIncluded)
            //Used to save the transaction. Not used by promo engine
            promoItem.grossUnitValueVatIncluded = item.GrossUnitValueVatIncluded
            promoItem.rowDiscountValue = item.DiscountValue
            promoItem.netRowValueVatIncluded = item.NetRowValueVatIncluded
            
            promoItem.quantity = item.OrderedQuantity
            
            if item.IsOriginalPriceChanged == true
                || item.applyPromoEngine == false
                || item.canApplyPromotions == false
                //|| item.RowType == "GL"
            {
                promoItem.canApplyPromotions = false
            }
            else{
                promoItem.canApplyPromotions = true
            }
            
            promoItem.fiscalExpenseTypeId = item.FiscalExpenseTypeId
            
            promoItem.rowType = item.RowType ?? ""
            promoItem.itemTemplateCode = item.itemTemplateCode
            
            promoCart.items.append(promoItem)
        }
        return promoCart
    }
    
    func isValidForSendingToHI(orderDetail: WorkOrderDetail) -> Bool{
        if self.contact.FiscalCode == nil || self.contact.FiscalCode == "" || self.contact.IsLegalPerson!{
            return false
        }
        
        if orderDetail.FiscalExpenseTypeId != nil {
            return true
        }
        else{
            for detail in self.OrderDetail{
                if detail.ParentOrderDetailId == orderDetail.OrderDetailId {
                    if detail.FiscalExpenseTypeId != nil{
                        return true
                    }
                }
            }
        }
        return false
    }
    
    func getSaleStateName() -> String{
        switch SaleState {
        case 0:
            return Util.getString("Quotation")
        case 1:
            return Util.getString("Not confirmed")
        case 2:
            return Util.getString("Preparing")
        case 3:
            return Util.getString("Partially ready")
        case 4:
            return Util.getString("Ready")
        case 5:
            return Util.getString("Closed")
        case 6:
            return Util.getString("Canceled")
        default:
            return ""
        }
    }
    
    func getNumberOfHeaders() -> Int{
        var count = 0
        for detail in self.OrderDetail{
            if detail.ParentOrderDetailId == nil{
                count += 1
            }
        }
        return count
    }
    
    func getOrderDetailByKey(orderDetailId: String) -> WorkOrderDetail?{
        for detail in self.OrderDetail{
            if detail.OrderDetailId == orderDetailId{
                return detail
            }
        }
        return nil
    }
    
    func getChildCollection(parentId: String) -> [WorkOrderDetail]{
        var childs: [WorkOrderDetail] = []
        for detail in self.OrderDetail{
            if detail.ParentOrderDetailId == parentId{
                childs.append(detail)
            }
        }
        return childs
    }
    
    func getHeaderCollection() -> [WorkOrderDetail]{
        var header: [WorkOrderDetail] = []
        for detail in self.OrderDetail{
            if detail.ParentOrderDetailId == nil{
                header.append(detail)
            }
        }
        return header
    }
    
    func getNextDetailRowNumber() -> Int{
        var max = 0
        for detail in self.OrderDetail{
            if detail.OrderDetailRowNumber > max{
                max = detail.OrderDetailRowNumber
            }
            for child in getChildCollection(parentId: detail.OrderDetailId){
                if child.OrderDetailRowNumber > max {
                    max = child.OrderDetailRowNumber
                }
            }
        }
        return max + 1
    }
    
    func getExtra(parentId: String) -> [WorkOrderDetail] {
        var extras = [WorkOrderDetail]()
        for child in getChildCollection(parentId: parentId){
            if child.RowType == rowTypeEnum.extra.rawValue {
                extras.append(child)
            }
            if child.RowType == rowTypeEnum.defaultService.rawValue {
                extras.append(child)
            }
        }
        return extras
    }
    
    func groupDetailsByParent(){
        var sortedOrderDetails: [WorkOrderDetail] = []
        for detail in self.OrderDetail{
            if detail.ParentOrderDetailId == nil {
                sortedOrderDetails.append(detail)
                let childs = self.getChildCollection(parentId: detail.OrderDetailId)
                
                sortedOrderDetails.append(contentsOf: self.groupChildsByRowType(childs: childs))
            }
        }
        self.OrderDetail = sortedOrderDetails
    }
    
    func groupChildsByRowType(childs: [WorkOrderDetail]) -> [WorkOrderDetail]{
        var sortedOrderDetails: [WorkOrderDetail] = []
        var frames: [WorkOrderDetail] = []
        var lens: [WorkOrderDetail] = []
        var extras: [WorkOrderDetail] = []
        
        for child in childs{
            if child.RowType == rowTypeEnum.frame.rawValue{
                frames.append(child)
            }
            else if child.RowType == rowTypeEnum.leftLens.rawValue || child.RowType == rowTypeEnum.rightLens.rawValue{
                lens.append(child)
            }
            else if child.RowType == rowTypeEnum.extra.rawValue{
                extras.append(child)
            }
            else if child.RowType == rowTypeEnum.defaultService.rawValue{
                extras.append(child)
            }
        }
        sortedOrderDetails.append(contentsOf: frames)
        sortedOrderDetails.append(contentsOf: lens)
        sortedOrderDetails.append(contentsOf: extras)
        
        return sortedOrderDetails
    }
    
    func clone() -> WorkOrder{
        let clone = WorkOrder()
        
        clone.OrderId  = self.OrderId
        clone.OrderNumber  = self.OrderNumber
        clone.Name  = self.Name
        clone.ExternalCode  = self.ExternalCode
        clone.Barcode  = self.Barcode
        clone.CreateContactId  = self.CreateContactId
        clone.CreateStoreId  = self.CreateStoreId
        clone.CreateCompanyId  = self.CreateCompanyId
        clone.AlternativeAddressId  = self.AlternativeAddressId
        clone.DestinationStoreId  = self.DestinationStoreId
        clone.DeliveryStoreId  = self.DeliveryStoreId
        clone.CreateTime  = self.CreateTime
        clone.CreateUserId  = self.CreateUserId
        clone.DeliveryDate  = self.DeliveryDate
        clone.OrderTypeId  = self.OrderTypeId
        clone.PaymentTypeId  = self.PaymentTypeId
        clone.CertifyTime  = self.CertifyTime
        clone.Notes  = self.Notes
        clone.CloseTime  = self.CloseTime
        clone.SupplierCompanyId  = self.SupplierCompanyId
        clone.ExpireTime  = self.ExpireTime
        clone.IsInvoiceMandatory  = self.IsInvoiceMandatory
        clone.PrintInvoice  = self.PrintInvoice
        clone.CancelTime  = self.CancelTime
        clone.VoucherValue  = self.VoucherValue
        clone.NetValueVatIncluded  = self.NetValueVatIncluded
        clone.LastActionIndex  = self.LastActionIndex
        clone.TotalGrossValueVatExcluded  = self.TotalGrossValueVatExcluded
        clone.TrackingNumber  = self.TrackingNumber
        clone.GrossValueVatIncluded  = self.GrossValueVatIncluded
        clone.DiscountValue  = self.DiscountValue
        clone.AdvanceRequiredValue  = self.AdvanceRequiredValue
        clone.AdvancePayedValue  = self.AdvancePayedValue
        clone.CurrencyId  = self.CurrencyId
        clone.SaleState  = self.SaleState
        clone.ModifyTime  = self.ModifyTime
        clone.TransferTime  = self.TransferTime
        clone.ReceivedTime  = self.ReceivedTime
        clone.ReceivedState  = self.ReceivedState
        clone.VatId  = self.VatId
        clone.contact = self.contact
        clone.OrderAction = self.OrderAction
        clone.payments = self.payments
        clone.isRecalculated = self.isRecalculated
        clone.change = self.change
        clone.totalPayed = self.totalPayed
        clone.AllowSendToHealthInsurance = self.AllowSendToHealthInsurance
        clone.posAllowModifyContact = self.posAllowModifyContact
        clone.posAllowAddProducts = self.posAllowAddProducts
        clone.posAllowChangePrices = self.posAllowChangePrices
        clone.posAllowApplyPromotions = self.posAllowApplyPromotions
        clone.VoucherCode = self.VoucherCode
        clone.VoucherUnlockCode = self.VoucherUnlockCode
        clone.voucherInfo = self.voucherInfo
        clone.isVoucherCumulative = self.isVoucherCumulative
        
        clone.workOrderSale = self.workOrderSale
        
        for detail in self.OrderDetail{
            clone.OrderDetail.append(detail.clone())
        }
        
        return clone
    }
}
