//
//  WorkOrderActionViewController.swift
//  iPOS
//
//  Created by bbc on 09.02.2017.
//  Copyright © 2017 BBC. All rights reserved.
//

import Foundation
import UIKit

class PayAdvenceViewController: UIViewController, UITextFieldDelegate,UIPopoverPresentationControllerDelegate, PaymentViewControllerDelegate {
    @IBOutlet weak var advancedPaymentSlider: UISlider!
    @IBOutlet weak var tfAdvancedPaymentSliderValue: UITextField!
    @IBOutlet weak var payButton: UIButton!
    
    var remainingValueToPay = Float(0)
    var recomandedValueToPay = Float(0)
    var ingenicoTransactionResponse: PTTransactionResult?
    var minimumAdvanceRequired = Float(0)
    let sliderStep: Double = 10
    
    var electronicPayments: [Payment] = []
    
    override func viewDidLoad() {
        super.viewDidLoad()
        self.tfAdvancedPaymentSliderValue.delegate = self
        let tap: UITapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(dismissKeyboard))
        view.addGestureRecognizer(tap)
        
        self.remainingAdvanceValueToPay()
        
        self.advancedPaymentSlider.minimumValue = 0
        self.advancedPaymentSlider.maximumValue = Float(self.remainingValueToPay)
        self.advancedPaymentSlider.setValue(self.recomandedValueToPay, animated: true)
        
        self.tfAdvancedPaymentSliderValue.text = Float(self.advancedPaymentSlider.value).description
        self.tfAdvancedPaymentSliderValue.addTarget(self, action: #selector(textFieldDidChange(_:)), for: .editingChanged)
    }
    
    func getRemaininValueIncludingAdvance()->Double{
        return State.workOrder.remainingValueToDeliver - State.workOrder.advanceRemainingValue
    }

