//
//  WorkOrderDetail.swift
//  iPOS
//
//  Created by bbc on 07.04.2017.
//  Copyright © 2017 BBC. All rights reserved.
//

import Foundation
import ObjectMapper


enum EnumDetailSaleState: Int {
    case Quotation = 0
    case NotConfirmed = 1
    case Preparing = 4
    case Reserved = 6
    case OrderedToSupplier = 5
    case Arrived = 7
    case PartiallyArrived = 8
    case Ready = 9
    case Delivered = 2
    case Returned = 3
    case PartiallyReady = 10
    case Canceled = 11
}

class WorkOrderDetail: Mappable {
    var cartItems: [DetailItem]
    var OrderDetailId: String
    var OrderId: String
    var ParentOrderDetailId: String?
    var OrderDetailRowNumber: Int = 0
    var RowType: String?
    var Barcode : String?
    var ProductCode: String?
    var ProductName: String?
    var productFamilyName: String!
    var productFamilyCode: String!
    var productSubfamilyName: String!
    var productSubfamilyCode: String!
    var StyleId: Int
    var OrderedQuantity: Double
    var UnitOfMeasureName: String?
    var GrossUnitValueVatIncluded : Double = 0
    var DiscountValue : Double?
    var NetRowValueVatIncluded: Double = 0
    var VatId: Int?
    var VatRate: Double?
    var VatValue: Double?
    var ApprovedQuantity: Double?
    var WorkApprovedQuantity: Double?
    var ApproveTime: Date?
    var ProcessTime: Date?
    var CloseTime : Date?
    var SN: String?
    var IsOriginalPriceChanged: Bool?
    var DeliveredQuantity: Double?
    var ReturnedQuantity: Double?
    var SaleState : Int = 0
    var PurchaseState: Int?
    var Notes : String?
    var OriginalPrice: Double?
    var FiscalPrinterDepartment: Int?
    var OperationType : String?
    var PrintType : String?
    var isChecked: Bool = false
    var FiscalExpenseTypeId: Int?
    var MedicalDevice: Bool?
    var FiscalExpenseType: FiscalExpenseTypes?
    var canApplyPromotions: Bool = true
    var itemTemplateId: Int?
    var itemTemplate: ItemTemplate?
    var discounts: [WorkOrderDetailDiscounts]?
    var orderDetailGlasses: WorkOrderDetailGlasses?
    var itemTemplateCode : String = ""
    var applyPromoEngine : Bool = true
    var Customizations: [WorkOrderDetailCustomizations] = [WorkOrderDetailCustomizations]()
    var Effects: [Effect]?
    
    func mapping(map: Map) {
        OrderDetailId <- map["OrderDetailId"]
        OrderId <- map["OrderId"]
        ParentOrderDetailId <- map["ParentOrderDetailId"]
        OrderDetailRowNumber <- map["OrderDetailRowNumber"]
        RowType <- map["RowType"]
        Barcode <- map["Barcode"]
        ProductCode <- map["ProductCode"]
        ProductName <- map["ProductName"]
        StyleId <- map["StyleId"]
        OrderedQuantity <- (map["OrderedQuantity"], Util.CustomDoubleTransformQuantities())
        UnitOfMeasureName <- map["UnitOfMeasureName"]
        GrossUnitValueVatIncluded <- (map["GrossUnitValueVatIncluded"], Util.CustomDoubleTransform())
        DiscountValue <- (map["DiscountValue"], Util.CustomDoubleTransform())
        NetRowValueVatIncluded <- (map["NetRowValueVatIncluded"], Util.CustomDoubleTransform())
        VatId <- map["VatId"]
        VatRate <- (map["VatRate"], Util.CustomDoubleTransform())
        VatValue <- (map["VatValue"], Util.CustomDoubleTransform())
        ApprovedQuantity <- (map["ApprovedQuantity"], Util.CustomDoubleTransform())
        WorkApprovedQuantity <- map["WorkApprovedQuantity"]
        ApproveTime <- map["ApproveTime"]
        ProcessTime <- map["ProcessTime"]
        CloseTime <- map["CloseTime"]
        SN <- map["SN"]
        IsOriginalPriceChanged <- map["IsOriginalPriceChanged"]
        DeliveredQuantity <- (map["DeliveredQuantity"], Util.CustomDoubleTransform())
        ReturnedQuantity <- (map["ReturnedQuantity"], Util.CustomDoubleTransform())
        SaleState <- map["SaleState"]
        PurchaseState <- map["PurchaseState"]
        Notes <- map["Notes"]
        OriginalPrice <- (map["OriginalPrice"], Util.CustomDoubleTransform())
        FiscalPrinterDepartment <- map["FiscalPrinterDepartment"]
        OperationType <- map["OperationType"]
        PrintType <- map["PrintType"]
        FiscalExpenseTypeId <- map["FiscalExpenseTypeId"]
        MedicalDevice <- map["MedicalDevice"]
        FiscalExpenseType <- map["FiscalExpenseTypes"]
        itemTemplateId <- map["ItemTemplateId"]
        itemTemplate <- map["ItemTemplates"]
        discounts <- map["OrderDetailDiscounts"]
        orderDetailGlasses <- map["OrderDetailGlasses"]
        applyPromoEngine <- map["ApplyPromoEngine"]        
        productFamilyName <- map["ProductFamilyName"]
        productFamilyCode <- map["ProductFamilyCode"]
        productSubfamilyName <- map["ProductSubfamilyName"]
        productSubfamilyCode <- map["ProductSubfamilyCode"]
        Customizations <- map["OrderDetailCustomizations"]
    }
    
