//
//  ClinicalStatusDetailsViewController.swift
//  iPOS
//
//  Created by BBC on 13/10/16.
//  Copyright © 2016 BBC. All rights reserved.
//

import Foundation
import UIKit

class ClinicalStatusDetailViewController: UIViewController ,UITabBarDelegate,UITextFieldDelegate,UITabBarControllerDelegate, UITextViewDelegate, UIPopoverPresentationControllerDelegate, UIPickerViewDelegate, UIPickerViewDataSource {
    
    private var originalClinicalStatus: ClinicalStatus = ClinicalStatus()
    private var copyClinicalStatus: ClinicalStatus = ClinicalStatus()
    var clinicalStatus: ClinicalStatus {
        get { return copyClinicalStatus }
        set {
            originalClinicalStatus = newValue
            copyClinicalStatus = newValue
        }
    }
    
    @IBOutlet weak var scrollView: UIScrollView!
    @IBOutlet weak var contentView: UIView!
    @IBOutlet weak var gaugeView: UIView!
    @IBOutlet weak var headerView: UIView!
    @IBOutlet weak var headerViewHeight: NSLayoutConstraint! //105
    @IBOutlet weak var glView: UIView!
    @IBOutlet weak var glViewHeight: NSLayoutConstraint! //84
    @IBOutlet weak var clView: UIView!
    @IBOutlet weak var clViewHeight: NSLayoutConstraint! //84
    @IBOutlet weak var footerView: UIView!
    @IBOutlet weak var footerViewHeight: NSLayoutConstraint! //105
    @IBOutlet weak var editableView: UIView!
    
    @IBOutlet weak var viewFarLVL1: UIView!
    @IBOutlet weak var viewFarLVL2: UIView!
    @IBOutlet weak var viewFarLVL3: UIView!
    @IBOutlet weak var viewFarLVL4: UIView!
    @IBOutlet weak var viewFarHeight1: NSLayoutConstraint! //21
    @IBOutlet weak var viewFarHeight2: NSLayoutConstraint! //21
    @IBOutlet weak var viewFarHeight3: NSLayoutConstraint! //21
    @IBOutlet weak var viewFarHeight4: NSLayoutConstraint! //21
    
    @IBOutlet weak var viewInterLVL1: UIView!
    @IBOutlet weak var viewInterLVL2: UIView!
    @IBOutlet weak var viewInterLVL3: UIView!
    @IBOutlet weak var viewInterLVL4: UIView!
    @IBOutlet weak var viewInterHeight1: NSLayoutConstraint! //21
    @IBOutlet weak var viewInterHeight2: NSLayoutConstraint! //21
    @IBOutlet weak var viewInterHeight3: NSLayoutConstraint! //21
    @IBOutlet weak var viewInterHeight4: NSLayoutConstraint! //21
    
    @IBOutlet weak var viewNearLVL1: UIView!
    @IBOutlet weak var viewNearLVL2: UIView!
    @IBOutlet weak var viewNearLVL3: UIView!
    @IBOutlet weak var viewNearLVL4: UIView!
    @IBOutlet weak var viewNearHeight1: NSLayoutConstraint! //21
    @IBOutlet weak var viewNearHeight2: NSLayoutConstraint! //21
    @IBOutlet weak var viewNearHeight3: NSLayoutConstraint! //21
    @IBOutlet weak var viewNearHeight4: NSLayoutConstraint! //21
    
    @IBOutlet weak var tabBar: UITabBar!
    
    @IBOutlet weak var lfDistance: UILabel!

    //far right
    @IBOutlet weak var rFarAdd: UITextField!
    @IBOutlet weak var rFarSph: UITextField!
    @IBOutlet weak var rFarCylAx: UITextField!
    
    @IBOutlet weak var rFarPrism1: UITextField!
    @IBOutlet weak var rFarPrism2: UITextField!
    
    @IBOutlet weak var rFarBC: UITextField!
    @IBOutlet weak var rFarDiameter: UITextField!
    
    @IBOutlet weak var rFarSdp: UITextField!
    
    @IBOutlet weak var rFarACN: UITextField!
    @IBOutlet weak var rFarACC: UITextField!
    
    //far left
    @IBOutlet weak var lFarAdd: UITextField!
    @IBOutlet weak var lFarSph: UITextField!
    @IBOutlet weak var lFarCylAx: UITextField!
    
    @IBOutlet weak var lFarPrism1: UITextField!
    @IBOutlet weak var lFarPrism2: UITextField!
    
    @IBOutlet weak var lFarBC: UITextField!
    @IBOutlet weak var lFarDiameter: UITextField!
    
    @IBOutlet weak var lFarSdp: UITextField!
    
    @IBOutlet weak var lFarACN: UITextField!
    @IBOutlet weak var lFarACC: UITextField!
    
    @IBOutlet weak var farDpTotal: UITextField!
    //far
    
    //interright
    @IBOutlet weak var rInterAdd: UITextField!
    @IBOutlet weak var rInterSph: UITextField!
    @IBOutlet weak var rInterCylAx: UITextField!
    
    @IBOutlet weak var rInterPrism1: UITextField!
    @IBOutlet weak var rInterPrism2: UITextField!
    
    @IBOutlet weak var rInterBC: UITextField!
    @IBOutlet weak var rInterDiameter: UITextField!
    
    @IBOutlet weak var rInterSdp: UITextField!
    
    @IBOutlet weak var rInterACN: UITextField!
    @IBOutlet weak var rInterACC: UITextField!
    
    //inter left
    @IBOutlet weak var lInterAdd: UITextField!
    @IBOutlet weak var lInterSph: UITextField!
    @IBOutlet weak var lInterCylAx: UITextField!
    
    @IBOutlet weak var lInterPrism1: UITextField!
    @IBOutlet weak var lInterPrism2: UITextField!
    
    @IBOutlet weak var lInterBC: UITextField!
    @IBOutlet weak var lInterDiameter: UITextField!
    
    @IBOutlet weak var lInterSdp: UITextField!
    
    @IBOutlet weak var lInterACN: UITextField!
    @IBOutlet weak var lInterACC: UITextField!
    
    @IBOutlet weak var interDpTotal: UITextField!
    //inter
    
    //near right
    @IBOutlet weak var rNearAdd: UITextField!
    @IBOutlet weak var rNearSph: UITextField!
    @IBOutlet weak var rNearCylAx: UITextField!
    
    @IBOutlet weak var rNearPrism1: UITextField!
    @IBOutlet weak var rNearPrism2: UITextField!
    
    @IBOutlet weak var rNearBC: UITextField!
    @IBOutlet weak var rNearDiameter: UITextField!
    
    @IBOutlet weak var rNearSdp: UITextField!
    
    @IBOutlet weak var rNearACN: UITextField!
    @IBOutlet weak var rNearACC: UITextField!
    
    //near left
    @IBOutlet weak var lNearAdd: UITextField!
    @IBOutlet weak var lNearSph: UITextField!
    @IBOutlet weak var lNearCylAx: UITextField!
    
    @IBOutlet weak var lNearPrism1: UITextField!
    @IBOutlet weak var lNearPrism2: UITextField!
    
    @IBOutlet weak var lNearBC: UITextField!
    @IBOutlet weak var lNearDiameter: UITextField!
    
    @IBOutlet weak var lNearSdp: UITextField!
    
    @IBOutlet weak var lNearACN: UITextField!
    @IBOutlet weak var lNearACC: UITextField!
    
    @IBOutlet weak var nearDpTotal: UITextField!
    //near
    
    @IBOutlet weak var tfPerformedByName: UITextField!
    @IBOutlet weak var tfPerformedByType: UITextField!
    @IBOutlet weak var tfExpiryDate: UITextField!
    @IBOutlet weak var tvNotes: UITextView!
    
    var contact: Contact?
    
    var save: UIBarButtonItem = UIBarButtonItem()
    var moreButton: UIBarButtonItem = UIBarButtonItem()
    
    var lastMeasurementMethod: Character? = nil
    var lastDistanceType: Character? = nil
    var lastSelectedTabIndex: Int = 0
    var isNew: Bool = false
    var isTextViewEditing = false
    
    var textEditing: UITextField?
    
    var datePicker: UIDatePicker = UIDatePicker(frame: CGRect(x: 0, y: 0, width: 0, height: 0))
    var pickerViewSimple: UIPickerView = UIPickerView(frame: CGRect(x: 0, y: 0, width: 0, height: 0))
    var pickerViewDouble: UIPickerView = UIPickerView(frame: CGRect(x: 0, y: 0, width: 0, height: 0))
    
    var performedByTypeDataSource: [String: String] = [
        "OP" : Util.getString("Optician"),
        "OM" : Util.getString("Optometrist"),
        "OC" : Util.getString("Oculist"),
        "CL" : Util.getString("Client")
    ]
    
    var performedByNameDataSource : [AnyObject]{
        get{
            if let type = self.tfPerformedByType.text{
                let key = self.findKeyForValue(value: type)
                if key == "OP" || key == "OM"{
                    let users = self.usersDataSource.filter({ $0.roleCode == key })
                    return users
                }
                else if key == "OC"{
                    return prescribersDataSource
                }
                else if key == "CL"{
                    return []
                }
            }
            return []
        }
    }
    
    var fields: [UITextField] = [UITextField]()
    
    var addDataSource: [String] = [String]()
    var sphereDataSource: [String] = [String]()
    var cylinderDataSource: [String] = [String]()
    var prismDataSource: [String] = [String]()
    var baseDataSource: [String] = [String]()
    var acuityDataSource: [String] = [String]()
    var prescribersDataSource: [Prescriber] = [Prescriber]()
    var usersDataSource: [UserRole] = [UserRole]()
    
    //MARK : FAR
    var _rFarPrism1Value:String?
    var _rFarPrism2Value:String?
    var _lFarPrism1Value:String?
    var _lFarPrism2Value:String?
    
    var _rFarBase1Value:String?
    var _rFarBase2Value:String?
    var _lFarBase1Value:String?
    var _lFarBase2Value:String?
    
    
    var _rFarCylValue:String?
    var _rFarAxisValue:String?
    var _lFarCylValue:String?
    var _lFarAxisValue:String?
    
    //MARK : INTER
    var _rInterPrism1Value:String?
    var _rInterPrism2Value:String?
    var _lInterPrism1Value:String?
    var _lInterPrism2Value:String?
    
    var _rInterBase1Value:String?
    var _rInterBase2Value:String?
    var _lInterBase1Value:String?
    var _lInterBase2Value:String?
    
    
    var _rInterCylValue:String?
    var _rInterAxisValue:String?
    var _lInterCylValue:String?
    var _lInterAxisValue:String?
    
    //MARK : NEAR
    var _rNearPrism1Value:String?
    var _rNearPrism2Value:String?
    var _lNearPrism1Value:String?
    var _lNearPrism2Value:String?
    
    var _rNearBase1Value:String?
    var _rNearBase2Value:String?
    var _lNearBase1Value:String?
    var _lNearBase2Value:String?
    
    
    var _rNearCylValue:String?
    var _rNearAxisValue:String?
    var _lNearCylValue:String?
    var _lNearAxisValue:String?
    
    
    //Begin Far
    var rFarCylValue: String {
        get {
            return pickerDataSourceSimple[self.pickerViewSimple.selectedRow(inComponent: 0)].description
        }
        set{
            self._rFarCylValue = newValue
        }
    }
    var rFarAxisValue: String {
        get {
            if let val = _rFarAxisValue{
                return val
            }
            return ""
        }
        set{
            self._rFarAxisValue = newValue
        }
    }
    
    var lFarCylValue: String {
        get {
            return pickerDataSourceSimple[self.pickerViewSimple.selectedRow(inComponent: 0)].description
        }
        set{
            self._lFarCylValue = newValue
        }
    }
    var lFarAxisValue: String {
        get {
            if let val = _lFarAxisValue{
                return val
            }
            return ""
        }
        set{
            self._lFarAxisValue = newValue
        }
    }
    
    var rFarPrism1Value: String? {
        get {
            return pickerDataSourceDouble[0][self.pickerViewDouble.selectedRow(inComponent: 0)].description
        }
        set{
            self._rFarPrism1Value = newValue
        }
    }
    var rFarBase1Value: String? {
        get {
            return pickerDataSourceDouble[1][self.pickerViewDouble.selectedRow(inComponent: 1)].description
        }
        set{
            self._rFarBase1Value = newValue
        }
    }
    
    var lFarPrism1Value: String {
        get {
            return pickerDataSourceDouble[0][self.pickerViewDouble.selectedRow(inComponent: 0)].description
        }
        set{
            self._lFarPrism1Value  = newValue
        }
    }
    var lFarBase1Value: String {
        get {
            return pickerDataSourceDouble[1][self.pickerViewDouble.selectedRow(inComponent: 1)].description
        }
        set{
            self._lFarBase1Value = newValue
        }
    }
    
    var rFarPrism2Value: String {
        get {
            return pickerDataSourceDouble[0][self.pickerViewDouble.selectedRow(inComponent: 0)].description
        }
        set{
            self._rFarPrism2Value = newValue
        }
    }
    var rFarBase2Value: String {
        get {
            return pickerDataSourceDouble[1][self.pickerViewDouble.selectedRow(inComponent: 1)].description
        }
        set{
            self._rFarBase2Value = newValue
        }
    }
    
    var lFarPrism2Value: String {
        get {
            return pickerDataSourceDouble[0][self.pickerViewDouble.selectedRow(inComponent: 0)].description
        }
        set{
            self._lFarPrism2Value  = newValue
        }
    }
    var lFarBase2Value: String {
        get {
            return pickerDataSourceDouble[1][self.pickerViewDouble.selectedRow(inComponent: 1)].description
        }
        set{
            self._lFarBase2Value = newValue
        }
    }
    // End Far
    
    //Begin Inter
    var rInterCylValue: String {
        get {
            return pickerDataSourceSimple[self.pickerViewSimple.selectedRow(inComponent: 0)].description
        }
        set{
            self._rInterCylValue = newValue
        }
    }
    var rInterAxisValue: String {
        get {
            if let val = _rInterAxisValue{
                return val
            }
            return ""
        }
        set{
            self._rInterAxisValue = newValue
        }
    }
    
    var lInterCylValue: String {
        get {
            return pickerDataSourceSimple[self.pickerViewSimple.selectedRow(inComponent: 0)].description
        }
        set{
            self._lInterCylValue = newValue
        }
    }
    var lInterAxisValue: String {
        get {
            if let val = _lInterAxisValue{
                return val
            }
            return ""
        }
        set{
            self._lInterAxisValue = newValue
        }
    }
    
    var rInterPrism1Value: String? {
        get {
            return pickerDataSourceDouble[0][self.pickerViewDouble.selectedRow(inComponent: 0)].description
        }
        set{
            self._rInterPrism1Value = newValue
        }
    }
    var rInterBase1Value: String? {
        get {
            return pickerDataSourceDouble[1][self.pickerViewDouble.selectedRow(inComponent: 1)].description
        }
        set{
            self._rInterBase1Value = newValue
        }
    }
    
    var lInterPrism1Value: String {
        get {
            return pickerDataSourceDouble[0][self.pickerViewDouble.selectedRow(inComponent: 0)].description
        }
        set{
            self._lInterPrism1Value  = newValue
        }
    }
    var lInterBase1Value: String {
        get {
            return pickerDataSourceDouble[1][self.pickerViewDouble.selectedRow(inComponent: 1)].description
        }
        set{
            self._lInterBase1Value = newValue
        }
    }
    
    var rInterPrism2Value: String {
        get {
            return pickerDataSourceDouble[0][self.pickerViewDouble.selectedRow(inComponent: 0)].description
        }
        set{
            self._rInterPrism2Value = newValue
        }
    }
    var rInterBase2Value: String {
        get {
            return pickerDataSourceDouble[1][self.pickerViewDouble.selectedRow(inComponent: 1)].description
        }
        set{
            self._rInterBase2Value = newValue
        }
    }
    
    var lInterPrism2Value: String {
        get {
            return pickerDataSourceDouble[0][self.pickerViewDouble.selectedRow(inComponent: 0)].description
        }
        set{
            self._lInterPrism2Value  = newValue
        }
    }
    var lInterBase2Value: String {
        get {
            return pickerDataSourceDouble[1][self.pickerViewDouble.selectedRow(inComponent: 1)].description
        }
        set{
            self._lInterBase2Value = newValue
        }
    }
    // End Inter
    