    func getMinimumAdvance() -> Int {
        var minim: Int = 0
        for detail in State.workOrder.OrderDetail{
            if detail.itemTemplate != nil{
                if detail.itemTemplate?.minimumAdvanceRequired != nil{
                    minim = detail.itemTemplate!.minimumAdvanceRequired
                }
            }
        }
        return minim
    }
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        self.electronicPayments = []
    }
    
    /*func remainingAdvanceValueToPay(){
        let remaininValueIncludintAdvance = self.getRemaininValueIncludingAdvance()
        let minimumAdvanceRequired = self.getMinimumAdvance()
        
        if settings.storeSetupSettings.advanceRequiredValue == 100{
            self.remainingValueToPay = Float(remaininValueIncludintAdvance)
            self.recomandedValueToPay = Float(remaininValueIncludintAdvance)
        }
        else{
            let advancePercent: Double = Double(settings.storeSetupSettings.advanceRequiredValue)/100
            let minimAdvanceRequiredPercent: Double = Double(minimumAdvanceRequired)/100
            if minimAdvanceRequiredPercent > advancePercent{
                let value: Double = Double(minimAdvanceRequiredPercent * remaininValueIncludintAdvance)
                let rest: Double = Double(value.round(nearest: sliderStep))
                self.remainingValueToPay = Float(remaininValueIncludintAdvance)
                self.recomandedValueToPay = Float(value)
                self.minimumAdvanceRequired = Float(value)
            }
            else {
            let value: Double = Double(advancePercent * remaininValueIncludintAdvance)
            let rest: Double = Double(value.round(nearest: sliderStep))
            self.remainingValueToPay = Float(remaininValueIncludintAdvance)
            self.recomandedValueToPay = Float(rest)
            }
        }
    }*/
    func remainingAdvanceValueToPay() {
        let remaininValueIncludintAdvance = self.getRemaininValueIncludingAdvance()
        let minimumAdvanceRequired = self.getMinimumAdvance()
        
        if settings.storeSetupSettings.advanceRequiredValue == 100 {
            self.remainingValueToPay = Float(remaininValueIncludintAdvance)
            self.recomandedValueToPay = Float(remaininValueIncludintAdvance)
        } else {
            let advancePercent: Double = Double(settings.storeSetupSettings.advanceRequiredValue) / 100
            let minimAdvanceRequiredPercent: Double = Double(minimumAdvanceRequired) / 100
            
            if minimAdvanceRequiredPercent > advancePercent {
                let value: Double = minimAdvanceRequiredPercent * remaininValueIncludintAdvance
                var roundedDownValue: Double = floor(value / 5) * 5
                if(minimAdvanceRequiredPercent == 1)
                {
                    roundedDownValue = value
                }
                   
                self.remainingValueToPay = Float(remaininValueIncludintAdvance)
                self.recomandedValueToPay = Float(roundedDownValue)
                self.minimumAdvanceRequired = Float(roundedDownValue)
            } else {
                let value: Double = advancePercent * remaininValueIncludintAdvance
                let roundedDownValue: Double = floor(value / 5) * 5  
                
                self.remainingValueToPay = Float(remaininValueIncludintAdvance)
                self.recomandedValueToPay = Float(roundedDownValue)
            }
        }
    }

    
    @objc func dismissKeyboard() {
        view.endEditing(true)
    }
    
    func textFieldShouldReturn(_ textField: UITextField) -> Bool {
        view.endEditing(true)
        return true
    }
    
    func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
        if textField == self.tfAdvancedPaymentSliderValue {
            if string != "" {
                if range.location == 0 && range.length == textField.text?.count{
                    if Util.isTextDoubleValue(value: string){
                        return true
                    }
                    return false
                }
                else{
                    if Util.isTextDoubleValue(oldText: &textField.text!, newText: string){
                        return true
                    }
                    return false
                }
            }
        }
        return true
    }
    
    @objc func textFieldDidChange(_ textField: UITextField) {
        if(self.tfAdvancedPaymentSliderValue.text == ""){
            self.advancedPaymentSlider.setValue(Float(0), animated: false)
        }
        else{
            if let currentValue = Float(tfAdvancedPaymentSliderValue.text!){
                if(currentValue < 0){
                    self.tfAdvancedPaymentSliderValue.text = "0"
                }
                else if(currentValue > Float(self.remainingValueToPay)) {
                    self.tfAdvancedPaymentSliderValue.text = String(Float(self.remainingValueToPay))
                    self.advancedPaymentSlider.setValue(Float(self.remainingValueToPay), animated: false)
                }
                else if (currentValue < Float(self.minimumAdvanceRequired)){
                    self.tfAdvancedPaymentSliderValue.text = String(Float(self.minimumAdvanceRequired))
                    self.advancedPaymentSlider.setValue(Float(self.minimumAdvanceRequired), animated: false)
                }
                else{
                    self.advancedPaymentSlider.setValue(currentValue, animated: true)
                }
            }
            else{
                self.tfAdvancedPaymentSliderValue.text = "0"
            }
        }
    }
    
    @IBAction func advancePaymentSlider_ValueChanged(_ sender: Any) {
        let advancedPaymentSlider = (Double(self.advancedPaymentSlider.value) / sliderStep) * sliderStep
        let value = round(advancedPaymentSlider * 100) / 100.0
        if Float(value) > self.remainingValueToPay {
            self.tfAdvancedPaymentSliderValue.text = self.remainingValueToPay.description
        }
        else{
            if self.advancedPaymentSlider.value == self.advancedPaymentSlider.maximumValue{
                self.tfAdvancedPaymentSliderValue.text = self.remainingValueToPay.description
            }
            else if self.advancedPaymentSlider.value < self.minimumAdvanceRequired {
                self.tfAdvancedPaymentSliderValue.text = self.minimumAdvanceRequired.description
                self.advancedPaymentSlider.setValue(Float(minimumAdvanceRequired), animated: true)
            }
            else{
                self.tfAdvancedPaymentSliderValue.text = value.description
                self.advancedPaymentSlider.setValue(Float(value), animated: true)
            }
        }
    }
    
    private func validateModifyTime(completionHandler: @escaping(Bool) -> Void){
        var isValid = true
        State.getOrderModifyTime { result in
            if let modifyTime = result{
                if modifyTime != State.workOrder.ModifyTime{
                    isValid = false
                }
            }
            else{
                isValid = false
            }
            completionHandler(isValid)
        }
    }
    
    @IBAction func payAdvancedPayment_Click(_ sender: Any) {
        if(self.tfAdvancedPaymentSliderValue.text == "") {
            self.tfAdvancedPaymentSliderValue.text = "0"
        }
        if let value = Double(self.tfAdvancedPaymentSliderValue.text!){
            if value > 0{
                State.workOrder.AdvancePayedValue = value
                settings.printer?.isPrinterStateIdle(completionHandler: { result in
                    if result == false{
                        return
                    }
                    else{
                        self.afterPrinterOK()
                    }
                })
                if settings.printer == nil {
                    self.afterPrinterOK()
                }
            }
            else{
                self.confirmOrderAndDetails()
            }
        }
    }
    
    func afterPrinterOK(){
        self.openPaymentType()
    }
    
    func openPaymentType(){
        let paymentViewController = self.storyboard?.instantiateViewController(withIdentifier: "paymentViewController") as! PaymentViewController
        paymentViewController.totalValueToPay = State.workOrder.AdvancePayedValue!
        paymentViewController.delegate = self
        paymentViewController.ticketType = .AdvancePayment
        
        let newPaymentViewController = self.storyboard?.instantiateViewController(withIdentifier: "newPaymentViewController") as! NewPaymentViewController
        newPaymentViewController.delegate = paymentViewController.self
        newPaymentViewController.payments = paymentViewController.payments
        newPaymentViewController.remainingValueToPay = State.workOrder.AdvancePayedValue!
        newPaymentViewController.ticketType = .AdvancePayment
        
        if State.workOrder.AdvancePayedValue! == 0{
            let paymentType = State.paymentType.first(where: { $0.Code == PaymentTypeString.CASH })!
            let payment = newPaymentViewController.newPaymentTypeSelected(paymentType: paymentType, amount: 0)
            paymentViewController.payments = [payment]
            self.navigationController?.pushViewController(paymentViewController, animated: true)
        }
        else if State.workOrder.AdvancePayedValue! > 0{
            self.navigationController?.pushViewController(paymentViewController, animated: false)
            self.navigationController?.pushViewController(newPaymentViewController, animated: true)
        }
        else{
            Util.AlertOperationNotAllowed(viewController: self, message: "You can not have the receipt with the negative value")
        }
    }
    
    func cancelTicket() {
        self.endPayment()
    }
    
    func printTicket(payments: [Payment], totalValueToPay: Double, remainingValueToPay: Double, totalValuePayed: Double, change: Double) {
        self.validateModifyTime { isValid in
            if isValid == false{
                Util.AlertOperationNotAllowed(viewController: self, message: Util.getString("OrderChanged"))
            }
            else{
                State.getNextTransactionNumber {
                    State.workOrder.payments = payments
                    State.workOrder.totalPayed = totalValuePayed
                    State.workOrder.change = change
                    
                    State.workOrder.workOrderSale.VoucherValue = totalValuePayed - change
                    State.workOrder.workOrderSale.payments = payments
                    State.workOrder.workOrderSale.TotalAmount = State.workOrder.NetValueVatIncluded
                    State.workOrder.workOrderSale.RestValue = change
                    State.workOrder.workOrderSale.StoreId = Int(settings.StoreId)!
                    State.workOrder.workOrderSale.CashRegister = Int(settings.CashRegister)!
                    State.workOrder.workOrderSale.ActionType = "RA1"
                    State.workOrder.workOrderSale.ContactId = State.workOrder.contact.ContactId
                    State.workOrder.workOrderSale.TransactionSign = 1
                    State.workOrder.workOrderSale.TransactionNumber = State.newTransactionNumber
                    
                    if settings.userSettings.countryCode != "ITA"{
                        State.workOrder.workOrderSale.transactionTime = Util.DateToLongDateISO(date: Date())
                    }
                    
                    State.workOrder.OrderDetail = []
                    State.workOrder.OrderAction = []
                    
                    if let fiscalCode = State.workOrder.contact.FiscalCode{
                        State.workOrder.workOrderSale.ContactFiscalCode = fiscalCode
                    }
                    
                    if let userId = settings.LoggedInUserId{
                        State.workOrder.workOrderSale.CashierUserId = userId
                    }
                    
                    if State.workOrder.OrderDetail.count > 0 {
                        State.workOrder.workOrderSale.ParentOrderDetailId = State.workOrder.OrderDetail[0].OrderDetailId
                    }
                    
                    self.printReceipt()
                }
            }
        }
    }
    
    func saveTransaction(){
        State.SaveWorkOrderTransaction(workOrder: State.workOrder, completionHandler: { result in
            if (result.resultCode == -1) {
                Util.GeneralAlertWithAction(viewController: self, message: Util.getString("Could not save the transaction, check your connection and try again later."), generalAction: self.onFailureEndPayment)
                Util.writeLogCustom(eventName: "save_payment", name: "Payment", text: "Could not save the transaction, check your connection and try again later.")
                return
            }
            else if (result.resultCode == 1) {
                Util.GeneralAlertWithAction(viewController: self, message: result.resultMessage, generalAction: self.onFailureEndPayment)
                Util.writeLogCustom(eventName: "save_payment", name: "Payment", text: result.resultMessage)
                return
            }
            else if (result.resultCode == 2) {
                let msg = result.resultMessage + " " + result.resultErrorDetails
                Util.GeneralAlertWithAction(viewController: self, message: msg, generalAction: self.onFailureEndPayment)
                Util.writeLogCustom(eventName: "save_payment", name: "Payment", text: msg)
                return
            }
            else if(result.resultCode == 0){
                self.endPayment()
                Util.writeLogCustom(eventName: "save_payment", name: "Payment", text: "Transaction succeeded - \(result.transactionId) [\(result.transactionNumber)]")
            }
        })
    }
    
    func confirmOrderAndDetails(){
        State.confirmOrderAndDetails { result in
            self.goToWorkOrderDetailViewController()
        }
    }
    
    func printReceipt(){
        settings.printer?.printPaidAdvanceNonFiscal(State.workOrder, completionHandler: { result in
            if(result == true){
                Util.writeLogCustom(eventName: "print_ticket", name: "Advance_Receipt", text: "Receipt printed : \(State.receiptFiscalNumber).Try save transaction.")
                self.saveTransaction()
            }
            else if(result == false || result == nil){
                Util.writeLogCustom(eventName: "print_ticket", name: "Advance_Receipt", text: "Error print.Receipt not printed!")
                Util.AlertRetryAction(viewController: self, title: Util.getString("Receipt not printed!"), message: Util.getString("Check printer is available"), actionOnRetry: self.printReceipt, actionOnCancel: nil)
            }
            //else if(result == nil){
            //    Util.AlertRetryAction(viewController: self, title: Util.getString("Something went wrong"), message: Util.getString("Receipt not printed!"), actionOnRetry: self.printReceipt, actionOnCancel: nil)
            //}
        })
        if settings.printer == nil {
            Util.writeLogCustom(eventName: "print_ticket", name: "Advance_Receipt", text: "Printer disabled.Try save transaction without printer.")
            self.saveTransaction()
        }
    }
    
    func endPayment(){
        self.goToWorkOrderDetailViewController()
    }
    
    func onFailureEndPayment(){
        for payment in State.shoppingCart.payments{
            if Util.isOnlinePayment(paymentType: payment.paymentType){
                self.electronicPayments.append(payment)
            }
        }
        if self.electronicPayments.count > 0{
            Util.GeneralAlertWithAction(viewController: self, message: Util.getString("ElectronicPaymentsNotRegistred")) {
               self.endPayment()
            }
        }
        else{
            self.endPayment()
        }
    }

    func goToWorkOrderDetailViewController(){
        for i in 0..<self.navigationController!.viewControllers.count{
            if (self.navigationController!.viewControllers[i].isKind(of: WorkOrderDetailViewContoller.self)){
                if let viewController = self.navigationController?.viewControllers[i] {
                    _ = self.navigationController?.popToViewController(viewController, animated: false)
                    return
                }
                _ = self.navigationController?.popViewController(animated: true)
                return
            }
        }
    }
}