    var grossRowValueVatIncluded: Double{
        get{
            return self.GrossUnitValueVatIncluded * self.OrderedQuantity
        }
    }
    
    var childrenTotalGrossValue: Double{
        get{
            var sum: Double = 0
            if(self.ParentOrderDetailId == nil){
                for child in State.workOrder.OrderDetail{
                    if(child.ParentOrderDetailId == self.OrderDetailId){
                        sum += child.GrossUnitValueVatIncluded * child.OrderedQuantity
                    }
                }
            }
            return sum
        }
    }
    
    var internalDiscountsTotalValue: Double{
        get{
            var discountValue: Double = 0
            
            if let discounts = self.discounts{
                for discount in discounts{
                    if discount.DiscountType == enumDiscountTypes.PR.rawValue || discount.DiscountType == enumDiscountTypes.MA.rawValue{
                        continue
                    }
                    else{
                        if let dv = discount.DiscountValue{
                            discountValue += dv
                        }
                    }
                }
            }
            return discountValue
        }
    }
    
    var kitExternalDiscountsTotalValue: Double{
        get{
            var discountValue: Double = 0
            
            if let discounts = self.discounts{
                for discount in discounts{
                    if discount.DiscountType == enumDiscountTypes.PR.rawValue || discount.DiscountType == enumDiscountTypes.MA.rawValue{
                        if let dv = discount.DiscountValue{
                            discountValue += dv
                        }
                    }
                }
            }
            return discountValue
        }
    }
    
    var discountsTotalValue: Double{
        get{
            var sum: Double = 0
            
            if let discounts = self.discounts{
                for discount in discounts{
                    if let dv = discount.DiscountValue{
                        sum += dv
                    }
                }
            }
            return sum
        }
    }
    
    var vatRate: Double{
        get{
            var vatRate: Double = 0
            if let vr = self.VatRate{
                vatRate = vr
            }
            return (vatRate).rounded(toPlaces: 2)
        }
    }
    
    var netRowValueVatExcluded: Double{
        get{
            return (self.NetRowValueVatIncluded / (1 + vatRate)).rounded(toPlaces: 2)
        }
    }
   
    var vatValue: Double{
        get{
            return  (netRowValueVatExcluded * vatRate).rounded(toPlaces: 2)
        }
    }
    
    var hasPrice: Bool{
        get{
            if self.itemTemplateId == nil{
                return false
            }
            let price = self.itemTemplate?.price ?? 0
            return price > 0
        }
    }
    
    var parentOrderDetail: WorkOrderDetail?{
        get{
            for parent in State.workOrder.OrderDetail{
                if parent.OrderDetailId == self.ParentOrderDetailId{
                    return parent
                }
            }
            return nil
        }
    }
    
    required init?(map: Map) {
        self.cartItems = [DetailItem]()
        OrderDetailId = UUID().description
        OrderId = UUID().description
        StyleId = 0
        OrderedQuantity = 0
    }
    
    init() {
        self.cartItems = [DetailItem]()
        OrderDetailId = UUID().description
        OrderId = UUID().description
        StyleId = 0
        OrderedQuantity = 0
    }
    
    func getNumberOfChild() -> Int {
        var nrOfChilds = 0
        if(ParentOrderDetailId == nil){
            for detail in State.workOrder.OrderDetail{
                if(detail.ParentOrderDetailId == OrderDetailId){
                    nrOfChilds += 1
                }
            }
        }
        return nrOfChilds
    }
    
    func getHeaderRowType() -> UIImage?{
        if let rowType = self.RowType{
            switch (rowType) {
            case "GL":
                return UIImage(named: "glasses.png")
            default:
                return UIImage(named: "defaultProduct.png")
            }
        }
        return UIImage(named: "defaultProduct.png")
    }
    
    func getDetailRowType() -> UIImage?{
        if let rowType = self.RowType{
            switch (rowType){
            case "SRV":
                return UIImage(named: "services.png")
            case "FRM":
                return UIImage(named: "frame.png")
            case "LNR":
                return UIImage(named: "lens.png")
            case "LNL":
                return UIImage(named: "lens.png")
            default:
                return nil
            }
        }
        return nil
    }
    