    //Begin Near
    var rNearCylValue: String {
        get {
            return pickerDataSourceSimple[self.pickerViewSimple.selectedRow(inComponent: 0)].description
        }
        set{
            self._rNearCylValue = newValue
        }
    }
    var rNearAxisValue: String {
        get {
            if let val = _rNearAxisValue{
                return val
            }
            return ""
        }
        set{
            self._rNearAxisValue = newValue
        }
    }
    
    var lNearCylValue: String {
        get {
            return pickerDataSourceSimple[self.pickerViewSimple.selectedRow(inComponent: 0)].description
        }
        set{
            self._lNearCylValue = newValue
        }
    }
    var lNearAxisValue: String {
        get {
            if let val = _lNearAxisValue{
                return val
            }
            return ""
        }
        set{
            self._lNearAxisValue = newValue
        }
    }
    
    var rNearPrism1Value: String? {
        get {
            return pickerDataSourceDouble[0][self.pickerViewDouble.selectedRow(inComponent: 0)].description
        }
        set{
            self._rNearPrism1Value = newValue
        }
    }
    var rNearBase1Value: String? {
        get {
            return pickerDataSourceDouble[1][self.pickerViewDouble.selectedRow(inComponent: 1)].description
        }
        set{
            self._rNearBase1Value = newValue
        }
    }
    
    var lNearPrism1Value: String {
        get {
            return pickerDataSourceDouble[0][self.pickerViewDouble.selectedRow(inComponent: 0)].description
        }
        set{
            self._lNearPrism1Value  = newValue
        }
    }
    var lNearBase1Value: String {
        get {
            return pickerDataSourceDouble[1][self.pickerViewDouble.selectedRow(inComponent: 1)].description
        }
        set{
            self._lNearBase1Value = newValue
        }
    }
    
    var rNearPrism2Value: String {
        get {
            return pickerDataSourceDouble[0][self.pickerViewDouble.selectedRow(inComponent: 0)].description
        }
        set{
            self._rNearPrism2Value = newValue
        }
    }
    var rNearBase2Value: String {
        get {
            return pickerDataSourceDouble[1][self.pickerViewDouble.selectedRow(inComponent: 1)].description
        }
        set{
            self._rNearBase2Value = newValue
        }
    }
    
    var lNearPrism2Value: String {
        get {
            return pickerDataSourceDouble[0][self.pickerViewDouble.selectedRow(inComponent: 0)].description
        }
        set{
            self._lNearPrism2Value  = newValue
        }
    }
    var lNearBase2Value: String {
        get {
            return pickerDataSourceDouble[1][self.pickerViewDouble.selectedRow(inComponent: 1)].description
        }
        set{
            self._lNearBase2Value = newValue
        }
    }
    // End Near
    
    var pickerDataSourceSimple: [String]{
        get{
            if let textField = textEditing{
                if textField == rFarAdd || textField == lFarAdd
                    || textField == rInterAdd || textField == lInterAdd
                    || textField == rNearAdd || textField == lNearAdd {
                    return self.addDataSource
                }
                else if textField == rFarSph || textField == lFarSph
                    || textField == rInterSph || textField == lInterSph
                    || textField == rNearSph || textField == lNearSph {
                    return self.sphereDataSource
                }
                else if textField == rFarCylAx || textField == lFarCylAx
                    || textField == rInterCylAx || textField == lInterCylAx
                    || textField == rNearCylAx || textField == lNearCylAx{
                    return self.cylinderDataSource
                }
                else if textField == rFarACN || textField == lFarACN || textField == rFarACC || textField == lFarACC
                    || textField == rInterACN || textField == lInterACN || textField == rInterACC || textField == lInterACC
                    || textField == rNearACN || textField == lNearACN || textField == rNearACC || textField == lNearACC{
                    return self.acuityDataSource
                }
                else if textField == tfPerformedByType{
                    return [String](self.performedByTypeDataSource.values)
                }
            }
            return [""]
        }
    }
    
    var pickerDataSourceDouble: [[String]]{
        get{
            var array: [[String]] = [[String]]()
            if let textField = textEditing{
                if textField == rFarPrism1 || textField == lFarPrism1 || textField == rFarPrism2 || textField == lFarPrism2
                || textField == rInterPrism1 || textField == lInterPrism1 || textField == rInterPrism2 || textField == lInterPrism2
                || textField == rNearPrism1 || textField == lNearPrism1 || textField == rNearPrism2 || textField == lNearPrism2{
                    array.append(self.prismDataSource)
                    array.append(self.baseDataSource)
                }
            }
            return array
        }
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        self.delegateTextField()
        self.disableUserInteraction()
        self.tabBar(tabBar, didSelect: tabBar.items![0] )
        self.createBarButtonItems()
        self.setLayoutAccordingToPrescriptionType()
        self.createLeftBackButton()
        self.setFieldsCustomLayout()
        self.setCustomTitle()
        self.setPlaceholderToRight()
        self.addTapGesture()
        self.loadClinicalParameters()
        self.configureGenericView()
        self.save.isEnabled = false
        self.setModifyPermissions()
    }
    
    
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        self.unregisterKeyboard()
        self.view.endEditing(true)
    }
    
    func setModifyPermissions(){
        if ((settings.LoggedInUserPermissons?.contains("CANMODIFYPRESCRIPTION")) == true || self.isNew){
            self.view.isUserInteractionEnabled = true
        }
        else{
            self.view.isUserInteractionEnabled = false
        }
    }
    
    
    func getCylAx(cylinder: String?, axis: String?) -> String?{
        if let cyl = cylinder{
            if let ax = axis{
                if cyl.isEmpty{
                    return nil
                }
                return cyl + "x" + ax
            }
        }
        return nil
    }
    
    func getPrismBase(prism: String?, base: String?) -> String?{
        if let prism = prism{
            if let base = base{
                return prism + " " + base
            }
        }
        return nil
    }
    
    func findKeyForValue(value: String) ->String{
        for (key, array) in performedByTypeDataSource{
            if (array.contains(value)){
                return key
            }
        }
        return ""
    }
    
    func loadClinicalParameters(){
        if State.clinicalParameters.count > 0 {
            self.setClinicalParameterType()
            return
        }
        
        State.loadClinicalParamter { result in
            if result {
                self.setClinicalParameterType()
            }
            else{
                NetworkController.AlertConnectionError(viewController: self)
            }
        }
    }
    
    func setClinicalParameterType(){
        for paramater in State.clinicalParameters{
            if paramater.name == "ADD"{
                self.addDataSource.append(paramater.value)
            }
            if paramater.name == "Sphere"{
                self.sphereDataSource.append(paramater.value)
            }
            else if paramater.name == "Cylinder"{
                self.cylinderDataSource.append(paramater.value)
            }
            else if paramater.name == "Prism"{
                self.prismDataSource.append(paramater.value)
            }
            else if paramater.name == "Base"{
                self.baseDataSource.append(paramater.value)
            }
            else if paramater.name == "Acuity"{
                self.acuityDataSource.append(paramater.value)
            }
        }
    }
    
    func setFieldsCustomLayout(){
        self.lfDistance.layer.borderWidth = 1
        self.lfDistance.layer.borderColor = UIColor.darkGray.cgColor
        
        self.tvNotes.layer.borderWidth = 1
        self.tvNotes.layer.cornerRadius = 10
        self.tvNotes.layer.borderColor = UIColor.darkGray.cgColor
    }
    
    func textView(_ textView: UITextView, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool {
        self.save.isEnabled = true
        return true
    }
    
    func textViewDidBeginEditing(_ textView: UITextView) {
        isTextViewEditing = true
    }
    
    func textViewDidEndEditing(_ textView: UITextView) {
        isTextViewEditing = false
        self.clinicalStatus.NOTES = textView.text
    }
    
    func textFieldShouldReturn(_ textField: UITextField) -> Bool {
        self.dismissKeyboard()
        return true
    }
    
    func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
        self.save.isEnabled = true
        return true
    }
    
    func textFieldShouldBeginEditing(_ textField: UITextField) -> Bool {
        self.textEditing = textField
        if textField == tfPerformedByName{
            self.dismissKeyboard()
            self.openPopup()
            return false
        }
        else if textField == self.tfExpiryDate{
            self.dismissKeyboard()
            self.openDatePicker(textField)
            return true
        }
        else if textField == self.tfPerformedByType{
            self.dismissKeyboard()
            self.openPickerView(self.pickerViewSimple, textField)
            return true
        }
        
        if textField == self.rFarBC || textField == self.lFarBC || textField == self.rInterBC || textField == self.lInterBC || textField == self.rNearBC || textField == self.lNearBC {
            self.simpleAlertWithTextEdit(title: getCaptionForTextField(textField: textField), message: nil, text: textField.text, availableValue: "5.0-15.0", actionYes: { value in
                if let value = value{
                    if let newValue = Double.init(value){
                        textField.text = Util.DoubleToStringWithOneDecimal(newValue)
                    }
                    else{
                        textField.text = nil
                    }
                }
                else{
                    textField.text = nil
                }
                self.saveControlValues()
            }, actionNo: {
                
            })
        }
        else if textField == self.rFarDiameter  || textField == self.lFarDiameter  || textField == self.rInterDiameter  || textField == self.lInterDiameter  || textField == self.rNearDiameter  || textField == self.lNearDiameter{
            self.simpleAlertWithTextEdit(title: getCaptionForTextField(textField: textField), message: nil, text: textField.text, availableValue: "5.0-20.0", actionYes: { value in
                if let value = value{
                    if let newValue = Double.init(value){
                        textField.text = Util.DoubleToStringWithOneDecimal(newValue)
                    }
                    else{
                        textField.text = nil
                    }
                }
                else{
                    textField.text = nil
                }
                self.saveControlValues()
            }, actionNo: {
                
            })
        }
        else if textField == self.rFarSdp || textField == self.lFarSdp || textField == self.rInterSdp  || textField == self.lInterSdp || textField == self.rNearSdp  || textField == self.lNearSdp{
            self.simpleAlertWithTextEdit(title: getCaptionForTextField(textField: textField), message: nil, text: textField.text, availableValue: "20.0-80.0", actionYes: { value in
                if let value = value{
                    if let newValue = Double.init(value){
                        textField.text = Util.DoubleToStringWithOneDecimal(newValue)
                    }
                    else{
                        textField.text = nil
                    }
                }
                else{
                    textField.text = nil
                }
                
                self.calculateDpTotal(textField: self.farDpTotal, rText: self.rFarSdp.text, lText: self.lFarSdp.text)
                self.calculateDpTotal(textField: self.interDpTotal, rText: self.rInterSdp.text, lText: self.lInterSdp.text)
                self.calculateDpTotal(textField: self.nearDpTotal, rText: self.rNearSdp.text, lText: self.lNearSdp.text)
                
                self.saveControlValues()
            }, actionNo: {
                
            })
        }
        else if textField == self.farDpTotal || textField == self.interDpTotal || textField == self.nearDpTotal {
            self.simpleAlertWithTextEdit(title: getCaptionForTextField(textField: textField), message: nil, text: textField.text, availableValue: "40.0-160.0", actionYes: { value in
                if let value = value{
                    if let newValue = Double.init(value){
                        textField.text = Util.DoubleToStringWithOneDecimal(newValue)
                    }
                    else{
                        textField.text = nil
                    }
                }
                else{
                    textField.text = nil
                }
                
                self.calculateSDP(rText: self.rFarSdp, lText: self.lFarSdp, dpTotal: self.farDpTotal)
                self.calculateSDP(rText: self.rInterSdp, lText: self.lInterSdp, dpTotal: self.interDpTotal)
                self.calculateSDP(rText: self.rNearSdp, lText: self.lNearSdp, dpTotal: self.nearDpTotal)
                
                self.saveControlValues()
            }, actionNo: {
                
            })
        }
        else{
            self.dismissKeyboard()
            if textField == rFarPrism1 || textField == self.lFarPrism1 || textField == self.rFarPrism2 || textField == self.lFarPrism2 || textField == rInterPrism1 || textField == self.lInterPrism1 || textField == self.rInterPrism2 || textField == self.lInterPrism2 || textField == rNearPrism1 || textField == self.lNearPrism1 || textField == self.rNearPrism2 || textField == self.lNearPrism2 {
                self.openPickerView(self.pickerViewDouble, textField)
            }
            else{
                self.openPickerView(self.pickerViewSimple, textField)
            }
        }
        return true
    }
    
    func textFieldDidBeginEditing(_ textField: UITextField) {
        if textField != self.tfPerformedByName && textField != self.tfPerformedByType && textField != self.tfExpiryDate{
            self.adjustFontSize(textField: textField, size: 5)
        }
    }
    
    func textFieldDidEndEditing(_ textField: UITextField) {
        if textField == self.rFarCylAx{
            if textField.text == nil || textField.text == ""{
                self.saveControlValues()
                return
            }
            self.simpleAlertWithTextEdit(title: "AXIS OD-Far", message: nil, text: _rFarAxisValue, availableValue: "1-180", actionYes: { value in
                self._rFarAxisValue = value
                if let value = value{
                    if value.isEmpty{
                        self._rFarCylValue = String()
                    }
                }
                textField.text = self.getCylAx(cylinder: self._rFarCylValue, axis: self._rFarAxisValue)
                self.saveControlValues()
            }, actionNo: {
                if let axis = self._rFarAxisValue{
                    if axis.isEmpty{
                        self._rFarCylValue = String()
                    }
                }
                else{
                    self._rFarCylValue = nil
                }
                textField.text = self.getCylAx(cylinder: self._rFarCylValue, axis: self._rFarAxisValue)
                self.saveControlValues()
            })
        }
        else if textField == self.lFarCylAx{
            if textField.text == nil || textField.text == ""{
                self.saveControlValues()
                return
            }
            self.simpleAlertWithTextEdit(title: "AXIS OS-Far", message: nil, text: _lFarAxisValue, availableValue: "1-180", actionYes: { value in
                self._lFarAxisValue = value
                if let value = value{
                    if value.isEmpty{
                        self._lFarCylValue = String()
                    }
                }
                textField.text = self.getCylAx(cylinder: self._lFarCylValue, axis: self._lFarAxisValue)
                self.saveControlValues()
            }, actionNo: {
                if let axis = self._lFarAxisValue{
                    if axis.isEmpty{
                        self._lFarCylValue = String()
                    }
                }
                else{
                    self._lFarCylValue = nil
                }
                textField.text = self.getCylAx(cylinder: self._lFarCylValue, axis: self._lFarAxisValue)
                self.saveControlValues()
            })
        }
        if textField == self.rInterCylAx{
            if textField.text == nil || textField.text == ""{
                self.saveControlValues()
                return
            }
            self.simpleAlertWithTextEdit(title: "AXIS OD-Inter", message: nil, text: _rInterAxisValue, availableValue: "1-180", actionYes: { value in
                self._rInterAxisValue = value
                if let value = value{
                    if value.isEmpty{
                        self._rInterCylValue = String()
                    }
                }
                textField.text = self.getCylAx(cylinder: self._rInterCylValue, axis: self._rInterAxisValue)
                self.saveControlValues()
            }, actionNo: {
                if let axis = self._rInterAxisValue{
                    if axis.isEmpty{
                        self._rInterCylValue = String()
                    }
                }
                else{
                    self._rInterCylValue = nil
                }
                textField.text = self.getCylAx(cylinder: self._rInterCylValue, axis: self._rInterAxisValue)
                self.saveControlValues()
            })
        }
        else if textField == self.lInterCylAx{
            if textField.text == nil || textField.text == ""{
                self.saveControlValues()
                return
            }
            self.simpleAlertWithTextEdit(title: "AXIS OS-Inter", message: nil, text: _lInterAxisValue, availableValue: "1-180", actionYes: { value in
                self._lInterAxisValue = value
                if let value = value{
                    if value.isEmpty{
                        self._lInterCylValue = String()
                    }
                }
                textField.text = self.getCylAx(cylinder: self._lInterCylValue, axis: self._lInterAxisValue)
                self.saveControlValues()
            }, actionNo: {
                if let axis = self._lInterAxisValue{
                    if axis.isEmpty{
                        self._lInterCylValue = String()
                    }
                }
                else{
                    self._lInterCylValue = nil
                }
                textField.text = self.getCylAx(cylinder: self._lInterCylValue, axis: self._lInterAxisValue)
                self.saveControlValues()
            })
        }
        
        if textField == self.rNearCylAx{
            if textField.text == nil || textField.text == ""{
                self.saveControlValues()
                return
            }
            var text = _rNearAxisValue
            if text == nil || text?.isEmpty == true{
                text = _rFarAxisValue
            }
            self.simpleAlertWithTextEdit(title: "AXIS OD-Near", message: nil, text: text, availableValue: "1-180", actionYes: { value in
                self._rNearAxisValue = value
                if let value = value{
                    if value.isEmpty{
                        self._rNearCylValue = String()
                    }
                }
                textField.text = self.getCylAx(cylinder: self._rNearCylValue, axis: self._rNearAxisValue)
                self.saveControlValues()
            }, actionNo: {
                if let axis = self._rNearAxisValue{
                    if axis.isEmpty{
                        self._rNearCylValue = String()
                    }
                }
                else{
                    self._rNearCylValue = nil
                }
                textField.text = self.getCylAx(cylinder: self._rNearCylValue, axis: self._rNearAxisValue)
                self.saveControlValues()
            })
        }
        else if textField == self.lNearCylAx{
            if textField.text == nil || textField.text == ""{
                self.saveControlValues()
                return
            }
            var text = _lNearAxisValue
            if text == nil || text?.isEmpty == true{
                text = _lFarAxisValue
            }
            self.simpleAlertWithTextEdit(title: "AXIS OS-Near", message: nil, text: text, availableValue: "1-180", actionYes: { value in
                self._lNearAxisValue = value
                if let value = value{
                    if value.isEmpty{
                        self._lNearCylValue = String()
                    }
                }
                textField.text = self.getCylAx(cylinder: self._lNearCylValue, axis: self._lNearAxisValue)
                self.saveControlValues()
            }, actionNo: {
                if let axis = self._lNearAxisValue{
                    if axis.isEmpty{
                        self._lNearCylValue = String()
                    }
                }
                else{
                    self._lNearCylValue = nil
                }
                textField.text = self.getCylAx(cylinder: self._lNearCylValue, axis: self._lNearAxisValue)
                self.saveControlValues()
            })
        }
        else if textField == self.rFarAdd || textField == self.lFarAdd || textField == self.rInterAdd || textField == self.lInterAdd || textField == self.rNearAdd || textField == self.lNearAdd{
            self.saveControlValues()
            self.setSPHValues()
            
            if textField == self.rInterAdd{
                self.duplicateInterRightEye()
            }
            if textField == self.rNearAdd{
                self.duplicateNearRightEye()
            }
            else if textField == self.lInterAdd{
                self.duplicateInterLeftEye()
            }
            else if textField == self.lNearAdd{
                self.duplicateNearLeftEye()
            }
            
            self.saveControlValues()
            self.setSPHValues()
        }
        else if textField == self.rFarSph || textField == self.lFarSph || textField == self.rInterSph || textField == self.lInterSph || textField == self.rNearSph || textField == self.lNearSph{
            self.saveControlValues()
            self.setAddValues()
        }
        else if textField == tfPerformedByType{
            if let value = tfPerformedByType.text{
                let type = self.findKeyForValue(value: value)
                if type != self.clinicalStatus.PERFORMED_BY_TYPE{
                    self.tfPerformedByName.text = nil
                    self.clinicalStatus.PERFORMED_BY_NAME = nil
                    self.clinicalStatus.OpticianId = nil
                    self.clinicalStatus.PrescriberId = nil
                    self.saveGeneralControlValues()
                }
                
                if type == "CL"{
                    self.tfPerformedByName.isEnabled = false
                    self.tfPerformedByName.text = self.clinicalStatus.Contact?.getFullName()
                }
                else if type == "OC"{
                    self.tfPerformedByName.isEnabled = true
                }
                else if type == "OM"{
                    self.tfPerformedByName.isEnabled = true
                }
                else if type == "OP"{
                    self.tfPerformedByName.isEnabled = true
                }
            }
        }
        
        if textField != self.tfPerformedByName && textField != self.tfPerformedByType && textField != self.tfExpiryDate{
            self.saveControlValues()
            self.adjustFontSize(textField: textField, size: -5)
        }
        else{
            self.saveGeneralControlValues()
        }
        
        self.isSaveButtonEnabled(isEnabled: true)
    }
    
    func duplicateInterRightEye(){
        if self.lInterAdd.text?.isEmpty == true{
            self.lInterAdd.text = self.rInterAdd.text
        }
    }
    
    func duplicateNearRightEye(){
        if self.lNearAdd.text?.isEmpty == true{
            self.lNearAdd.text = self.rNearAdd.text
        }
    }
    
    func duplicateInterLeftEye(){
        if self.rInterAdd.text?.isEmpty == true{
            self.rInterAdd.text = self.lInterAdd.text
        }
    }
    
    func duplicateNearLeftEye(){
        if self.rNearAdd.text?.isEmpty == true{
            self.rNearAdd.text = self.lNearAdd.text
        }
    }
    
    func getCaptionForTextField(textField: UITextField) -> String{
        if textField == rFarBC{
            return "BC OD-FAR"
        }
        else if textField == lFarBC{
            return "BC OS-FAR"
        }
        
        else if textField == rFarDiameter{
            return "DIAMETER OD-FAR"
        }
        else if textField == lFarDiameter{
            return "DIAMETER OS-FAR"
        }
        
        else if textField == rFarCylAx{
            return "AXIS OD-FAR"
        }
        else if textField == lFarCylAx{
            return "AXIS OS-FAR"
        }
            
        else if textField == rFarSdp{
            return "DP OD-FAR"
        }
        else if textField == lFarSdp{
            return "DP OS-FAR"
        }
            
        else if textField == rInterBC{
            return "BC OD-Inter"
        }
        else if textField == lInterBC{
            return "BC OS-Inter"
        }
            
        else if textField == rInterDiameter{
            return "DIAMETER OD-Inter"
        }
        else if textField == lInterDiameter{
            return "DIAMETER OS-Inter"
        }
            
        else if textField == rInterCylAx{
            return "AXIS OD-Inter"
        }
        else if textField == lInterCylAx{
            return "AXIS OS-Inter"
        }
            
        else if textField == rInterSdp{
            return "DP OD-Inter"
        }
        else if textField == lInterSdp{
            return "DP OS-Inter"
        }
        
        
        else if textField == rNearBC{
            return "BC OD-Near"
        }
        else if textField == lNearBC{
            return "BC OS-Near"
        }
            
        else if textField == rNearDiameter{
            return "DIAMETER OD-Near"
        }
        else if textField == lNearDiameter{
            return "DIAMETER OS-Near"
        }
            
        else if textField == rNearCylAx{
            return "AXIS OD-Near"
        }
        else if textField == lNearCylAx{
            return "AXIS OS-Near"
        }
            
        else if textField == rNearSdp{
            return "DP OD-Near"
        }
        else if textField == lNearSdp{
            return "DP OS-Near"
        }
        
        return ""
    }
    
    var alert = UIAlertController()
    func simpleAlertWithTextEdit(title: String?, message:String?, text: String?, availableValue: String, actionYes: @escaping ((String?) -> ()), actionNo: @escaping (() -> ()))  {
        self.alert = UIAlertController(title: title, message: message, preferredStyle: .alert)
        
        alert.addTextField { textField in
            textField.text = text
            textField.addTarget(self, action: #selector(self.textChanged(_:)), for: .editingChanged)
            textField.keyboardType = .numbersAndPunctuation
            let label = UILabel(frame: CGRect(x: 0, y: 0, width: 100, height: 22))
            label.textAlignment = NSTextAlignment.right
            label.textColor = UIColor(red: 0.78, green: 0.78, blue: 0.80, alpha: 1.0)
            label.text = availableValue
            textField.rightView = label
            textField.rightViewMode = .always
        }
        alert.addAction(UIAlertAction(title: Util.getString("Apply"), style: .default, handler: {(_) in
            actionYes(self.alert.textFields?[0].text)
        }))
        
        alert.addAction(UIAlertAction(title: Util.getString("Cancel"), style: .destructive, handler: {(_) in
            actionNo()
        }))
        
        self.present(alert, animated: true, completion: {
            self.alert.textFields?[0].selectAll(self.alert)
        })
    }
    
    @objc func textChanged(_ textField: UITextField) {
        if let text = textField.text{
            if text != "" {
                if textEditing == self.rFarBC || textEditing == self.lFarBC || textEditing == self.rInterBC || textEditing == self.lInterBC || textEditing == self.rNearBC || textEditing == self.lNearBC{
                    if let value = Double(text){
                        if value < 5 || value > 15{
                            alert.actions[0].isEnabled = false
                        }
                        else{
                            alert.actions[0].isEnabled = true
                        }
                    }
                    else{
                        alert.actions[0].isEnabled = false
                    }
                }
                else if textEditing == self.rFarDiameter  || textEditing == self.lFarDiameter || textEditing == self.rInterDiameter || textEditing == self.lInterDiameter || textEditing == self.rNearDiameter || textEditing == self.lNearDiameter{
                    if let value = Double(text){
                        if value < 5 || value > 20{
                            alert.actions[0].isEnabled = false
                        }
                        else{
                            alert.actions[0].isEnabled = true
                        }
                    }
                    else{
                        alert.actions[0].isEnabled = false
                    }
                }
                
                else if textEditing == self.rFarCylAx  || textEditing == self.lFarCylAx || textEditing == self.rInterCylAx  || textEditing == self.lInterCylAx || textEditing == self.rNearCylAx  || textEditing == self.lNearCylAx{
                    if let value = Int(text){
                        if value < 1 || value > 180{
                            alert.actions[0].isEnabled = false
                        }
                        else{
                            alert.actions[0].isEnabled = true
                        }
                    }
                    else{
                        alert.actions[0].isEnabled = false
                    }
                }
                else if textEditing == self.rFarSdp || textEditing == self.lFarSdp || textEditing == self.rInterSdp || textEditing == self.lInterSdp || textEditing == self.rNearSdp || textEditing == self.lNearSdp{
                    if let value = Double(text){
                        if value < 20 || value > 80{
                            alert.actions[0].isEnabled = false
                        }
                        else{
                            alert.actions[0].isEnabled = true
                        }
                    }
                    else{
                        alert.actions[0].isEnabled = false
                    }
                }
                else if textEditing == self.farDpTotal || textEditing == self.interDpTotal || textEditing == self.nearDpTotal{
                    if let value = Double(text){
                        if value < 40 || value > 160{
                            alert.actions[0].isEnabled = false
                        }
                        else{
                            alert.actions[0].isEnabled = true
                        }
                    }
                    else{
                        alert.actions[0].isEnabled = false
                    }
                }
            }
        }
    }
    
    func calculateDpTotal(textField: UITextField,rText: String?,lText: String? ){
        var dpTotal = 0.0
        var rPd = 0.0
        var lPd = 0.0
        if let text = rText{
            if let value = Double(text){
                rPd = value
            }
        }
        if let text = lText{
            if let value = Double(text){
                lPd = value
            }
        }
        
        dpTotal = rPd + lPd
        if dpTotal  > 0 {
            textField.text = "\(dpTotal)"
        }
        else{
            textField.text = ""
        }
    }
    
    func calculateSDP(rText: UITextField, lText: UITextField, dpTotal: UITextField){
        if let value = Double(dpTotal.text ?? ""){
            rText.text = "\(value/2)"
            lText.text = "\(value/2)"
        }
        else{
            rText.text = ""
            lText.text = ""
        }
    }
    
    // Keyboard
    func registerKeyboard(){
        NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardDidShow(notification:)), name: UIResponder.keyboardDidShowNotification, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardWillHide(notification:)), name: UIResponder.keyboardWillHideNotification, object: nil)
    }
    
    func unregisterKeyboard(){
        NotificationCenter.default.removeObserver(self)
    }
    
    @objc func keyboardDidShow(notification: NSNotification){
        let userInfo: NSDictionary = notification.userInfo! as NSDictionary
        let keyboardInfo = userInfo[UIResponder.keyboardFrameEndUserInfoKey] as! NSValue
        let keyboardSize = keyboardInfo.cgRectValue.size
        let contentInsets = UIEdgeInsets(top: 0, left: 0, bottom: keyboardSize.height, right: 0)
        self.scrollView.contentInset = contentInsets
        self.scrollView.scrollIndicatorInsets = contentInsets
        
        if(isTextViewEditing){
            self.scrollView.scrollRectToVisible((self.tvNotes.superview?.frame)!, animated: true)
        }
    }
    
    @objc func keyboardWillHide(notification: NSNotification){
        self.scrollView.contentInset = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 0)
        self.scrollView.scrollIndicatorInsets = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 0)
    }
    
    func addTapGesture(){
        let tap: UITapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(dismissKeyboard))
        self.scrollView.addGestureRecognizer(tap)
    }
    
    @objc func dismissKeyboard() {
        self.view.endEditing(true)
        self.contentView.endEditing(true)
        self.scrollView.endEditing(true)
    }
    
    func getAllTextFields(){
        self.fields.append(self.tfPerformedByName)
        self.fields.append(self.tfPerformedByType)
        self.fields.append(self.tfExpiryDate)
    }
    
    func setPlaceholderToRight(){
        self.getAllTextFields()
        for textField in self.fields{
            if let placeholder = textField.placeholder{
                let height = textField.frame.height
                let size: CGSize = Util.getString(placeholder).size(withAttributes: [NSAttributedString.Key.font: UIFont.systemFont(ofSize: 17.0)])
                
                let label = UILabel(frame: CGRect(x: 0, y: 0, width: size.width, height: height))
                label.textAlignment = NSTextAlignment.right
                label.textColor = UIColor(red: 0.78, green: 0.78, blue: 0.80, alpha: 1.0)
                label.text = Util.getString(placeholder)
                textField.placeholder = nil
                textField.rightView = label
                textField.rightViewMode = .unlessEditing
            }
        }
    }
    
    func createBarButtonItems(){
        self.save = UIBarButtonItem(barButtonSystemItem: .save , target: self, action: #selector(saveClinicalStatus))
        self.moreButton = UIBarButtonItem(image: UIImage.init(named: "moreButton.png"), style: .plain, target: self, action: #selector(moreButtonAlert))
        
        self.navigationItem.rightBarButtonItems = [moreButton, save]
    }
    
    override func viewWillAppear(_ animated: Bool) {
        self.registerKeyboard()
        self.setLastSelectedTabIndex()
        self.tabBar.selectedItem = tabBar.items![lastSelectedTabIndex] as UITabBarItem
        self.tabBar(tabBar, didSelect: tabBar.items![lastSelectedTabIndex])
        self.configureView()
    }
    
    func setLastSelectedTabIndex(){
        if (lastDistanceType == "A") { lastSelectedTabIndex = 0 }
        else if (lastDistanceType == "D") { lastSelectedTabIndex = 1 }
        else if (lastDistanceType == "I") { lastSelectedTabIndex = 2 }
        else if (lastDistanceType == "N") { lastSelectedTabIndex = 3 }
    }
    
    func setCustomTitle(){
        let title: UILabel = UILabel()
        title.numberOfLines = 0
        title.textAlignment = .center
        title.text = clinicalStatus.Contact!.getFullNameSexAge() + "\n\(Util.DateToShortDateString(date: clinicalStatus.CreateTime))"
        self.navigationItem.titleView = title
        self.title = self.clinicalStatus.Contact?.getFullName()
    }
    
    func configureGenericView(){
        if(isNew){
            self.clinicalStatus.MeasurementMethod = "T"
            
            let date = Calendar.current.date(byAdding: .year, value: 2, to: Date())
            if let newDate = date{
                self.clinicalStatus.ExpiryDate = newDate
            }
            
            State.loadUserAndRole(filterString: nil, completionHandler: { result in
                if let users = result{
                    for user in users{
                        if user.userId.description == settings.LoggedInUserId{
                            if let code = user.roleCode{
                                self.tfPerformedByType.text = self.performedByTypeDataSource[code]
                                self.tfPerformedByName.text = user.userName
                                self.clinicalStatus.OpticianId = user.userId
                                break
                            }
                        }
                    }
                }
            })
        }
    }
    
    func configureView(){
        self.lastMeasurementMethod = self.clinicalStatus.MeasurementMethod?.first
        self.tvNotes.text = self.clinicalStatus.NOTES
        
        if clinicalStatus.PERFORMED_BY_TYPE == "OP" || clinicalStatus.PERFORMED_BY_TYPE == "OM"{
            self.tfPerformedByName.text = self.clinicalStatus.Optician?.userName
        }
        else if clinicalStatus.PERFORMED_BY_TYPE == "OC"{
            self.tfPerformedByName.text = self.clinicalStatus.Prescriber?.name
        }
        else if clinicalStatus.PERFORMED_BY_TYPE == "CL"{
            self.tfPerformedByName.text = self.clinicalStatus.Contact?.getFullName()
            self.tfPerformedByName.isEnabled = false
        }
        
        if let type = self.clinicalStatus.PERFORMED_BY_TYPE {
            self.tfPerformedByType.text = performedByTypeDataSource[type]
        }
        
        self.tfExpiryDate.text = Util.DateToShortDateString(date: clinicalStatus.ExpiryDate)
        self.datePicker.setDate(clinicalStatus.ExpiryDate, animated: true)
    }
    
    func createLeftBackButton(){
        let backButton = UIBarButtonItem(title: Util.getString("Cancel"), style: .done, target: self, action: #selector(backButtonPressed))
        self.navigationItem.leftBarButtonItem = backButton
    }
    
    @objc func backButtonPressed(){
        if self.save.isEnabled{
            Util.AlertYesNo(viewController: self, title: "iPOS", message: Util.getString("Are you sure you want to cancel? All changes will be lost!"), actionYes: {
                _ = self.navigationController?.popViewController(animated: true)
            }, actionNo: {
                return
            })
        }
        else{
            _ = self.navigationController?.popViewController(animated: true)
        }
    }
    
    func setLayoutAccordingToPrescriptionType(){
        if(clinicalStatus.PrescriptionType == "GL"){
            self.clView.isHidden = true
            self.clView.clipsToBounds = true
            self.clViewHeight.constant = 0
            self.glViewHeight.constant = 111
        }
        else if( clinicalStatus.PrescriptionType == "CL"){
            self.glView.isHidden = true
            self.glView.clipsToBounds = true
            self.clViewHeight.constant = 111
            self.glViewHeight.constant = 0
        }
    }

    func beforeSaveClinicalStatus(){
        let clinicalStatusWithoutCollections = clinicalStatus.clone()
        clinicalStatusWithoutCollections.Contact = nil
        clinicalStatusWithoutCollections.Prescriber = nil
        clinicalStatusWithoutCollections.Optician = nil
        clinicalStatusWithoutCollections.TransferTime = nil
        
        if(!isNew){
            clinicalStatusWithoutCollections.ModifyTime = Date()
            
            State.modifyClinicalStatus(clinicalStatusWithoutCollections) { isOk in
                if(isOk == true){
                    _ = self.navigationController?.popViewController(animated: true)
                }
                else if (isOk == false) {
                    Util.AlertSystemError(viewController: self)
                }
                else {
                    NetworkController.AlertConnectionError(viewController: self)
                }
            }
        }
        else{
            State.LoadLastClinicalStatusNumber { result in
                clinicalStatusWithoutCollections.ClinicalStatusNumber = result + 1

                State.addNewClinicalStatus(clinicalStatusWithoutCollections){ isOk in
                    if(isOk == true){
                        _ = self.navigationController?.popViewController(animated: true)
                    }
                    else if (isOk == false) {
                        Util.AlertSystemError(viewController: self)
                    }
                    else {
                        NetworkController.AlertConnectionError(viewController: self)
                    }
                }
            }
        }
    }
    
    func disableUserInteraction(){
        self.rFarAdd.isUserInteractionEnabled = false
        self.lFarAdd.isUserInteractionEnabled = false
        
        //self.farDpTotal.isUserInteractionEnabled = false
        //self.interDpTotal.isUserInteractionEnabled = false
        //self.nearDpTotal.isUserInteractionEnabled = false
    }
    
    func delegateTextField(){
        self.rFarAdd.delegate = self
        self.rFarSph.delegate = self
        self.rFarCylAx.delegate = self
        self.lFarAdd.delegate = self
        self.lFarSph.delegate = self
        self.lFarCylAx.delegate = self
        
        self.rInterAdd.delegate = self
        self.rInterSph.delegate = self
        self.rInterCylAx.delegate = self
        self.lInterAdd.delegate = self
        self.lInterSph.delegate = self
        self.lInterCylAx.delegate = self
        
        self.rNearAdd.delegate = self
        self.rNearSph.delegate = self
        self.rNearCylAx.delegate = self
        self.lNearAdd.delegate = self
        self.lNearSph.delegate = self
        self.lNearCylAx.delegate = self
        
        self.rFarPrism1.delegate = self
        self.rFarPrism2.delegate = self
        self.lFarPrism1.delegate = self
        self.lFarPrism2.delegate = self
        
        self.rInterPrism1.delegate = self
        self.rInterPrism2.delegate = self
        self.lInterPrism1.delegate = self
        self.lInterPrism2.delegate = self
        
        self.rNearPrism1.delegate = self
        self.rNearPrism2.delegate = self
        self.lNearPrism1.delegate = self
        self.lNearPrism2.delegate = self
        
        self.rFarBC.delegate = self
        self.lFarBC.delegate = self
        self.rFarDiameter.delegate = self
        self.lFarDiameter.delegate = self
        
        self.rInterBC.delegate = self
        self.lInterBC.delegate = self
        self.rInterDiameter.delegate = self
        self.lInterDiameter.delegate = self
        
        self.rNearBC.delegate = self
        self.lNearBC.delegate = self
        self.rNearDiameter.delegate = self
        self.lNearDiameter.delegate = self
        
        self.rFarSdp.delegate = self
        self.lFarSdp.delegate = self
        self.farDpTotal.delegate = self
        
        self.rInterSdp.delegate = self
        self.lInterSdp.delegate = self
        self.interDpTotal.delegate = self
        
        self.rNearSdp.delegate = self
        self.lNearSdp.delegate = self
        self.nearDpTotal.delegate = self
        
        self.rFarACN.delegate = self
        self.rFarACC.delegate = self
        self.lFarACN.delegate = self
        self.lFarACC.delegate = self
        
        self.rInterACN.delegate = self
        self.rInterACC.delegate = self
        self.lInterACN.delegate = self
        self.lInterACC.delegate = self
        
        self.rNearACN.delegate = self
        self.rNearACC.delegate = self
        self.lNearACN.delegate = self
        self.lNearACC.delegate = self
        
        self.tfPerformedByName.delegate = self
        self.tfPerformedByType.delegate = self
        self.tfExpiryDate.delegate = self
        self.tvNotes.delegate = self
        self.tabBar.delegate = self
        self.pickerViewSimple.delegate = self
        self.pickerViewSimple.dataSource = self
        self.pickerViewDouble.delegate = self
        self.pickerViewDouble.dataSource = self
    }
    
    func validateFields() -> Bool{
        if let type = self.tfPerformedByType.text{
            if type.isEmpty{
                Util.GeneralAlert(viewController: self, message: Util.getString("Optician not selected"))
                return false
            }
            if let name = self.tfPerformedByName.text{
                if name.isEmpty{
                    Util.GeneralAlert(viewController: self, message: Util.getString("Optician not selected"))
                    return false
                }
            }
            else{
                Util.GeneralAlert(viewController: self, message: Util.getString("Optician not selected"))
                return false
            }
        }
        else{
            Util.GeneralAlert(viewController: self, message: Util.getString("Optician not selected"))
            return false
        }
        if settings.storeSetupSettings.enableClinicalStatusValidation {
            if (self.rFarAdd.text!.isEmpty  && self.rInterAdd.text!.isEmpty && self.rNearAdd.text!.isEmpty && self.rFarSph.text!.isEmpty
                && self.rInterSph.text!.isEmpty && self.rNearSph.text!.isEmpty && self.rFarCylAx.text!.isEmpty && self.rInterCylAx.text!.isEmpty
                && self.rNearCylAx.text!.isEmpty && self.lFarAdd.text!.isEmpty && self.lInterAdd.text!.isEmpty && self.lNearAdd.text!.isEmpty
                && self.lFarSph.text!.isEmpty && self.lInterSph.text!.isEmpty && self.lNearSph.text!.isEmpty && self.lFarCylAx.text!.isEmpty
                && self.lInterCylAx.text!.isEmpty && self.lNearCylAx.text!.isEmpty) {
                
                Util.GeneralAlert(viewController: self, message: Util.getString("ClinicalStatusDetailValidateFields"))
                return false
            }
        }
        
        return true
    }
    
    @objc func saveClinicalStatus(){
        if self.validateFields(){
            self.saveGeneralControlValues()
            self.saveControlValues()
            self.beforeSaveClinicalStatus()
        }
    }
    
    func saveGeneralControlValues(){
        self.clinicalStatus.NOTES = self.tvNotes.text
        self.clinicalStatus.ExpiryDate = self.datePicker.date
        self.clinicalStatus.PERFORMED_BY_NAME = self.tfPerformedByName.text
        
        if let type = self.tfPerformedByType.text{
            self.clinicalStatus.PERFORMED_BY_TYPE = findKeyForValue(value: type)
        }
    }
    
    @objc func moreButtonAlert(){
        let alert = UIAlertController(title: nil, message: nil, preferredStyle: .alert)
        
        if ((settings.LoggedInUserPermissons?.contains("CANMODIFYPRESCRIPTION")) == true){
                let transposeAction = UIAlertAction(title: "Transpose", style: .default) { (action) -> Void in
                    self.transposeAction()
                }
                alert.addAction(transposeAction)
            }
        
        var changeMeasurementMethodTo = ""
        if (self.lastMeasurementMethod == "T"){
            changeMeasurementMethodTo = "Internazionale"
        }
        else if (self.lastMeasurementMethod == "I"){
            changeMeasurementMethodTo = "Tabo"
        }
        
        let taboInternazionaleAction = UIAlertAction(title: "Switch to \(changeMeasurementMethodTo)", style: .default) { (action) -> Void in
            self.measurementMethod_Changed(measurementMethod: changeMeasurementMethodTo)
        }
        let cancelAction = UIAlertAction(title: Util.getString("Cancel"), style: .destructive) { (action) -> Void in
            return
        }
        
        let printAction = UIAlertAction(title: Util.getString("Print"), style: .default) {(action) -> Void in
            self.printClinicalStatusReport()
        }
        

        alert.addAction(taboInternazionaleAction)
        
        if self.isNew == false{
            alert.addAction(printAction)
        }
        
        alert.addAction(cancelAction)
        
        present(alert, animated: true, completion: nil)
    }
    
    func tabBar(_ tabBar: UITabBar, didSelect item: UITabBarItem) {
        if(item.tag == 0) {
            self.lfDistance.text = "\(clinicalStatus.getPrescriptionsType())"
            self.LoadAll()
            if self.viewFarLVL1.isHidden && self.viewFarLVL2.isHidden && self.viewFarLVL3.isHidden && self.viewFarLVL4.isHidden{
                self.hideFar(isHiden: false)
            }
            if self.viewInterLVL1.isHidden && self.viewInterLVL2.isHidden && self.viewInterLVL3.isHidden && self.viewInterLVL4.isHidden{
                self.hideInter(isHiden: false)
            }
            if self.viewNearLVL1.isHidden && self.viewNearLVL2.isHidden && self.viewNearLVL3.isHidden && self.viewNearLVL4.isHidden{
                self.hideNear(isHiden: false)
            }
            self.lockView(isUserInteractionEnabled: true)
        }
        else if(item.tag == 1){
            self.lfDistance.text = "\(clinicalStatus.getPrescriptionsType())-\(item.title!)"
            self.LoadFar()
            self.hideFar(isHiden: false)
            self.hideInter(isHiden: true)
            self.hideNear(isHiden: true)
            self.lockView(isUserInteractionEnabled: true)
        }
        else if(item.tag == 2){
            self.lfDistance.text = "\(clinicalStatus.getPrescriptionsType())-\(item.title!)"
            self.LoadIntermediate()
            self.hideInter(isHiden: false)
            self.hideFar(isHiden: true)
            self.hideNear(isHiden: true)
            self.lockView(isUserInteractionEnabled: true)
        }
        else if(item.tag == 3){
            self.lfDistance.text = "\(clinicalStatus.getPrescriptionsType())-\(item.title!)"
            self.LoadNear()
            self.hideNear(isHiden: false)
            self.hideFar(isHiden: true)
            self.hideInter(isHiden: true)
            self.lockView(isUserInteractionEnabled: true)
        }
        self.adjustLayout(item: item)
    }
    
    func adjustLayout(item: UITabBarItem){
        if item.tag == 0 {
            self.headerViewHeight.constant = 132
            if clinicalStatus.PrescriptionType == "CL"{
                self.clViewHeight.constant = 111
                self.glViewHeight.constant = 0
            }
            else if clinicalStatus.PrescriptionType == "GL"{
                self.clViewHeight.constant = 0
                self.glViewHeight.constant = 111
            }
            self.footerViewHeight.constant = 132
            self.setFieldsFont()
        }
        else{
            self.headerViewHeight.constant = 72
            if clinicalStatus.PrescriptionType == "CL"{
                self.clViewHeight.constant = 51
                self.glViewHeight.constant = 0
            }
            else if clinicalStatus.PrescriptionType == "GL"{
                self.clViewHeight.constant = 0
                self.glViewHeight.constant = 51
            }
            self.footerViewHeight.constant = 72
            self.setFieldsFont()
        }
    }
    
    func adjustFontSize(textField: UITextField, size: CGFloat){
        if lastDistanceType == "A"{
            if let font = textField.font{
                textField.font = UIFont.systemFont(ofSize: font.pointSize + size)
            }
            else{
                textField.font = UIFont.systemFont(ofSize: UIFont.systemFontSize)
            }
        }
        else{
            if let font = textField.font{
                textField.font = UIFont.boldSystemFont(ofSize: font.pointSize + size)
            }
            else{
                textField.font = UIFont.boldSystemFont(ofSize: UIFont.systemFontSize)
            }
        }
    }
    
    func adjustFontSize(textField: UITextField){
        if lastDistanceType == "A"{
            if let font = textField.font{
                textField.font = UIFont.systemFont(ofSize: font.pointSize)
            }
            else{
                textField.font = UIFont.systemFont(ofSize: UIFont.systemFontSize)
            }
        }
        else{
            if let font = textField.font{
                textField.font = UIFont.boldSystemFont(ofSize: font.pointSize)
            }
            else{
                textField.font = UIFont.boldSystemFont(ofSize: UIFont.systemFontSize)
            }
        }
    }
    
    func setFieldsFont(){
        adjustFontSize(textField: self.rFarAdd)
        adjustFontSize(textField: self.rFarSph)
        adjustFontSize(textField: self.rFarCylAx)
        adjustFontSize(textField: self.lFarAdd)
        adjustFontSize(textField: self.lFarSph)
        adjustFontSize(textField: self.lFarCylAx)
        
        adjustFontSize(textField: self.rFarPrism1)
        adjustFontSize(textField: self.lFarPrism1)
        adjustFontSize(textField: self.rFarPrism2)
        adjustFontSize(textField: self.lFarPrism2)
        
        adjustFontSize(textField: self.rFarBC)
        adjustFontSize(textField: self.lFarBC)
        adjustFontSize(textField: self.rFarDiameter)
        adjustFontSize(textField: self.lFarDiameter)
        
        adjustFontSize(textField: self.rFarSdp)
        adjustFontSize(textField: self.lFarSdp)
        adjustFontSize(textField: self.farDpTotal)
        
        adjustFontSize(textField: self.rFarACC)
        adjustFontSize(textField: self.lFarACC)
        adjustFontSize(textField: self.rFarACN)
        adjustFontSize(textField: self.lFarACN)
        //
        adjustFontSize(textField: self.rInterAdd)
        adjustFontSize(textField: self.rInterSph)
        adjustFontSize(textField: self.rInterCylAx)
        adjustFontSize(textField: self.lInterAdd)
        adjustFontSize(textField: self.lInterSph)
        adjustFontSize(textField: self.lInterCylAx)
        
        adjustFontSize(textField: self.rInterPrism1)
        adjustFontSize(textField: self.lInterPrism1)
        adjustFontSize(textField: self.rInterPrism2)
        adjustFontSize(textField: self.lInterPrism2)
        
        adjustFontSize(textField: self.rInterBC)
        adjustFontSize(textField: self.lInterBC)
        adjustFontSize(textField: self.rInterDiameter)
        adjustFontSize(textField: self.lInterDiameter)
        
        adjustFontSize(textField: self.rInterSdp)
        adjustFontSize(textField: self.lInterSdp)
        adjustFontSize(textField: self.interDpTotal)
        
        adjustFontSize(textField: self.rInterACC)
        adjustFontSize(textField: self.lInterACC)
        adjustFontSize(textField: self.rInterACN)
        adjustFontSize(textField: self.lInterACN)
        //
        adjustFontSize(textField: self.rNearAdd)
        adjustFontSize(textField: self.rNearSph)
        adjustFontSize(textField: self.rNearCylAx)
        adjustFontSize(textField: self.lNearAdd)
        adjustFontSize(textField: self.lNearSph)
        adjustFontSize(textField: self.lNearCylAx)
        
        adjustFontSize(textField: self.rNearPrism1)
        adjustFontSize(textField: self.lNearPrism1)
        adjustFontSize(textField: self.rNearPrism2)
        adjustFontSize(textField: self.lNearPrism2)
        
        adjustFontSize(textField: self.rNearBC)
        adjustFontSize(textField: self.lNearBC)
        adjustFontSize(textField: self.rNearDiameter)
        adjustFontSize(textField: self.lNearDiameter)
        
        adjustFontSize(textField: self.rNearSdp)
        adjustFontSize(textField: self.lNearSdp)
        adjustFontSize(textField: self.nearDpTotal)
        
        adjustFontSize(textField: self.rNearACC)
        adjustFontSize(textField: self.lNearACC)
        adjustFontSize(textField: self.rNearACN)
        adjustFontSize(textField: self.lNearACN)
    }
    
    func hideFar(isHiden: Bool){
        self.viewFarLVL1.isHidden = isHiden
        self.viewFarLVL2.isHidden = isHiden
        self.viewFarLVL3.isHidden = isHiden
        self.viewFarLVL4.isHidden = isHiden
        if isHiden{
            self.viewFarHeight1.constant = 0
            self.viewFarHeight2.constant = 0
            self.viewFarHeight3.constant = 0
            self.viewFarHeight4.constant = 0
        }
        else{
            self.viewFarHeight1.constant = 30
            self.viewFarHeight2.constant = 30
            self.viewFarHeight3.constant = 30
            self.viewFarHeight4.constant = 30
        }
        self.viewFarLVL1.layoutIfNeeded()
        self.viewFarLVL2.layoutIfNeeded()
        self.viewFarLVL3.layoutIfNeeded()
        self.viewFarLVL4.layoutIfNeeded()
    }
    
    func hideInter(isHiden: Bool){
        self.viewInterLVL1.isHidden = isHiden
        self.viewInterLVL2.isHidden = isHiden
        self.viewInterLVL3.isHidden = isHiden
        self.viewInterLVL4.isHidden = isHiden
        
        if isHiden{
            self.viewInterHeight1.constant = 0
            self.viewInterHeight2.constant = 0
            self.viewInterHeight3.constant = 0
            self.viewInterHeight4.constant = 0
        }
        else{
            self.viewInterHeight1.constant = 30
            self.viewInterHeight2.constant = 30
            self.viewInterHeight3.constant = 30
            self.viewInterHeight4.constant = 30
        }
        self.viewInterLVL1.layoutIfNeeded()
        self.viewInterLVL2.layoutIfNeeded()
        self.viewInterLVL3.layoutIfNeeded()
        self.viewInterLVL4.layoutIfNeeded()
    }
    
    func hideNear(isHiden: Bool){
        self.viewNearLVL1.isHidden = isHiden
        self.viewNearLVL2.isHidden = isHiden
        self.viewNearLVL3.isHidden = isHiden
        self.viewNearLVL4.isHidden = isHiden
        
        if isHiden{
            self.viewNearHeight1.constant = 0
            self.viewNearHeight2.constant = 0
            self.viewNearHeight3.constant = 0
            self.viewNearHeight4.constant = 0
        }
        else{
            self.viewNearHeight1.constant = 30
            self.viewNearHeight2.constant = 30
            self.viewNearHeight3.constant = 30
            self.viewNearHeight4.constant = 30
        }
        self.viewNearLVL1.layoutIfNeeded()
        self.viewNearLVL2.layoutIfNeeded()
        self.viewNearLVL3.layoutIfNeeded()
        self.viewNearLVL4.layoutIfNeeded()
    }
    
    func lockView(isUserInteractionEnabled: Bool){
        self.headerView.isUserInteractionEnabled = isUserInteractionEnabled
        self.glView.isUserInteractionEnabled = isUserInteractionEnabled
        self.clView.isUserInteractionEnabled = isUserInteractionEnabled
        self.footerView.isUserInteractionEnabled = isUserInteractionEnabled
    }
    
    func LoadAll(){
        self.LoadFar()
        self.LoadIntermediate()
        self.LoadNear()
        self.lastDistanceType = "A"
    }
    
    func LoadFar(){
        rFarSph.text = self.clinicalStatus.R_DIST_SPHERE
        lFarSph.text = self.clinicalStatus.L_DIST_SPHERE
        
        rFarCylAx.text = getCylAx(cylinder: self.clinicalStatus.R_DIST_CYLINDER, axis: self.clinicalStatus.R_DIST_AXIS)
        self._rFarCylValue = self.clinicalStatus.R_DIST_CYLINDER
        self._rFarAxisValue = self.clinicalStatus.R_DIST_AXIS
        lFarCylAx.text = getCylAx(cylinder: self.clinicalStatus.L_DIST_CYLINDER, axis: self.clinicalStatus.L_DIST_AXIS)
        self._lFarCylValue = self.clinicalStatus.L_DIST_CYLINDER
        self._lFarAxisValue = self.clinicalStatus.L_DIST_AXIS
        
        if(clinicalStatus.PrescriptionType == "GL"){
            rFarPrism1.text = getPrismBase(prism: self.clinicalStatus.R_DIST_PRISM1, base: self.clinicalStatus.R_DIST_BASE1)
            self._rFarPrism1Value = self.clinicalStatus.R_DIST_PRISM1
            self._rFarBase1Value = self.clinicalStatus.R_DIST_BASE1
            lFarPrism1.text = getPrismBase(prism: self.clinicalStatus.L_DIST_PRISM1, base: self.clinicalStatus.L_DIST_BASE1)
            self._lFarPrism1Value = self.clinicalStatus.L_DIST_PRISM1
            self._lFarBase1Value = self.clinicalStatus.L_DIST_BASE1
            rFarPrism2.text = getPrismBase(prism: self.clinicalStatus.R_DIST_PRISM2, base: self.clinicalStatus.R_DIST_BASE2)
            self._rFarPrism2Value = self.clinicalStatus.R_DIST_PRISM2
            self._rFarBase2Value = self.clinicalStatus.R_DIST_BASE2
            lFarPrism2.text = getPrismBase(prism: self.clinicalStatus.L_DIST_PRISM2, base: self.clinicalStatus.L_DIST_BASE2)
            self._lFarPrism2Value = self.clinicalStatus.L_DIST_PRISM2
            self._lFarBase2Value = self.clinicalStatus.L_DIST_BASE2
        }
        else if( clinicalStatus.PrescriptionType == "CL"){
            rFarBC.text = self.clinicalStatus.R_DIST_RB
            lFarBC.text = self.clinicalStatus.L_DIST_RB
            rFarDiameter.text = self.clinicalStatus.R_DIST_DIAMETER
            lFarDiameter.text = self.clinicalStatus.L_DIST_DIAMETER
        }
        
        rFarSdp.text = self.clinicalStatus.R_DIST_PD
        lFarSdp.text = self.clinicalStatus.L_DIST_PD
        
        
        calculateDpTotal(textField: farDpTotal, rText: self.clinicalStatus.R_DIST_PD, lText: self.clinicalStatus.L_DIST_PD)
        
        rFarACN.text = self.clinicalStatus.R_DIST_ACUITY
        lFarACN.text = self.clinicalStatus.L_DIST_ACUITY
        rFarACC.text = self.clinicalStatus.R_DIST_ACUITYAIDED
        lFarACC.text = self.clinicalStatus.L_DIST_ACUITYAIDED
        
        lastDistanceType = "D"
    }

    func LoadNear(){
        rNearAdd.text = self.clinicalStatus.R_NEAR_ADD
        lNearAdd.text = self.clinicalStatus.L_NEAR_ADD
        
        rNearSph.text = self.clinicalStatus.R_NEAR_SPHERE
        lNearSph.text = self.clinicalStatus.L_NEAR_SPHERE
        
        rNearCylAx.text = getCylAx(cylinder: self.clinicalStatus.R_NEAR_CYLINDER, axis: self.clinicalStatus.R_NEAR_AXIS)
        self._rNearCylValue = self.clinicalStatus.R_NEAR_CYLINDER
        self._rNearAxisValue = self.clinicalStatus.R_NEAR_AXIS
        lNearCylAx.text = getCylAx(cylinder: self.clinicalStatus.L_NEAR_CYLINDER, axis: self.clinicalStatus.L_NEAR_AXIS)
        self._lNearCylValue = self.clinicalStatus.L_NEAR_CYLINDER
        self._lNearAxisValue = self.clinicalStatus.L_NEAR_AXIS
        
        if(clinicalStatus.PrescriptionType == "GL"){
            rNearPrism1.text = getPrismBase(prism: self.clinicalStatus.R_NEAR_PRISM1, base: self.clinicalStatus.R_NEAR_BASE1)
            self._rNearPrism1Value = self.clinicalStatus.R_NEAR_PRISM1
            self._rNearBase1Value = self.clinicalStatus.R_NEAR_BASE1
            lNearPrism1.text = getPrismBase(prism: self.clinicalStatus.L_NEAR_PRISM1, base: self.clinicalStatus.L_NEAR_BASE1)
            self._lNearPrism1Value = self.clinicalStatus.L_NEAR_PRISM1
            self._lNearBase1Value = self.clinicalStatus.L_NEAR_BASE1
            rNearPrism2.text = getPrismBase(prism: self.clinicalStatus.R_NEAR_PRISM2, base: self.clinicalStatus.R_NEAR_BASE2)
            self._rNearPrism2Value = self.clinicalStatus.R_NEAR_PRISM2
            self._rNearBase2Value = self.clinicalStatus.R_NEAR_BASE2
            lNearPrism2.text = getPrismBase(prism: self.clinicalStatus.L_NEAR_PRISM2, base: self.clinicalStatus.L_NEAR_BASE2)
            self._lNearPrism2Value = self.clinicalStatus.L_NEAR_PRISM2
            self._lNearBase2Value = self.clinicalStatus.L_NEAR_BASE2
        }
        else if( clinicalStatus.PrescriptionType == "CL"){
            rNearBC.text = self.clinicalStatus.R_NEAR_RB
            lNearBC.text = self.clinicalStatus.L_NEAR_RB
            rNearDiameter.text = self.clinicalStatus.R_NEAR_DIAMETER
            lNearDiameter.text = self.clinicalStatus.L_NEAR_DIAMETER
        }
        
        rNearSdp.text = self.clinicalStatus.R_NEAR_PD
        lNearSdp.text = self.clinicalStatus.L_NEAR_PD
        
        calculateDpTotal(textField: nearDpTotal, rText: self.clinicalStatus.R_NEAR_PD, lText: self.clinicalStatus.L_NEAR_PD)
        
        rNearACN.text = self.clinicalStatus.R_NEAR_ACUITY
        lNearACN.text = self.clinicalStatus.L_NEAR_ACUITY
        rNearACC.text = self.clinicalStatus.R_NEAR_ACUITYAIDED
        lNearACC.text = self.clinicalStatus.L_NEAR_ACUITYAIDED
        
        lastDistanceType = "N"
    }
    
    func LoadIntermediate(){
        rInterAdd.text = self.clinicalStatus.R_INTER_ADD
        lInterAdd.text = self.clinicalStatus.L_INTER_ADD
        
        rInterSph.text = self.clinicalStatus.R_INTER_SPHERE
        lInterSph.text = self.clinicalStatus.L_INTER_SPHERE
        
        rInterCylAx.text = getCylAx(cylinder: self.clinicalStatus.R_INTER_CYLINDER, axis: self.clinicalStatus.R_INTER_AXIS)
        self._rInterCylValue = self.clinicalStatus.R_INTER_CYLINDER
        self._rInterAxisValue = self.clinicalStatus.R_INTER_AXIS
        lInterCylAx.text = getCylAx(cylinder: self.clinicalStatus.L_INTER_CYLINDER, axis: self.clinicalStatus.L_INTER_AXIS)
        self._lInterCylValue = self.clinicalStatus.L_INTER_CYLINDER
        self._lInterAxisValue = self.clinicalStatus.L_INTER_AXIS
        
        if(clinicalStatus.PrescriptionType == "GL"){
            rInterPrism1.text = getPrismBase(prism: self.clinicalStatus.R_INTER_PRISM1, base: self.clinicalStatus.R_INTER_BASE1)
            self._rInterPrism1Value = self.clinicalStatus.R_INTER_PRISM1
            self._rInterBase1Value = self.clinicalStatus.R_INTER_BASE1
            lInterPrism1.text = getPrismBase(prism: self.clinicalStatus.L_INTER_PRISM1, base: self.clinicalStatus.L_INTER_BASE1)
            self._lInterPrism1Value = self.clinicalStatus.L_INTER_PRISM1
            self._lInterBase1Value = self.clinicalStatus.L_INTER_BASE1
            rInterPrism2.text = getPrismBase(prism: self.clinicalStatus.R_INTER_PRISM2, base: self.clinicalStatus.R_INTER_BASE2)
            self._rInterPrism2Value = self.clinicalStatus.R_INTER_PRISM2
            self._rInterBase2Value = self.clinicalStatus.R_INTER_BASE2
            lInterPrism2.text = getPrismBase(prism: self.clinicalStatus.L_INTER_PRISM2, base: self.clinicalStatus.L_INTER_BASE2)
            self._lInterPrism2Value = self.clinicalStatus.L_INTER_PRISM2
            self._lInterBase2Value = self.clinicalStatus.L_INTER_BASE2
        }
        else if( clinicalStatus.PrescriptionType == "CL"){
            rInterBC.text = self.clinicalStatus.R_INTER_RB
            lInterBC.text = self.clinicalStatus.L_INTER_RB
            rInterDiameter.text = self.clinicalStatus.R_INTER_DIAMETER
            lInterDiameter.text = self.clinicalStatus.L_INTER_DIAMETER
        }
        
        rInterSdp.text = self.clinicalStatus.R_INTER_PD
        lInterSdp.text = self.clinicalStatus.L_INTER_PD
        calculateDpTotal(textField: interDpTotal, rText: self.clinicalStatus.R_INTER_PD, lText: self.clinicalStatus.L_INTER_PD)
        
        rInterACN.text = self.clinicalStatus.R_INTER_ACUITY
        lInterACN.text = self.clinicalStatus.L_INTER_ACUITY
        rInterACC.text = self.clinicalStatus.R_INTER_ACUITYAIDED
        lInterACC.text = self.clinicalStatus.L_INTER_ACUITYAIDED
        
        lastDistanceType = "I"
    }
    
    func measurementMethod_Changed(measurementMethod: String) {
        if self.lastMeasurementMethod == "T"{
            self.clinicalStatus.MeasurementMethod = "I"
        }
        else if self.lastMeasurementMethod == "I"{
            self.clinicalStatus.MeasurementMethod = "T"
        }
        
        self.lastMeasurementMethod = clinicalStatus.MeasurementMethod?.first
        
        if (self.clinicalStatus.L_DIST_AXIS != nil && self.clinicalStatus.L_DIST_AXIS != "")
        || (self.clinicalStatus.L_NEAR_AXIS != nil && self.clinicalStatus.L_NEAR_AXIS != "")
        || (self.clinicalStatus.L_INTER_AXIS != nil && self.clinicalStatus.L_INTER_AXIS != ""){
            self.alertMeasurementTypeChanged(measurementMethod: measurementMethod)
        }
        self.save.isEnabled = true
    }
    
    func alertMeasurementTypeChanged(measurementMethod: String){
        let message = String.init(format: Util.getString("ConverAxisToT/I"), "\(measurementMethod)")
        
        let alertController = UIAlertController(title: "iPOS", message: message, preferredStyle: .alert)
        
        let yes = UIAlertAction(title: Util.getString("Yes"), style: .default) { (action) -> Void in
            self.changeMeasurementType()
        }
        
        let no = UIAlertAction(title: Util.getString("No"), style: .default) { (action) -> Void in
            return
        }
        
        alertController.addAction(yes)
        alertController.addAction(no)
        
        self.present(alertController, animated: true, completion: nil)
    }
    
    func changeMeasurementType(){
        if let value = self.clinicalStatus.L_DIST_AXIS{
            if let axis = Int(value){
                self.clinicalStatus.L_DIST_AXIS = "\(180 - axis)"
            }
        }

        if let value = self.clinicalStatus.L_NEAR_AXIS{
            if let axis = Int(value){
                self.clinicalStatus.L_NEAR_AXIS = "\(180 - axis)"
            }
        }
        
        if let value = self.clinicalStatus.L_INTER_AXIS{
            if let axis = Int(value){
                self.clinicalStatus.L_INTER_AXIS = "\(180 - axis)"
            }
        }
        
        self.reloadData()
        
        Util.notifyWhenTextWasChanged(textField: lFarCylAx)
        Util.notifyWhenTextWasChanged(textField: lInterCylAx)
        Util.notifyWhenTextWasChanged(textField: lNearCylAx)
    }
    
    func transposeAction() {
        self.transposeDIST()
        self.transposeNEAR()
        self.transposeINTER()
        
        self.reloadData()
        
        Util.notifyWhenTextWasChanged(textField: rFarSph)
        Util.notifyWhenTextWasChanged(textField: lFarSph)
        Util.notifyWhenTextWasChanged(textField: rInterSph)
        Util.notifyWhenTextWasChanged(textField: lInterSph)
        Util.notifyWhenTextWasChanged(textField: rNearSph)
        Util.notifyWhenTextWasChanged(textField: lNearSph)
        
        Util.notifyWhenTextWasChanged(textField: rFarCylAx)
        Util.notifyWhenTextWasChanged(textField: lFarCylAx)
        Util.notifyWhenTextWasChanged(textField: rInterCylAx)
        Util.notifyWhenTextWasChanged(textField: lInterCylAx)
        Util.notifyWhenTextWasChanged(textField: rNearCylAx)
        Util.notifyWhenTextWasChanged(textField: lNearCylAx)
        
        self.save.isEnabled = true
    }
    
    func transposeDIST(){
        if let sph = clinicalStatus.L_DIST_SPHERE{
            if let sphValue = Double(sph){
                if let cyl = clinicalStatus.L_DIST_CYLINDER{
                    if let cylValue = Double(cyl){
                        let newSPHValue = sphValue + cylValue
                        if newSPHValue > 0{
                            self.clinicalStatus.L_DIST_SPHERE = "+\(Util.DoubleToStringWithPointSeparator(newSPHValue))"
                        }
                        else{
                            self.clinicalStatus.L_DIST_SPHERE = "\(Util.DoubleToStringWithPointSeparator(newSPHValue))"
                        }
                        
                        let newCYLValue = cylValue * (-1)
                        if newCYLValue > 0 {
                            self.clinicalStatus.L_DIST_CYLINDER = "+\(Util.DoubleToStringWithPointSeparator(newCYLValue))"
                        }
                        else{
                            self.clinicalStatus.L_DIST_CYLINDER = "\(Util.DoubleToStringWithPointSeparator(newCYLValue))"
                        }
                    }
                }
            }
        }
        if let axis = self.clinicalStatus.L_DIST_AXIS{
            if let axisValue = Int(axis){
                let newAxisValue = axisValue + 90
                if newAxisValue > 180{
                    self.clinicalStatus.L_DIST_AXIS = "\(newAxisValue - 180)"
                }
                else{
                    self.clinicalStatus.L_DIST_AXIS = "\(newAxisValue)"
                }
            }
        }
        if let sph = clinicalStatus.R_DIST_SPHERE{
            if let sphValue = Double(sph){
                if let cyl = clinicalStatus.R_DIST_CYLINDER{
                    if let cylValue = Double(cyl){
                        let newSPHValue = sphValue + cylValue
                        if newSPHValue > 0{
                            self.clinicalStatus.R_DIST_SPHERE = "+\(Util.DoubleToStringWithPointSeparator(newSPHValue))"
                        }
                        else{
                            self.clinicalStatus.R_DIST_SPHERE = "\(Util.DoubleToStringWithPointSeparator(newSPHValue))"
                        }
                        
                        let newCYLValue = cylValue * (-1)
                        if newCYLValue > 0 {
                            self.clinicalStatus.R_DIST_CYLINDER = "+\(Util.DoubleToStringWithPointSeparator(newCYLValue))"
                        }
                        else{
                            self.clinicalStatus.R_DIST_CYLINDER = "\(Util.DoubleToStringWithPointSeparator(newCYLValue))"
                        }
                    }
                }
            }
        }
        if let axis = self.clinicalStatus.R_DIST_AXIS{
            if let axisValue = Int(axis){
                let newAxisValue = axisValue + 90
                if newAxisValue > 180{
                    self.clinicalStatus.R_DIST_AXIS = "\(newAxisValue - 180)"
                }
                else{
                    self.clinicalStatus.R_DIST_AXIS = "\(newAxisValue)"
                }
            }
        }
    }
    
    func transposeNEAR(){
        if let sph = clinicalStatus.L_NEAR_SPHERE{
            if let sphValue = Double(sph){
                if let cyl = clinicalStatus.L_NEAR_CYLINDER{
                    if let cylValue = Double(cyl){
                        let newSPHValue = sphValue + cylValue
                        if newSPHValue > 0{
                            self.clinicalStatus.L_NEAR_SPHERE = "+\(Util.DoubleToStringWithPointSeparator(newSPHValue))"
                        }
                        else{
                            self.clinicalStatus.L_NEAR_SPHERE = "\(Util.DoubleToStringWithPointSeparator(newSPHValue))"
                        }
                        
                        let newCYLValue = cylValue * (-1)
                        if newCYLValue > 0 {
                            self.clinicalStatus.L_NEAR_CYLINDER = "+\(Util.DoubleToStringWithPointSeparator(newCYLValue))"
                        }
                        else{
                            self.clinicalStatus.L_NEAR_CYLINDER = "\(Util.DoubleToStringWithPointSeparator(newCYLValue))"
                        }
                    }
                }
            }
        }
        if let axis = self.clinicalStatus.L_NEAR_AXIS{
            if let axisValue = Int(axis){
                let newAxisValue = axisValue + 90
                if newAxisValue > 180{
                    self.clinicalStatus.L_NEAR_AXIS = "\(newAxisValue - 180)"
                }
                else{
                    self.clinicalStatus.L_NEAR_AXIS = "\(newAxisValue)"
                }
            }
        }
        if let sph = clinicalStatus.R_NEAR_SPHERE{
            if let sphValue = Double(sph){
                if let cyl = clinicalStatus.R_NEAR_CYLINDER{
                    if let cylValue = Double(cyl){
                        let newSPHValue = sphValue + cylValue
                        if newSPHValue > 0{
                            self.clinicalStatus.R_NEAR_SPHERE = "+\(Util.DoubleToStringWithPointSeparator(newSPHValue))"
                        }
                        else{
                            self.clinicalStatus.R_NEAR_SPHERE = "\(Util.DoubleToStringWithPointSeparator(newSPHValue))"
                        }
                        
                        let newCYLValue = cylValue * (-1)
                        if newCYLValue > 0 {
                            self.clinicalStatus.R_NEAR_CYLINDER = "+\(Util.DoubleToStringWithPointSeparator(newCYLValue))"
                        }
                        else{
                            self.clinicalStatus.R_NEAR_CYLINDER = "\(Util.DoubleToStringWithPointSeparator(newCYLValue))"
                        }
                    }
                }
            }
        }
        if let axis = self.clinicalStatus.R_NEAR_AXIS{
            if let axisValue = Int(axis){
                let newAxisValue = axisValue + 90
                if newAxisValue > 180{
                    self.clinicalStatus.R_NEAR_AXIS = "\(newAxisValue - 180)"
                }
                else{
                    self.clinicalStatus.R_NEAR_AXIS = "\(newAxisValue)"
                }
            }
        }
    }
    
    func transposeINTER(){
        if let sph = clinicalStatus.L_INTER_SPHERE{
            if let sphValue = Double(sph){
                if let cyl = clinicalStatus.L_INTER_CYLINDER{
                    if let cylValue = Double(cyl){
                        let newSPHValue = sphValue + cylValue
                        if newSPHValue > 0{
                            self.clinicalStatus.L_INTER_SPHERE = "+\(Util.DoubleToStringWithPointSeparator(newSPHValue))"
                        }
                        else{
                            self.clinicalStatus.L_INTER_SPHERE = "\(Util.DoubleToStringWithPointSeparator(newSPHValue))"
                        }
                        
                        let newCYLValue = cylValue * (-1)
                        if newCYLValue > 0 {
                            self.clinicalStatus.L_INTER_CYLINDER = "+\(Util.DoubleToStringWithPointSeparator(newCYLValue))"
                        }
                        else{
                            self.clinicalStatus.L_INTER_CYLINDER = "\(Util.DoubleToStringWithPointSeparator(newCYLValue))"
                        }
                    }
                }
            }
        }
        if let axis = self.clinicalStatus.L_INTER_AXIS{
            if let axisValue = Int(axis){
                let newAxisValue = axisValue + 90
                if newAxisValue > 180{
                    self.clinicalStatus.L_INTER_AXIS = "\(newAxisValue - 180)"
                }
                else{
                    self.clinicalStatus.L_INTER_AXIS = "\(newAxisValue)"
                }
            }
        }
        if let sph = clinicalStatus.R_INTER_SPHERE{
            if let sphValue = Double(sph){
                if let cyl = clinicalStatus.R_INTER_CYLINDER{
                    if let cylValue = Double(cyl){
                        let newSPHValue = sphValue + cylValue
                        if newSPHValue > 0{
                            self.clinicalStatus.R_INTER_SPHERE = "+\(Util.DoubleToStringWithPointSeparator(newSPHValue))"
                        }
                        else{
                            self.clinicalStatus.R_INTER_SPHERE = "\(Util.DoubleToStringWithPointSeparator(newSPHValue))"
                        }
                        
                        let newCYLValue = cylValue * (-1)
                        if newCYLValue > 0 {
                            self.clinicalStatus.R_INTER_CYLINDER = "+\(Util.DoubleToStringWithPointSeparator(newCYLValue))"
                        }
                        else{
                            self.clinicalStatus.R_INTER_CYLINDER = "\(Util.DoubleToStringWithPointSeparator(newCYLValue))"
                        }
                    }
                }
            }
        }
        if let axis = self.clinicalStatus.R_INTER_AXIS{
            if let axisValue = Int(axis){
                let newAxisValue = axisValue + 90
                if newAxisValue > 180{
                    self.clinicalStatus.R_INTER_AXIS = "\(newAxisValue - 180)"
                }
                else{
                    self.clinicalStatus.R_INTER_AXIS = "\(newAxisValue)"
                }
            }
        }
    }
    
    func reloadData(){
        if let lastDistance = self.lastDistanceType{
            if lastDistance == "A"{
                self.LoadAll()
            }
            else if lastDistance == "D"{
                self.LoadFar()
            }
            else if lastDistance == "N"{
                self.LoadNear()
            }
            else if lastDistance == "I"{
                self.LoadIntermediate()
            }
        }
    }
    
    func isSaveButtonEnabled(isEnabled: Bool) {
        self.save.isEnabled = isEnabled
    }
    
    func openPopup(){
        if let value = self.tfPerformedByType.text{
            let type = self.findKeyForValue(value: value)
            if type == "OP" || type == "OM"{
                self.loadUsers(type: type)
            }
            else if type == "OC"{
                self.loadPrescribers()
            }
        }
    }
    
    func loadUsers(type: String){
        var shouldBeAddButtonHidden = false
        if settings.storeSetupSettings.clientName.uppercased() == "NAU!"{
            shouldBeAddButtonHidden = true
        }
        
        if self.usersDataSource.count > 0 {
            self.openPopUp(self.tfPerformedByName, self.performedByNameDataSource as! [INameable], "SecuritySystemUser_\(type)", self.tfPerformedByType.text!, shouldBeSearchBarHidden: false, shouldBeAddButtonHidden: shouldBeAddButtonHidden)
        }
        else{
            State.loadUserAndRole(filterString: nil, completionHandler: { result in
                if let users = result{
                    for user in users{
                        self.usersDataSource.append(user)
                    }
                    self.openPopUp(self.tfPerformedByName, self.performedByNameDataSource as! [INameable], "SecuritySystemUser_\(type)", self.tfPerformedByType.text!, shouldBeSearchBarHidden: false, shouldBeAddButtonHidden: shouldBeAddButtonHidden)
                }
            })
        }
    }
    
    func loadPrescribers(){
        if self.prescribersDataSource.count > 0 {
            openPopUp(self.tfPerformedByName, self.performedByNameDataSource as! [INameable], "Prescriber", self.tfPerformedByType.text!, shouldBeSearchBarHidden: false, shouldBeAddButtonHidden: false)
        }
        else{
            State.loadPrescribers(filterString: nil, completionHandler: { result in
                if let prescribers = result{
                    for prescriber in prescribers{
                        self.prescribersDataSource.append(prescriber)
                    }
                    self.openPopUp(self.tfPerformedByName, self.performedByNameDataSource as! [INameable], "Prescriber", self.tfPerformedByType.text!, shouldBeSearchBarHidden: false, shouldBeAddButtonHidden: false)
                }
            })
        }
    }
    
    func adaptivePresentationStyle(for controller: UIPresentationController) -> UIModalPresentationStyle {
        return .fullScreen
    }
    
    func openPopUp(_ textField: UITextField, _ dataSource: [INameable], _ dataSourceType: String, _ title: String, shouldBeSearchBarHidden: Bool, shouldBeAddButtonHidden: Bool) {
        let popupSelectorViewController = self.storyboard?.instantiateViewController(withIdentifier: "popupSelectorViewController") as! PopupSelectorViewController
        popupSelectorViewController.shouldBeSearchBarHidden = shouldBeSearchBarHidden
        popupSelectorViewController.shouldBeAddButtonHidden = shouldBeAddButtonHidden
        popupSelectorViewController.itemSelectedCallback = selectedValue
        popupSelectorViewController.dataSource = dataSource
        popupSelectorViewController.dataSourceType = dataSourceType
        popupSelectorViewController.title = title
        let nav = UINavigationController(rootViewController: popupSelectorViewController)
        nav.modalPresentationStyle = UIModalPresentationStyle.fullScreen
        let popover = nav.popoverPresentationController
        popover?.permittedArrowDirections = .up
        popupSelectorViewController.preferredContentSize = CGSize(width: textField.frame.size.width, height: 300)
        popover?.delegate = self
        popover?.sourceView = textField
        popover?.sourceRect = CGRect(x: textField.frame.size.width/2.0, y: textField.frame.size.height, width: 0, height: 0)
        self.present(nav, animated: true, completion: nil)
    }
    
    func selectedValue(item: AnyObject, parentItem: AnyObject?){
        if item.isKind(of: Prescriber.self){
            let prescriber = item as! Prescriber
            self.clinicalStatus.PrescriberId = prescriber.prescriberId
            self.clinicalStatus.Prescriber = prescriber
            self.tfPerformedByName.text = prescriber.name
            
            self.clinicalStatus.OpticianId = nil
            self.clinicalStatus.Optician = nil
            
            self.saveGeneralControlValues()
        }
        if item.isKind(of: UserRole.self){
            let user = item as! UserRole
            self.clinicalStatus.OpticianId = user.userId
            let optician = SecuritySystemUser()
            optician.userId = user.userId
            optician.userName = user.userName
            self.clinicalStatus.Optician = optician
            self.tfPerformedByName.text = user.userName
            
            self.clinicalStatus.PrescriberId = nil
            self.clinicalStatus.Prescriber = nil
            
            self.saveGeneralControlValues()
        }
        else if item is String{
            if let value = self.tfPerformedByType.text{
                if let name = item as? String{
                    let type = self.findKeyForValue(value: value)
                    if type == "OC"{
                        self.addNewPrescriber(name: name, type: type)
                    }
                    else if type == "OM" || type == "OP"{
                        self.addNewUser(name: name, as: type)
                    }
                }
            }
        }
        self.isSaveButtonEnabled(isEnabled: true)
    }
    
    func addNewPrescriber(name: String, type: String){
        let prescriber = Prescriber()
        prescriber.type = type
        prescriber.name = name
        prescriber.storeId = Int(settings.StoreId)
        prescriber.countryId = settings.userSettings.countryId
        
        State.addPrescriber(prescriber) { result in
            if result == true {
                self.clinicalStatus.PrescriberId = prescriber.prescriberId
                self.clinicalStatus.Prescriber = prescriber
                self.tfPerformedByName.text = prescriber.name
                
                self.clinicalStatus.OpticianId = nil
                self.clinicalStatus.Optician = nil
                
                self.saveGeneralControlValues()
            }
            else if result == false {
                Util.AlertSystemError(viewController: self, message: Util.getString("The prescriber cannot be added for the moment, try again later."))
            }
            else if result == nil {
                NetworkController.AlertConnectionError(viewController: self)
            }
        }
    }
    
    func addNewUser(name: String, as type: String){
        let user = UserRequest()
        user.username = name
        user.roleCode = type
        
        State.addUserAndUserRole(user: user) { result in
            if result.resultCode == 0 {
                self.clinicalStatus.OpticianId = UUID.init(uuidString: result.userId!)
                let optician = SecuritySystemUser()
                optician.userId = UUID.init(uuidString: result.userId!)
                optician.userName = user.username
                self.clinicalStatus.Optician = optician
                self.tfPerformedByName.text = user.username
                
                self.clinicalStatus.PrescriberId = nil
                self.clinicalStatus.Prescriber = nil
                
                self.saveGeneralControlValues()
            }
            else{
                if let msg = result.resultMessage{
                    Util.AlertSystemError(viewController: self, message: msg)
                }
                else{
                    NetworkController.AlertConnectionError(viewController: self)
                }
            }
        }
    }
    
    func openDatePicker(_ sender: UITextField) {
        sender.inputAssistantItem.trailingBarButtonGroups = []
        sender.inputAssistantItem.leadingBarButtonGroups = []
        
        if #available(iOS 13.4, *) {
            self.datePicker.preferredDatePickerStyle = .wheels
        }
        
        self.datePicker.frame.origin.x = (self.view.frame.size.width - self.datePicker.frame.size.width)/2
        let inputView = UIView(frame: CGRect(x: 0, y: 0, width: self.view.frame.size.width, height: self.datePicker.frame.size.height))
        self.datePicker.datePickerMode = UIDatePicker.Mode.date
        inputView.addSubview(self.datePicker)
        
        let toolBar = UIToolbar()
        toolBar.frame.size.width = self.view.frame.size.width
        toolBar.barStyle = UIBarStyle.default
        toolBar.isTranslucent = true
        toolBar.tintColor = UIColor.black
        toolBar.sizeToFit()
        
        let doneButton = UIBarButtonItem(title: Util.getString("Done"), style: UIBarButtonItem.Style.done, target: self, action: #selector(self.doneButton(_:)))
        let spaceButton = UIBarButtonItem(barButtonSystemItem: UIBarButtonItem.SystemItem.flexibleSpace, target: nil, action: nil)
        let cancelButton = UIBarButtonItem(title: Util.getString("Clear"), style: UIBarButtonItem.Style.plain, target: self, action: #selector(self.cancelButton(_:)))
        
        toolBar.setItems([cancelButton, spaceButton, doneButton], animated: false)
        toolBar.isUserInteractionEnabled = true
        
        sender.inputView = inputView
        sender.inputAccessoryView = toolBar
        self.datePicker.addTarget(self, action: #selector(handleDatePicker(_:)), for: UIControl.Event.valueChanged)
        
        self.handleDatePicker(self.datePicker)
    }
    
    @objc func handleDatePicker(_ birthDatePicker: UIDatePicker) {
        self.tfExpiryDate.text = Util.DateToShortDateString(date: birthDatePicker.date)
        self.isSaveButtonEnabled(isEnabled: true)
    }
    
    @objc func doneButton(_ birthDatePicker: UIDatePicker){
        self.tfExpiryDate.resignFirstResponder()
        self.isSaveButtonEnabled(isEnabled: true)
    }
    
    @objc func cancelButton(_ birthDatePicker: UIDatePicker){
        self.tfExpiryDate.text = ""
        self.tfExpiryDate.resignFirstResponder()
        self.isSaveButtonEnabled(isEnabled: true)
    }
    
    func numberOfComponents(in pickerView: UIPickerView) -> Int {
        if(pickerView == pickerViewDouble){
            return 2
        }
        else{
            return 1
        }
    }
    
    func pickerView(_ pickerView: UIPickerView, numberOfRowsInComponent component: Int) -> Int {
        if(pickerView == pickerViewDouble){
            if pickerDataSourceDouble.count == 0 {
                return 0
            }
            
            if pickerDataSourceDouble[component].count == 0 {
                return 0
            }
            
            return pickerDataSourceDouble[component].count
        }
        else{
            if pickerDataSourceSimple.count == 0{
                return 0
            }
            return pickerDataSourceSimple.count
        }
    }
    
    func pickerView(_ pickerView: UIPickerView, titleForRow row: Int, forComponent component: Int) -> String? {
        if(pickerView == pickerViewDouble){
            if pickerDataSourceDouble.count == 0 {
                return nil
            }
            if pickerDataSourceDouble[component].count == 0 {
                return nil
            }
            if pickerDataSourceDouble[component].count > row {
                return pickerDataSourceDouble[component][row]
            }
            return nil
        }
        else{
            if pickerDataSourceSimple.count > row{
                return pickerDataSourceSimple[row]
            }
            return nil
        }
    }
    
    func pickerView(_ pickerView: UIPickerView, didSelectRow row: Int, inComponent component: Int) {
        if(pickerView == pickerViewDouble){
            if let textField = self.textEditing{
                if textField == self.rFarPrism1{
                    textField.text = getPrismBase(prism: rFarPrism1Value, base: rFarBase1Value)
                    self._rFarPrism1Value = rFarPrism1Value
                    
                    if component == 1 {
                        self._rFarBase1Value = rFarBase1Value
                    }
                }
                else if textField == self.rFarPrism2{
                    textField.text = getPrismBase(prism: rFarPrism2Value, base: rFarBase2Value)
                    self._rFarPrism2Value = rFarPrism2Value
                    
                    if component == 1 {
                        self._rFarBase2Value = rFarBase2Value
                    }
                }
                else if textField == self.lFarPrism1{
                    textField.text = getPrismBase(prism: lFarPrism1Value, base: lFarBase1Value)
                    self._lFarPrism1Value = lFarPrism1Value
                    
                    if component == 1 {
                        self._lFarBase1Value = lFarBase1Value
                    }
                }
                else if textField == self.lFarPrism2{
                    textField.text = getPrismBase(prism: lFarPrism2Value, base: lFarBase2Value)
                    self._lFarPrism2Value = lFarPrism2Value
                    
                    if component == 1 {
                        self._lFarBase2Value = lFarBase2Value
                    }
                }
                
                else if textField == self.rNearPrism1{
                    textField.text = getPrismBase(prism: rNearPrism1Value, base: rNearBase1Value)
                    self._rNearPrism1Value = rNearPrism1Value
                    
                    if component == 1 {
                        self._rNearBase1Value = rNearBase1Value
                    }
                }
                else if textField == self.rNearPrism2{
                    textField.text = getPrismBase(prism: rNearPrism2Value, base: rNearBase2Value)
                    self._rNearPrism2Value = rNearPrism2Value
                    
                    if component == 1 {
                        self._rNearBase2Value = rNearBase2Value
                    }
                }
                else if textField == self.lNearPrism1{
                    textField.text = getPrismBase(prism: lNearPrism1Value, base: lNearBase1Value)
                    self._lNearPrism1Value = lNearPrism1Value
                    
                    if component == 1 {
                        self._lNearBase1Value = lNearBase1Value
                    }
                }
                else if textField == self.lNearPrism2{
                    textField.text = getPrismBase(prism: lNearPrism2Value, base: lNearBase2Value)
                    self._lNearPrism2Value = lNearPrism2Value
                    
                    if component == 1 {
                        self._lNearBase2Value = lNearBase2Value
                    }
                }
                
                else if textField == self.rInterPrism1{
                    textField.text = getPrismBase(prism: rInterPrism1Value, base: rInterBase1Value)
                    self._rInterPrism1Value = rInterPrism1Value
                    
                    if component == 1 {
                        self._rInterBase1Value = rInterBase1Value
                    }
                }
                else if textField == self.rInterPrism2{
                    textField.text = getPrismBase(prism: rInterPrism2Value, base: rInterBase2Value)
                    self._rInterPrism2Value = rInterPrism2Value
                    
                    if component == 1 {
                        self._rInterBase2Value = rInterBase2Value
                    }
                }
                else if textField == self.lInterPrism1{
                    textField.text = getPrismBase(prism: lInterPrism1Value, base: lInterBase1Value)
                    self._lInterPrism1Value = lInterPrism1Value
                    
                    if component == 1 {
                        self._lInterBase1Value = lInterBase1Value
                    }
                }
                else if textField == self.lInterPrism2{
                    textField.text = getPrismBase(prism: lInterPrism2Value, base: lInterBase2Value)
                    self._lInterPrism2Value = lInterPrism2Value
                    
                    if component == 1 {
                        self._lInterBase2Value = lInterBase2Value
                    }
                }
            }
        }
        else{
            if let textField = self.textEditing{
                if textField == self.rFarCylAx{
                    textField.text = getCylAx(cylinder: rFarCylValue, axis: rFarAxisValue)
                    self._rFarCylValue = rFarCylValue
                }
                else if textField == self.lFarCylAx{
                    textField.text = getCylAx(cylinder: lFarCylValue, axis: lFarAxisValue)
                    self._lFarCylValue = lFarCylValue
                }
                    
                else if textField == self.rInterCylAx{
                    textField.text = getCylAx(cylinder: rInterCylValue, axis: rInterAxisValue)
                    self._rInterCylValue = rInterCylValue
                }
                else if textField == self.lInterCylAx{
                    textField.text = getCylAx(cylinder: lInterCylValue, axis: lInterAxisValue)
                    self._lInterCylValue = lInterCylValue
                }
                
                else if textField == self.rNearCylAx{
                    textField.text = getCylAx(cylinder: rNearCylValue, axis: rNearAxisValue)
                    self._rNearCylValue = rNearCylValue
                }
                else if textField == self.lNearCylAx{
                    textField.text = getCylAx(cylinder: lNearCylValue, axis: lNearAxisValue)
                    self._lNearCylValue = lNearCylValue
                }
                else{
                    self.textEditing?.text = pickerDataSourceSimple[row]
                }
            }
        }
    }
    
    func selectItemInPickerViewSimple (item: String?, picker: UIPickerView) {
        var rowIndex: Int? = nil
        rowIndex = getClinicalParameterIndex(item)
        if let rowIndex = rowIndex {
            picker.reloadAllComponents()
            picker.selectRow(rowIndex, inComponent: 0, animated: true)
            picker.delegate?.pickerView!(picker, didSelectRow: rowIndex, inComponent: 0)
        }
    }
    
    func getClinicalParameterIndex(_ item: String?) -> Int? {
        if self.pickerDataSourceSimple.count == 0 {
            return nil
        }
        if let item = item{
            if item.isEmpty{
                if pickerDataSourceSimple == self.addDataSource || pickerDataSourceSimple == [String](self.performedByTypeDataSource.values){
                    return 0
                }
                return self.pickerDataSourceSimple.count/2
            }
            return self.pickerDataSourceSimple.firstIndex(of: item)
        }
        return self.pickerDataSourceSimple.count/2
    }
    
    func selectItemInPickerViewDouble (item: String?, picker: UIPickerView,component: Int) {
        var rowIndex: Int? = 0
        if(component == 0){
            rowIndex = getPrismParameterIndex(item)
        }
        else if(component == 1){
            rowIndex = getBaseParameterIndex(item)
        }
        if let rowIndex = rowIndex {
            picker.selectRow(rowIndex, inComponent: component, animated: true)
            picker.delegate?.pickerView!(picker, didSelectRow: rowIndex, inComponent: component)
        }
    }
    
    func getPrismParameterIndex(_ item: String?) -> Int? {
        if self.pickerDataSourceDouble.count == 0 {
            return nil
        }
        if let item = item{
            if item.isEmpty{
                return 0
            }
            return self.pickerDataSourceDouble[0].firstIndex(of: item)
        }
        return 0
    }
    
    func getBaseParameterIndex(_ item: String?) -> Int? {
        if self.pickerDataSourceDouble.count == 0 {
            return nil
        }
        if let item = item{
            if item.isEmpty{
                return 0
            }
            return self.pickerDataSourceDouble[1].firstIndex(of: item)
        }
        return 0
    }
    
    func openPickerView(_ pickerView: UIPickerView,_ sender: UITextField) {
        sender.inputAssistantItem.trailingBarButtonGroups = []
        sender.inputAssistantItem.leadingBarButtonGroups = []
        
        pickerView.frame.origin.x = (self.view.frame.size.width - pickerView.frame.size.width)/2
        pickerView.showsSelectionIndicator = true
        
        let inputView = UIView(frame: CGRect(x: 0, y: 0, width: self.view.frame.size.width, height: pickerView.frame.size.height))
        inputView.backgroundColor = UIColor.white
        inputView.addSubview(pickerView)
        
        let toolBar = UIToolbar()
        toolBar.frame.size.width = self.view.frame.size.width
        toolBar.barStyle = UIBarStyle.default
        toolBar.isTranslucent = true
        toolBar.tintColor = UIColor.black
        toolBar.sizeToFit()
        
        let doneButton = UIBarButtonItem(title: Util.getString("Done"), style: UIBarButtonItem.Style.done, target: self, action: #selector(donePicker))
        let spaceButton = UIBarButtonItem(barButtonSystemItem: UIBarButtonItem.SystemItem.flexibleSpace, target: nil, action: nil)
        let cancelButton = UIBarButtonItem(title: Util.getString("Clear"), style: UIBarButtonItem.Style.plain, target: self, action: #selector(cancelPicker))
        
        toolBar.setItems([cancelButton, spaceButton, doneButton], animated: false)
        toolBar.isUserInteractionEnabled = true
        
        sender.inputView = inputView
        sender.inputAccessoryView = toolBar
        handleOpenPicker(pickerView, sender)
    }
    
    func handleOpenPicker(_ pickerView: UIPickerView, _ textField: UITextField){
        if textField == self.rFarPrism1 {
            selectItemInPickerViewDouble(item: self._rFarPrism1Value, picker: pickerView, component: 0)
            selectItemInPickerViewDouble(item: self._rFarBase1Value, picker: pickerView, component: 1)
        }
        else if textField == lFarPrism1{
            selectItemInPickerViewDouble(item: self._lFarPrism1Value, picker: pickerView, component: 0)
            selectItemInPickerViewDouble(item: self._lFarBase1Value, picker: pickerView, component: 1)
        }
        else if textField == self.rFarPrism2 {
            selectItemInPickerViewDouble(item: self._rFarPrism2Value, picker: pickerView, component: 0)
            selectItemInPickerViewDouble(item: self._rFarBase2Value, picker: pickerView, component: 1)
        }
        else if textField == lFarPrism2{
            selectItemInPickerViewDouble(item: self._lFarPrism2Value, picker: pickerView, component: 0)
            selectItemInPickerViewDouble(item: self._lFarBase2Value, picker: pickerView, component: 1)
        }
        else if textField == rInterPrism1{
            selectItemInPickerViewDouble(item: self._rInterPrism1Value, picker: pickerView, component: 0)
            selectItemInPickerViewDouble(item: self._rInterBase1Value, picker: pickerView, component: 1)
        }
        else if textField == lInterPrism1{
            selectItemInPickerViewDouble(item: self._lInterPrism1Value, picker: pickerView, component: 0)
            selectItemInPickerViewDouble(item: self._lInterBase1Value, picker: pickerView, component: 1)
        }
        else if textField == rInterPrism2{
            selectItemInPickerViewDouble(item: self._rInterPrism2Value, picker: pickerView, component: 0)
            selectItemInPickerViewDouble(item: self._rInterBase2Value, picker: pickerView, component: 1)
        }
        else if textField == lInterPrism2{
            selectItemInPickerViewDouble(item: self._lInterPrism2Value, picker: pickerView, component: 0)
            selectItemInPickerViewDouble(item: self._lInterBase2Value, picker: pickerView, component: 1)
        }
        else if textField == rNearPrism1{
            selectItemInPickerViewDouble(item: self._rNearPrism1Value, picker: pickerView, component: 0)
            selectItemInPickerViewDouble(item: self._rNearBase1Value, picker: pickerView, component: 1)
        }
        else if textField == lNearPrism1{
            selectItemInPickerViewDouble(item: self._lNearPrism1Value, picker: pickerView, component: 0)
            selectItemInPickerViewDouble(item: self._lNearBase1Value, picker: pickerView, component: 1)
        }
        else if textField == rNearPrism2{
            selectItemInPickerViewDouble(item: self._rNearPrism2Value, picker: pickerView, component: 0)
            selectItemInPickerViewDouble(item: self._rNearBase2Value, picker: pickerView, component: 1)
        }
        else if textField == lNearPrism2{
            selectItemInPickerViewDouble(item: self._lNearPrism2Value, picker: pickerView, component: 0)
            selectItemInPickerViewDouble(item: self._lNearBase2Value, picker: pickerView, component: 1)
        }
            
        else if textField == rFarCylAx{
            selectItemInPickerViewSimple(item: _rFarCylValue, picker: pickerView)
        }
        else if textField == lFarCylAx{
            selectItemInPickerViewSimple(item: _lFarCylValue, picker: pickerView)
        }
            
        else if textField == rInterCylAx{
            selectItemInPickerViewSimple(item: _rInterCylValue, picker: pickerView)
        }
        else if textField == lInterCylAx{
            selectItemInPickerViewSimple(item: _lInterCylValue, picker: pickerView)
        }
            
        else if textField == rNearCylAx{
            if rNearCylAx.text?.isEmpty == true{
                selectItemInPickerViewSimple(item: _rFarCylValue, picker: pickerView)
            }
            else{
                selectItemInPickerViewSimple(item: _rNearCylValue, picker: pickerView)
            }
        }
        else if textField == lNearCylAx{
            if lNearCylAx.text?.isEmpty == true{
                selectItemInPickerViewSimple(item: _lFarCylValue, picker: pickerView)
            }
            else{
                selectItemInPickerViewSimple(item: _lNearCylValue, picker: pickerView)
            }
        }
            
        else {
            selectItemInPickerViewSimple(item: textField.text, picker: pickerView)
        }
    }
    
    @objc func donePicker(){
        if let textField = self.textEditing{
            textField.resignFirstResponder()
        }
    }
    
    @objc func cancelPicker(){
        if let textField = self.textEditing{
            if textField == self.rFarPrism1{
                self._rFarPrism1Value = nil
                self._rFarBase1Value = nil
                textField.text = ""
            }
            else if textField == self.rFarPrism2{
                self._rFarPrism2Value = nil
                self._rFarBase2Value = nil
                textField.text = ""
            }
            else if textField == self.lFarPrism1{
                self._lFarPrism1Value = nil
                self._lFarBase1Value = nil
                textField.text = ""
            }
            else if textField == self.lFarPrism2{
                self._lFarPrism2Value = nil
                self._lFarBase2Value = nil
                textField.text = ""
            }
                
            else if textField == self.rInterPrism1{
                self._rInterPrism1Value = nil
                self._rInterBase1Value = nil
                textField.text = ""
            }
            else if textField == self.rInterPrism2{
                self._rInterPrism2Value = nil
                self._rInterBase2Value = nil
                textField.text = ""
            }
            else if textField == self.lInterPrism1{
                self._lInterPrism1Value = nil
                self._lInterBase1Value = nil
                textField.text = ""
            }
            else if textField == self.lInterPrism2{
                self._lInterPrism2Value = nil
                self._lInterBase2Value = nil
                textField.text = ""
            }
                
            else if textField == self.rNearPrism1{
                self._rNearPrism1Value = nil
                self._rNearBase1Value = nil
                textField.text = ""
            }
            else if textField == self.rNearPrism2{
                self._rNearPrism2Value = nil
                self._rNearBase2Value = nil
                textField.text = ""
            }
            else if textField == self.lNearPrism1{
                self._lNearPrism1Value = nil
                self._lNearBase1Value = nil
                textField.text = ""
            }
            else if textField == self.lNearPrism2{
                self._lNearPrism2Value = nil
                self._lNearBase2Value = nil
                textField.text = ""
            }
                
            else if textField == self.rFarCylAx{
                self._rFarCylValue = nil
                self._rFarAxisValue = nil
                textField.text = ""
            }
            else if textField == self.lFarCylAx{
                self._lFarCylValue = nil
                self._lFarAxisValue = nil
                textField.text = ""
            }
                
            else if textField == self.rInterCylAx{
                self._rInterCylValue = nil
                self._rInterAxisValue = nil
                textField.text = ""
            }
            else if textField == self.lInterCylAx{
                self._lInterCylValue = nil
                self._lInterAxisValue = nil
                textField.text = ""
            }
                
            else if textField == self.rNearCylAx{
                self._rNearCylValue = nil
                self._rNearAxisValue = nil
                textField.text = ""
            }
            else if textField == self.lNearCylAx{
                self._lNearCylValue = nil
                self._lNearAxisValue = nil
                textField.text = ""
            }

            else{
                textField.text = ""
            }
            
            textField.resignFirstResponder()
        }
    }

    func saveControlValues(){
        self.saveRightDistance()
        self.saveLeftDistance()

        self.saveRightInter()
        self.saveLeftInter()

        self.saveRightNear()
        self.saveLeftNear()
    }
    
    func saveRightDistance() {
        self.clinicalStatus.R_DIST_SPHERE = rFarSph.text
        self.clinicalStatus.R_DIST_CYLINDER = _rFarCylValue
        self.clinicalStatus.R_DIST_AXIS = _rFarAxisValue
        self.clinicalStatus.R_DIST_ACUITY = rFarACN.text
        self.clinicalStatus.R_DIST_ACUITYAIDED = rFarACC.text
        
        if(self.clinicalStatus.PrescriptionType == "CL"){
            self.clinicalStatus.R_DIST_DIAMETER = rFarDiameter.text
            self.clinicalStatus.R_DIST_RB = rFarBC.text
        }
        else if self.clinicalStatus.PrescriptionType == "GL"{
            self.clinicalStatus.R_DIST_PRISM1 = _rFarPrism1Value
            self.clinicalStatus.R_DIST_BASE1 = _rFarBase1Value
            self.clinicalStatus.R_DIST_PRISM2 = _rFarPrism2Value
            self.clinicalStatus.R_DIST_BASE2 = _rFarBase2Value
        }
        self.clinicalStatus.R_DIST_PD = rFarSdp.text
    }
    
    func saveLeftDistance() {
        self.clinicalStatus.L_DIST_SPHERE = lFarSph.text
        self.clinicalStatus.L_DIST_CYLINDER = _lFarCylValue
        self.clinicalStatus.L_DIST_AXIS = _lFarAxisValue
        self.clinicalStatus.L_DIST_ACUITY = lFarACN.text
        self.clinicalStatus.L_DIST_ACUITYAIDED = lFarACC.text
        
        if(self.clinicalStatus.PrescriptionType == "CL"){
            self.clinicalStatus.L_DIST_DIAMETER = lFarDiameter.text
            self.clinicalStatus.L_DIST_RB = lFarBC.text
        }
        else if self.clinicalStatus.PrescriptionType == "GL"{
            self.clinicalStatus.L_DIST_PRISM1 = _lFarPrism1Value
            self.clinicalStatus.L_DIST_BASE1 = _lFarBase1Value
            self.clinicalStatus.L_DIST_PRISM2 = _lFarPrism2Value
            self.clinicalStatus.L_DIST_BASE2 = _lFarBase2Value
        }
        self.clinicalStatus.L_DIST_PD = lFarSdp.text
    }
    
    func saveRightInter() {
        self.clinicalStatus.R_INTER_ADD = rInterAdd.text
        self.clinicalStatus.R_INTER_SPHERE = rInterSph.text
        self.clinicalStatus.R_INTER_CYLINDER = _rInterCylValue
        self.clinicalStatus.R_INTER_AXIS = _rInterAxisValue
        self.clinicalStatus.R_INTER_ACUITY = rInterACN.text
        self.clinicalStatus.R_INTER_ACUITYAIDED = rInterACC.text
        
        if(self.clinicalStatus.PrescriptionType == "CL"){
            clinicalStatus.R_INTER_DIAMETER = rInterDiameter.text
            clinicalStatus.R_INTER_RB = rInterBC.text
        }
        else if self.clinicalStatus.PrescriptionType == "GL"{
            self.clinicalStatus.R_INTER_PRISM1 = _rInterPrism1Value
            self.clinicalStatus.R_INTER_BASE1 = _rInterBase1Value
            self.clinicalStatus.R_INTER_PRISM2 = _rInterPrism2Value
            self.clinicalStatus.R_INTER_BASE2 = _rInterBase2Value
        }
        self.clinicalStatus.R_INTER_PD = rInterSdp.text
    }
    
    
    func saveLeftInter() {
        self.clinicalStatus.L_INTER_ADD = lInterAdd.text
        self.clinicalStatus.L_INTER_SPHERE = lInterSph.text
        self.clinicalStatus.L_INTER_CYLINDER = _lInterCylValue
        self.clinicalStatus.L_INTER_AXIS = _lInterAxisValue
        self.clinicalStatus.L_INTER_ACUITY = lInterACN.text
        self.clinicalStatus.L_INTER_ACUITYAIDED = lInterACC.text
        
        if(self.clinicalStatus.PrescriptionType == "CL"){
            self.clinicalStatus.L_INTER_DIAMETER = lInterDiameter.text
            self.clinicalStatus.L_INTER_RB = lInterBC.text
        }
        else if self.clinicalStatus.PrescriptionType == "GL"{
            self.clinicalStatus.L_INTER_PRISM1 = _lInterPrism1Value
            self.clinicalStatus.L_INTER_BASE1 = _lInterBase1Value
            self.clinicalStatus.L_INTER_PRISM2 = _lInterPrism2Value
            self.clinicalStatus.L_INTER_BASE2 = _lInterBase2Value
        }
        self.clinicalStatus.L_INTER_PD = lInterSdp.text
    }
    
    func saveRightNear() {
        self.clinicalStatus.R_NEAR_ADD = rNearAdd.text
        self.clinicalStatus.R_NEAR_SPHERE = rNearSph.text
        self.clinicalStatus.R_NEAR_CYLINDER = _rNearCylValue
        self.clinicalStatus.R_NEAR_AXIS = _rNearAxisValue
        self.clinicalStatus.R_NEAR_ACUITY = rNearACN.text
        self.clinicalStatus.R_NEAR_ACUITYAIDED = rNearACC.text
        
        if(self.clinicalStatus.PrescriptionType == "CL"){
            self.clinicalStatus.R_NEAR_DIAMETER = rNearDiameter.text
            self.clinicalStatus.R_NEAR_RB = rNearBC.text
        }
        else if self.clinicalStatus.PrescriptionType == "GL"{
            self.clinicalStatus.R_NEAR_PRISM1 = _rNearPrism1Value
            self.clinicalStatus.R_NEAR_BASE1 = _rNearBase1Value
            self.clinicalStatus.R_NEAR_PRISM2 = _rNearPrism2Value
            self.clinicalStatus.R_NEAR_BASE2 = _rNearBase2Value
        }
        self.clinicalStatus.R_NEAR_PD = rNearSdp.text
    }
    
    func saveLeftNear() {
        self.clinicalStatus.L_NEAR_ADD = lNearAdd.text
        self.clinicalStatus.L_NEAR_SPHERE = lNearSph.text
        self.clinicalStatus.L_NEAR_CYLINDER = _lNearCylValue
        self.clinicalStatus.L_NEAR_AXIS = _lNearAxisValue
        self.clinicalStatus.L_NEAR_ACUITY = lNearACN.text
        self.clinicalStatus.L_NEAR_ACUITYAIDED = lNearACC.text
        
        if(self.clinicalStatus.PrescriptionType == "CL"){
            self.clinicalStatus.L_NEAR_DIAMETER = lNearDiameter.text
            self.clinicalStatus.L_NEAR_RB = lNearBC.text
        }
        else if self.clinicalStatus.PrescriptionType == "GL"{
            self.clinicalStatus.L_NEAR_PRISM1 = _lNearPrism1Value
            self.clinicalStatus.L_NEAR_BASE1 = _lNearBase1Value
            self.clinicalStatus.L_NEAR_PRISM2 = _lNearPrism2Value
            self.clinicalStatus.L_NEAR_BASE2 = _lNearBase2Value
        }
        self.clinicalStatus.L_NEAR_PD = lNearSdp.text
    }
    
    func setAddValues() {
        clinicalStatus.setAddValueAsDifference(add: &clinicalStatus.L_NEAR_ADD, sourceSphere1: clinicalStatus.L_DIST_SPHERE, sourceSphere2: clinicalStatus.L_NEAR_SPHERE)
        lNearAdd.text = clinicalStatus.L_NEAR_ADD
        
        clinicalStatus.setAddValueAsDifference(add: &clinicalStatus.L_INTER_ADD, sourceSphere1: clinicalStatus.L_DIST_SPHERE, sourceSphere2: clinicalStatus.L_INTER_SPHERE)
        lInterAdd.text = clinicalStatus.L_INTER_ADD
        
        clinicalStatus.setAddValueAsDifference(add: &clinicalStatus.R_NEAR_ADD, sourceSphere1: clinicalStatus.R_DIST_SPHERE, sourceSphere2: clinicalStatus.R_NEAR_SPHERE)
        rNearAdd.text = clinicalStatus.R_NEAR_ADD
        
        clinicalStatus.setAddValueAsDifference(add: &clinicalStatus.R_INTER_ADD, sourceSphere1: clinicalStatus.R_DIST_SPHERE, sourceSphere2: clinicalStatus.R_INTER_SPHERE)
        rInterAdd.text = clinicalStatus.R_INTER_ADD
    }
    
    func setSPHValues() {
        clinicalStatus.setSphValueAsDifference(add: clinicalStatus.L_NEAR_ADD, sourceSphere1: clinicalStatus.L_DIST_SPHERE, sourceSphere2: &clinicalStatus.L_NEAR_SPHERE)
        lNearSph.text = clinicalStatus.L_NEAR_SPHERE
        
        clinicalStatus.setSphValueAsDifference(add: clinicalStatus.L_INTER_ADD, sourceSphere1: clinicalStatus.L_DIST_SPHERE, sourceSphere2: &clinicalStatus.L_INTER_SPHERE)
        lInterSph.text = clinicalStatus.L_INTER_SPHERE
        
        clinicalStatus.setSphValueAsDifference(add: clinicalStatus.R_NEAR_ADD, sourceSphere1: clinicalStatus.R_DIST_SPHERE, sourceSphere2: &clinicalStatus.R_NEAR_SPHERE)
        rNearSph.text = clinicalStatus.R_NEAR_SPHERE
        
        clinicalStatus.setSphValueAsDifference(add: clinicalStatus.R_INTER_ADD, sourceSphere1: clinicalStatus.R_DIST_SPHERE, sourceSphere2: &clinicalStatus.R_INTER_SPHERE)
        rInterSph.text = clinicalStatus.R_INTER_SPHERE
    }
    
    func printClinicalStatusReport(){
        let clinicalStatusReportRequest = ClinicalStatusReportRequest()
        clinicalStatusReportRequest.storeId = Int(settings.StoreId)!
        clinicalStatusReportRequest.clinicalStatusId = UUID.init(uuidString: self.clinicalStatus.ClinicalStatusId)!
        State.getClinicalStatusDataReport(clinicalStatusReportRequest: clinicalStatusReportRequest) { result in
            let documentDetailViewContoller = (self.storyboard?.instantiateViewController(withIdentifier: "documentDetailViewController") as! DocumentDetailViewController)
            documentDetailViewContoller.contact = self.clinicalStatus.Contact
            documentDetailViewContoller.binaryData = result.document
            documentDetailViewContoller.viewTitle = "Prescription.pdf"
            documentDetailViewContoller.title = "Prescription Report"
            self.navigationController?.pushViewController(documentDetailViewContoller, animated: true)
        }
    }
}

class CustomUITextField: UITextField {
    
    override func caretRect(for position: UITextPosition) -> CGRect{
        return CGRect.zero
    }
    
    override func selectionRects(for range: UITextRange) -> [UITextSelectionRect]{
        return []
    }
    
    override func canPerformAction(_ action: Selector, withSender sender: Any?) -> Bool{
        return false
    }
}