    func getSaleStatusImage() ->UIImage?{
        if let rowType = self.RowType{
            switch (rowType){
            case "SRV":
                return nil
            default:
                break
            }
        }
        
        switch self.SaleState{
        case 4:
            return UIImage(named: "Cancel.png")
        case 5:
            return UIImage(named: "GreenBag.png")
        case 6:
            return UIImage(named: "Ok.png")
        case 7:
            return UIImage(named: "Ok.png")
        default:
            return nil
        }
    }
    
    func getSaleStateName() -> String{
        switch (self.SaleState) {
        case 0:
            return Util.getString("Quotation")
        case 1:
            return Util.getString("Not confirmed")
        case 4:
            return Util.getString("Preparing")
        case 9:
            return Util.getString("Ready")
        case 2:
            return Util.getString("Delivered")
        case 3:
            return Util.getString("Returned")
        case 10:
            return Util.getString("Partially ready")
        case 11:
            return Util.getString("Canceled")
        default:
            return ""
        }
    }
    
    func getComponentsForDetailByKey() -> [WorkOrderDetail]{
        var orderDetail = [WorkOrderDetail]()
        for detail in State.workOrder.OrderDetail{
            if detail.ParentOrderDetailId == self.OrderDetailId{
                orderDetail.append(detail)
            }
        }
        return orderDetail
    }
    
    func convertToPriceChangeItem() -> PriceChangeItem{
        let item: PriceChangeItem = PriceChangeItem()
        item.rowNumber = self.OrderDetailRowNumber
        item.name = self.ProductName!
        item.code = self.ProductCode!
        item.originalPrice = self.OriginalPrice == nil ? 0 : self.OriginalPrice!
        item.netRowValue = self.NetRowValueVatIncluded
        item.grossUnitValue = self.GrossUnitValueVatIncluded
        item.quantity = self.OrderedQuantity
        item.discountValue =  self.DiscountValue == nil ? 0 : self.DiscountValue!
        return item
    }
    
    func convertGlassesToPriceChangeItem() -> PriceChangeItem{
        let item: PriceChangeItem = PriceChangeItem()
        item.rowNumber = self.OrderDetailRowNumber
        item.name = self.ProductName!
        item.code = self.ProductCode!
        item.originalPrice = self.OriginalPrice == nil ? 0 : self.OriginalPrice!
        item.netRowValue = self.NetRowValueVatIncluded
        item.grossUnitValue = (self.NetRowValueVatIncluded / self.OrderedQuantity) + self.kitExternalDiscountsTotalValue
        item.quantity = self.OrderedQuantity
        item.discountValue =  self.kitExternalDiscountsTotalValue
        return item
    }
    
    func importPriceChanges(result: PriceChangeResult){
        self.NetRowValueVatIncluded = result.netRowValueVatIncluded
        self.GrossUnitValueVatIncluded = result.grossUnitValueVatIncluded
        self.DiscountValue = result.discountValue
        self.canApplyPromotions = result.canApplyPromotions
        self.VatValue = Util.DoubleToDoubleRoundedWithTwoDecimalPlaces(self.NetRowValueVatIncluded * self.VatRate!)
    }
    
    func addEffect(discountCause: DiscountCauses, rowNumber: Int, discountValue: Double, discountPercentage: Double, effectCategory: String){
        let effect = Effect()
        effect.discountCauseId = discountCause.discountCauseId
        effect.rowNumber = rowNumber
        effect.rowDiscountValue = discountValue
        effect.effectCategory = effectCategory
        effect.rowDiscountPercent = discountPercentage
        effect.isManualDiscount = true
                
        self.Effects = [effect]
    }
    
    func clone() -> WorkOrderDetail{
        let clone = WorkOrderDetail()
        clone.OrderDetailId = self.OrderDetailId
        clone.OrderId = self.OrderId
        clone.ParentOrderDetailId = self.ParentOrderDetailId
        clone.OrderDetailRowNumber = self.OrderDetailRowNumber
        clone.RowType = self.RowType
        clone.Barcode  = self.Barcode
        clone.ProductCode = self.ProductCode
        clone.ProductName = self.ProductName
        clone.StyleId = self.StyleId
        clone.OrderedQuantity = self.OrderedQuantity
        clone.UnitOfMeasureName = self.UnitOfMeasureName
        clone.GrossUnitValueVatIncluded  = self.GrossUnitValueVatIncluded
        clone.DiscountValue  = self.DiscountValue
        clone.NetRowValueVatIncluded = self.NetRowValueVatIncluded
        clone.VatId = self.VatId
        clone.VatRate = self.VatRate
        clone.VatValue = self.VatValue
        clone.ApprovedQuantity = self.ApprovedQuantity
        clone.WorkApprovedQuantity = self.WorkApprovedQuantity
        clone.ApproveTime = self.ApproveTime
        clone.ProcessTime = self.ProcessTime
        clone.CloseTime  = self.CloseTime
        clone.SN = self.SN
        clone.IsOriginalPriceChanged = self.IsOriginalPriceChanged
        clone.DeliveredQuantity = self.DeliveredQuantity
        clone.ReturnedQuantity = self.ReturnedQuantity
        clone.SaleState  = self.SaleState
        clone.PurchaseState = self.PurchaseState
        clone.Notes  = self.Notes
        clone.OriginalPrice = self.OriginalPrice
        clone.FiscalPrinterDepartment = self.FiscalPrinterDepartment
        clone.OperationType  = self.OperationType
        clone.PrintType  = self.PrintType
        clone.isChecked = self.isChecked
        clone.FiscalExpenseTypeId = self.FiscalExpenseTypeId
        clone.MedicalDevice = self.MedicalDevice
        clone.FiscalExpenseType = self.FiscalExpenseType
        clone.itemTemplateId = self.itemTemplateId
        clone.itemTemplate = self.itemTemplate
        clone.canApplyPromotions = self.canApplyPromotions
        clone.itemTemplateCode = self.itemTemplateCode
        clone.applyPromoEngine = self.applyPromoEngine
        clone.productFamilyCode = self.productFamilyCode
        clone.productFamilyName = self.productFamilyName
        clone.productSubfamilyCode = self.productSubfamilyCode
        clone.productSubfamilyName = self.productSubfamilyName
     
        if let discounts = self.discounts{
            clone.discounts = []
            for discount in discounts{
                clone.discounts?.append(discount.clone())
            }
        }
        
        clone.orderDetailGlasses = self.orderDetailGlasses
        clone.Customizations = self.Customizations
        
        return clone
    }
}

class DetailItem {
    var barcodeInfo: WSBarcodeInfo
    var canApplyPromotions: Bool
    var Quantity: Double
    var GrossUnitValue: Double
    var PromotionId: Int?
    var DiscountValue: Double
    var DiscountPercentage: Double
    var DistributedDiscount: Double
    var NetRowValue: Double
    var RowNumber: Int
    var Effects: [Effect]?
    var fiscalExpenseTypeId: Int?
    var fiscalExpenseTypeCode: String?
    var serialNumber: String?
    var rowTypeId: Int = 1
    
    init() {
        barcodeInfo = WSBarcodeInfo()
        Quantity = 0
        GrossUnitValue = 0
        DiscountValue = 0
        DiscountPercentage = 0
        DistributedDiscount = 0
        NetRowValue = 0
        RowNumber = 1
        canApplyPromotions = true
    }
    
    func convertToPriceChangeItem() -> PriceChangeItem{
        let item: PriceChangeItem = PriceChangeItem()
        item.rowNumber = self.RowNumber
        item.name = self.barcodeInfo.Name
        item.code = self.barcodeInfo.Code
        item.originalPrice = self.barcodeInfo.SalePrice
        item.netRowValue = self.NetRowValue
        item.grossUnitValue = self.GrossUnitValue
        item.quantity = self.Quantity
        item.discountValue = self.DiscountValue
        item.discountPercentage = self.DiscountPercentage
        return item
    }
    
    func importPriceChanges(result: PriceChangeResult){
        self.NetRowValue = result.netRowValueVatIncluded
        self.GrossUnitValue = result.grossUnitValueVatIncluded
        self.DiscountValue = result.discountValue
        self.DiscountPercentage = result.discountPercentage
        self.canApplyPromotions = result.canApplyPromotions
    }
    
    func addEffect(discountCause: DiscountCauses, rowNumber: Int, discountValue: Double, discountPercentage: Double, effectCategory: String){
        let effect = Effect()
        effect.discountCauseId = discountCause.discountCauseId
        effect.rowNumber = rowNumber
        effect.rowDiscountValue = discountValue
        effect.effectCategory = effectCategory
        effect.rowDiscountPercent = discountPercentage
        effect.isManualDiscount = true
                
        self.Effects = [effect]
    }
    
    var vatRate: Double{
        get{
            var vatRate: Double = 0
            if let vr = self.barcodeInfo.VatRate{
                vatRate = vr
            }
            return (vatRate).rounded(toPlaces: 2)
        }
    }
    
    var netRowValueVatExcluded: Double{
        get{
            return (self.NetRowValue / (1 + vatRate)).rounded(toPlaces: 2)
        }
    }
    
    var vatValue: Double{
        get{
            return  (netRowValueVatExcluded * vatRate).rounded(toPlaces: 2)
        }
    }
}
