//
//  TechnicalDataViewController.swift
//  iPOS
//
//  Created by Zoran Albu on 1/10/19.
//  Copyright © 2019 BBC. All rights reserved.
//

import Foundation
import UIKit
import QuickLook

class TechnicalDataViewController: UIViewController, UITextFieldDelegate{
    
    @IBOutlet weak var lfCenteringData: UILabel!
    
    @IBOutlet weak var lfLensLengthA: UILabel!
    @IBOutlet weak var tfLensLengthARight: UITextField!
    @IBOutlet weak var ivLensLengthA: UIButton!
    
    @IBOutlet weak var lfLensHeightB: UILabel!
    @IBOutlet weak var tfLensHeightBRight: UITextField!
    @IBOutlet weak var ivLensHeightB: UIButton!
    
    @IBOutlet weak var lfBridge: UILabel!
    @IBOutlet weak var tfBridge: UITextField!
    @IBOutlet weak var ivBridge: UIButton!
    
    @IBOutlet weak var lfSDP: UILabel!
    @IBOutlet weak var tfSDPRight: UITextField!
    @IBOutlet weak var tfSDPLeft: UITextField!
    @IBOutlet weak var ivSDP: UIButton!
    
    @IBOutlet weak var lfSDPNear: UILabel!
    @IBOutlet weak var tfSDPNearRight: UITextField!
    @IBOutlet weak var tfSDPNearLeft: UITextField!
    @IBOutlet weak var ivSDPNear: UIButton!
    
    @IBOutlet weak var lfOpticalCenterHeight: UILabel!
    @IBOutlet weak var tfOpticalCenterHeightRight: UITextField!
    @IBOutlet weak var tfOpticalCenterHeightLeft: UITextField!
    @IBOutlet weak var ivOpticalCenterHeight: UIButton!
    
    @IBOutlet weak var lfSegmentHeight: UILabel!
    @IBOutlet weak var tfSegmentHeightRight: UITextField!
    @IBOutlet weak var tfSegmentHeightLeft: UITextField!
    @IBOutlet weak var ivSegmentHeight: UIButton!
    
    @IBOutlet weak var lfDecentralization: UILabel!
    @IBOutlet weak var tfDecentralizationRight: UITextField!
    @IBOutlet weak var tfDecentralizationLeft: UITextField!
    @IBOutlet weak var ivDecentralization: UIButton!
    
    @IBOutlet weak var lfFrameData: UILabel!
    @IBOutlet weak var lfCornealDistance: UILabel!
    @IBOutlet weak var tfCornealDistanceRight: UITextField!
    @IBOutlet weak var tfCornealDistanceLeft: UITextField!
    @IBOutlet weak var ivCornealDistance: UIButton!
    
    @IBOutlet weak var lfPantoscopicAngle: UILabel!
    @IBOutlet weak var tfPantoscopicAngleRight: UITextField!
    @IBOutlet weak var ivPantoscopicAngle: UIButton!
    
    @IBOutlet weak var lfWinding: UILabel!
    @IBOutlet weak var tfWindingRight: UITextField!
    @IBOutlet weak var ivWinding: UIButton!
    
    @IBOutlet weak var scrollView: UIScrollView!
    
    var orderDetailGlasses: WorkOrderDetailGlasses?
    var clinicalStatus: ClinicalStatus?
    
    var textEditing: UITextField?
    
    var righEye = Util.getString("RightEye")
    var leftEye = Util.getString("LeftEye")
    let milimetricUnitOfMeasure = "mm"
    let angleUnitOfMeasure = "°"
    
    override func viewDidLoad() {
        super.viewDidLoad()
    }
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        self.setCaption()
        self.delegateTextField()
        self.addTapGesture()
        self.initData()
    }
    
    func setCaption(){
        self.lfCenteringData.text = Util.getString("CenteringData")
        self.lfLensLengthA.text = Util.getString("LensLenght") + " (A)"
        self.lfLensHeightB.text = Util.getString("LensHeight") + " (B)"
        self.lfBridge.text = Util.getString("Bridge")
        
        self.lfSDP.text = Util.getString("SDP")
        self.lfSDPNear.text = Util.getString("SDPNear")
        self.lfOpticalCenterHeight.text = Util.getString("OpticalCenterHeight")
        self.lfSegmentHeight.text = Util.getString("SegmentHeight")
        self.lfDecentralization.text = Util.getString("Decentralization")
        
        self.lfFrameData.text = Util.getString("FrameData")
        self.lfCornealDistance.text = Util.getString("CornealDistance")
        self.lfPantoscopicAngle.text = Util.getString("PantoscopicAngle")
        self.lfWinding.text = Util.getString("Winding")
        
        self.tfLensLengthARight.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfLensLengthARight)
        self.tfLensHeightBRight.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfLensHeightBRight)
        self.tfBridge.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfBridge)
        self.tfSDPLeft.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfSDPLeft)
        self.tfSDPRight.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfSDPRight)
        self.tfSDPNearLeft.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfSDPNearLeft)
        self.tfSDPNearRight.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfSDPNearRight)
        self.tfOpticalCenterHeightLeft.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfOpticalCenterHeightLeft)
        self.tfOpticalCenterHeightRight.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfOpticalCenterHeightRight)
        self.tfSegmentHeightLeft.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfSegmentHeightLeft)
        self.tfSegmentHeightRight.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfSegmentHeightRight)
        self.tfDecentralizationLeft.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfOpticalCenterHeightLeft)
        self.tfDecentralizationRight.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfDecentralizationRight)
        self.tfSegmentHeightLeft.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfSegmentHeightLeft)
        self.tfSegmentHeightRight.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfSegmentHeightRight)
        self.tfCornealDistanceLeft.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfCornealDistanceLeft)
        self.tfCornealDistanceRight.placeholder = self.milimetricUnitOfMeasure
        self.setPlaceHolders(textField: self.tfCornealDistanceRight)
        self.tfPantoscopicAngleRight.placeholder = self.angleUnitOfMeasure
        self.setPlaceHolders(textField: self.tfPantoscopicAngleRight)
        self.tfWindingRight.placeholder = self.angleUnitOfMeasure
        self.setPlaceHolders(textField: self.tfWindingRight)
    }
    
    func setPlaceHolders(textField: UITextField){
        if let text = textField.placeholder{
            let height = textField.frame.height
            let size: CGSize = text.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 = textField.placeholder
            textField.placeholder = nil
            textField.rightView = label
            textField.rightViewMode = .unlessEditing
        }
    }
    
    func delegateTextField(){
        self.tfLensLengthARight.delegate = self
        self.tfLensHeightBRight.delegate = self
        self.tfBridge.delegate = self
        
        self.tfSDPLeft.delegate = self
        self.tfSDPRight.delegate = self
        self.tfSDPNearLeft.delegate = self
        self.tfSDPNearRight.delegate = self
        self.tfOpticalCenterHeightLeft.delegate = self
        self.tfOpticalCenterHeightRight.delegate = self
        self.tfSegmentHeightLeft.delegate = self
        self.tfSegmentHeightRight.delegate = self
        self.tfDecentralizationLeft.delegate = self
        self.tfDecentralizationRight.delegate = self
        
        self.tfCornealDistanceLeft.delegate = self
        self.tfCornealDistanceRight.delegate = self
        self.tfPantoscopicAngleRight.delegate = self
        self.tfWindingRight.delegate = self
    }
    
    func initData(){
        if let LensLength = self.orderDetailGlasses?.LensLength{
            self.tfLensLengthARight.text = Util.DoubleToStringWithTwoDecimals(LensLength)
        }
        if let LensHeight = self.orderDetailGlasses?.LensHeight{
            self.tfLensHeightBRight.text = Util.DoubleToStringWithTwoDecimals(LensHeight)
        }
        if let Bridge = self.orderDetailGlasses?.Bridge{
            self.tfBridge.text = Util.DoubleToStringWithTwoDecimals(Bridge)
        }
        if let SPDFarLeft = self.orderDetailGlasses?.SPDFarLeft{
            self.tfSDPLeft.text = Util.DoubleToStringWithOneDecimal(SPDFarLeft)
        }
        if let SPDFarRight = self.orderDetailGlasses?.SPDFarRight{
            self.tfSDPRight.text = Util.DoubleToStringWithOneDecimal(SPDFarRight)
        }
        if let SPDNearLeft = self.orderDetailGlasses?.SPDNearLeft{
            self.tfSDPNearLeft.text = Util.DoubleToStringWithOneDecimal(SPDNearLeft)
        }
        if let SPDNearRight = self.orderDetailGlasses?.SPDNearRight{
            self.tfSDPNearRight.text = Util.DoubleToStringWithOneDecimal(SPDNearRight)
        }
        if let OpticalCenterHeightLeft = self.orderDetailGlasses?.OpticalCenterHeightLeft{
            self.tfOpticalCenterHeightLeft.text = Util.DoubleToStringWithTwoDecimals(OpticalCenterHeightLeft)
        }
        if let OpticalCenterHeightRight = self.orderDetailGlasses?.OpticalCenterHeightRight{
            self.tfOpticalCenterHeightRight.text = Util.DoubleToStringWithTwoDecimals(OpticalCenterHeightRight)
        }
        if let SegmentHeightLeft = self.orderDetailGlasses?.SegmentHeightLeft{
            self.tfSegmentHeightLeft.text = Util.DoubleToStringWithTwoDecimals(SegmentHeightLeft)
        }
        if let SegmentHeightRight = self.orderDetailGlasses?.SegmentHeightRight{
            self.tfSegmentHeightRight.text = Util.DoubleToStringWithTwoDecimals(SegmentHeightRight)
        }
        if let DecentralizationLeft = self.orderDetailGlasses?.DecentralizationLeft{
            self.tfDecentralizationLeft.text = Util.DoubleToStringWithTwoDecimals(DecentralizationLeft)
        }
        if let DecentralizationRight = self.orderDetailGlasses?.DecentralizationRight{
            self.tfDecentralizationRight.text = Util.DoubleToStringWithTwoDecimals(DecentralizationRight)
        }
        if let CornealDistanceLeft = self.orderDetailGlasses?.CornealDistanceLeft{
            self.tfCornealDistanceLeft.text = Util.DoubleToStringWithTwoDecimals(CornealDistanceLeft)
        }
        if let CornealDistanceLeft = self.orderDetailGlasses?.CornealDistanceLeft{
            self.tfCornealDistanceRight.text = Util.DoubleToStringWithTwoDecimals(CornealDistanceLeft)
        }
        if let PantoscopicAngle = self.orderDetailGlasses?.PantoscopicAngle?.description{
            self.tfPantoscopicAngleRight.text = PantoscopicAngle
        }
        if let WindingAngle = self.orderDetailGlasses?.WindingAngle?.description{
            self.tfWindingRight.text = WindingAngle
        }
    }
    
    func textFieldShouldBeginEditing(_ textField: UITextField) -> Bool {
        self.textEditing = textField
        var title = ""
        var availableValue = ""
        
        if textField == self.tfLensLengthARight{
            title = Util.getString("LensLenght")
        }
        else if textField == self.tfLensHeightBRight{
            title = Util.getString("LensHeight")
        }
        else if textField == self.tfBridge{
            title = Util.getString("Bridge")
            availableValue = "14-24"
        }
        else if textField == self.tfSDPRight {
            title = Util.getString("SDP") + " " + righEye
            availableValue = "20.0-40.0"
        }
        else if textField == self.tfSDPLeft{
            title = Util.getString("SDP") + " " + leftEye
            availableValue = "20.0-40.0"
        }
        else if textField == self.tfSDPNearRight{
            title = Util.getString("SDPNear") + " " + righEye
            availableValue = "20.0-40.0"
        }
        else if textField == self.tfSDPNearLeft{
            title = Util.getString("SDPNear") + " " + leftEye
            availableValue = "20.0-40.0"
        }
        else if textField == self.tfOpticalCenterHeightRight{
            title = Util.getString("OpticalCenterHeight") + " " + righEye
        }
        else if textField == self.tfOpticalCenterHeightLeft{
            title = Util.getString("OpticalCenterHeight") + " " + leftEye
        }
        else if textField == self.tfSegmentHeightRight{
            title = Util.getString("SegmentHeight") + " " + righEye
        }
        else if  textField == self.tfSegmentHeightLeft{
            title = Util.getString("SegmentHeight") + " " + leftEye
        }
        else if textField == self.tfDecentralizationRight{
            title = Util.getString("Decentralization") + " " + righEye
        }
        else if textField == self.tfDecentralizationLeft{
            title = Util.getString("Decentralization") + " " + leftEye
        }
        else if textField == self.tfCornealDistanceRight{
            title = Util.getString("CornealDistance") + " " + righEye
        }
        else if textField == self.tfCornealDistanceLeft{
            title = Util.getString("CornealDistance") + " " + leftEye
        }
        else if textField == self.tfPantoscopicAngleRight{
            title = Util.getString("PantoscopicAngle")
        }
        else if textField == self.tfWindingRight{
            title = Util.getString("Winding")
        }
        
        self.simpleAlertWithTextEdit(title: title, message: nil, text: textField.text, availableValue: availableValue, actionYes: { value in
            if let value = value{
                if textField == self.tfPantoscopicAngleRight || textField == self.tfWindingRight{
                    if let newValue = Int.init(value){
                        textField.text = newValue.description
                    }else{
                        textField.text = nil
                    }
                }
                else if textField == self.tfSDPLeft || textField == self.tfSDPRight || textField == self.tfSDPNearLeft || textField == self.tfSDPNearRight{
                    if let newValue = Double.init(value){
                        textField.text = Util.DoubleToStringWithOneDecimal(newValue)
                    }else{
                        textField.text = nil
                    }
                }
                else{
                    if let newValue = Double.init(value){
                        textField.text = Util.DoubleToStringWithTwoDecimals(newValue)
                    }else{
                        textField.text = nil
                    }
                }
            }
            else{
                textField.text = nil
            }
            self.saveData()
        }, actionNo: {
            return
        })
            
        return true
    }
    
    func textFieldShouldReturn(_ textField: UITextField) -> Bool {
        self.dismissKeyboard()
        return true
    }
    
    func addTapGesture(){
        let tap: UITapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(dismissKeyboard))
        self.scrollView.addGestureRecognizer(tap)
    }
    
    @objc func dismissKeyboard() {
        self.view.endEditing(true)
    }
    
    func saveData(){
        if let lensLength = self.tfLensLengthARight.text{
            if let value = Double(lensLength){
                self.orderDetailGlasses?.LensLength = value
            }
        }
        if let lensHeight = self.tfLensHeightBRight.text{
            if let value = Double(lensHeight){
                self.orderDetailGlasses?.LensHeight = value
            }
        }
        if let bridge = self.tfBridge.text{
            if let value = Double(bridge){
                self.orderDetailGlasses?.Bridge = value
            }
        }
        if let tfSDPLeft = self.tfSDPLeft.text{
            if let value = Double(tfSDPLeft){
                self.orderDetailGlasses?.SPDFarLeft = value
            }
        }
        if let tfSDPRight = self.tfSDPRight.text{
            if let value = Double(tfSDPRight){
                self.orderDetailGlasses?.SPDFarRight = value
            }
        }
        if let tfSDPNearLeft = self.tfSDPNearLeft.text{
            if let value = Double(tfSDPNearLeft){
                self.orderDetailGlasses?.SPDNearLeft = value
            }
        }
        if let tfSDPNearRight = self.tfSDPNearRight.text{
            if let value = Double(tfSDPNearRight){
                self.orderDetailGlasses?.SPDNearRight = value
            }
        }
        if let tfOpticalCenterHeightLeft = self.tfOpticalCenterHeightLeft.text{
            if let value = Double(tfOpticalCenterHeightLeft){
                self.orderDetailGlasses?.OpticalCenterHeightLeft = value
            }
        }
        if let tfOpticalCenterHeightRight = self.tfOpticalCenterHeightRight.text{
            if let value = Double(tfOpticalCenterHeightRight){
                self.orderDetailGlasses?.OpticalCenterHeightRight = value
            }
        }
        if let tfSegmentHeightLeft = self.tfSegmentHeightLeft.text{
            if let value = Double(tfSegmentHeightLeft){
                self.orderDetailGlasses?.SegmentHeightLeft = value
            }
        }
        if let tfSegmentHeightRight = self.tfSegmentHeightRight.text{
            if let value = Double(tfSegmentHeightRight){
                self.orderDetailGlasses?.SegmentHeightRight = value
            }
        }
        if let tfDecentralizationLeft = self.tfDecentralizationLeft.text{
            if let value = Double(tfDecentralizationLeft){
                self.orderDetailGlasses?.DecentralizationLeft = value
            }
        }
        if let tfDecentralizationRight = self.tfDecentralizationRight.text{
            if let value = Double(tfDecentralizationRight){
                self.orderDetailGlasses?.DecentralizationRight = value
            }
        }
        if let tfCornealDistanceLeft = self.tfCornealDistanceLeft.text{
            if let value = Double(tfCornealDistanceLeft){
                self.orderDetailGlasses?.CornealDistanceLeft = value
            }
        }
        if let tfCornealDistanceRight = self.tfCornealDistanceRight.text{
            if let value = Double(tfCornealDistanceRight){
                self.orderDetailGlasses?.CornealDistanceRight = value
            }
        }
        if let tfPantoscopicAngleRight = self.tfPantoscopicAngleRight.text{
            if let value = Int(tfPantoscopicAngleRight){
                self.orderDetailGlasses?.PantoscopicAngle = value
            }
        }
        if let tfWindingRight = self.tfWindingRight.text{
            if let value = Int(tfWindingRight){
                self.orderDetailGlasses?.WindingAngle = value
            }
        }
    }
    
    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 self.textEditing == self.tfBridge{
                    let newValue = Util.checkNumberOfDecimalPlaces(string: text, digitCount: 2)
                    textField.text = newValue
                    if let value = Double(newValue){
                        if value >= 14 && value <= 24 {
                            alert.actions[0].isEnabled = true
                        }else{
                            alert.actions[0].isEnabled = false
                        }
                    }else{
                        alert.actions[0].isEnabled = false
                    }
                }
                else if self.textEditing == self.tfSDPLeft || self.textEditing == self.tfSDPRight || self.textEditing == self.tfSDPNearLeft || self.textEditing == self.tfSDPNearRight{
                    let newValue = Util.checkNumberOfDecimalPlaces(string: text, digitCount: 1)
                    textField.text = newValue
                    if let value = Double(newValue){
                        if value >= 20 && value <= 40 {
                            alert.actions[0].isEnabled = true
                        }else{
                            alert.actions[0].isEnabled = false
                        }
                    }else{
                        alert.actions[0].isEnabled = false
                    }
                }
                else if self.textEditing == self.tfPantoscopicAngleRight || self.textEditing == self.tfWindingRight{
                    if let value = Int(text){
                        if value >= -1000 && value <= 1000 {
                            alert.actions[0].isEnabled = true
                        }else{
                            alert.actions[0].isEnabled = false
                        }
                    }else{
                        alert.actions[0].isEnabled = false
                    }
                }
                else {
                    let newValue = Util.checkNumberOfDecimalPlaces(string: text, digitCount: 2)
                    textField.text = newValue
                    if let value = Double(newValue){
                        if value >= -999.99 && value <= 999.99 {
                            alert.actions[0].isEnabled = true
                        }else{
                            alert.actions[0].isEnabled = false
                        }
                    }else{
                        alert.actions[0].isEnabled = false
                    }
                }
            }
        }
    }
    
    @IBAction func lensLength_Click(_ sender: Any) {
        if let image = UIImage.init(named: "lensDimensions.jpg"){
            self.previewImage(image: image, title: Util.getString("LensLenght"), message: "", imageName: "lensDimensions", ext: "jpg")
        }
    }
    
    @IBAction func lensHeight_Click(_ sender: Any) {
        if let image = UIImage.init(named: "lensDimensions.jpg"){
            self.previewImage(image: image, title: Util.getString("LensHeight"), message: "", imageName: "lensDimensions", ext: "jpg")
        }
    }
    
    @IBAction func bridge_Click(_ sender: Any) {
        if let image = UIImage.init(named: "lensDimensions.jpg"){
            self.previewImage(image: image, title: Util.getString("Bridge"), message: "", imageName: "lensDimensions", ext: "jpg")
        }
    }
    
    @IBAction func sdp_Click(_ sender: Any) {
        if let image = UIImage.init(named: "SDP.jpg"){
            self.previewImage(image: image, title: Util.getString("SDP"), message: Util.getString("SDPInfo"), imageName: "SDP", ext: "jpg")
        }
    }
    
    @IBAction func sdpNear_Click(_ sender: Any) {
        if let image = UIImage.init(named: "SDPNear.jpg"){
            self.previewImage(image: image, title: Util.getString("SDPNear"), message: Util.getString("SDPNearInfo"), imageName: "SDPNear", ext: "jpg")
        }
    }
    
    @IBAction func opticalCenterHeight_Click(_ sender: Any) {
        if let image = UIImage.init(named: "OpticalCenterHeight.jpg"){
            self.previewImage(image: image, title: Util.getString("OpticalCenterHeight"), message: Util.getString("OpticalCenterHeightInfo"), imageName: "OpticalCenterHeight", ext: "jpg")
        }
    }
    
    @IBAction func SegmentHeight_Click(_ sender: Any) {
        self.previewText(text: Util.getString("SegmentHeightInfo"), title: Util.getString("SegmentHeight"))
    }
    
    @IBAction func decentralization_Click(_ sender: Any) {
        self.previewText(text: Util.getString("DecentralizationInfo"), title: Util.getString("Decentralization"))
    }
    
    @IBAction func cornealDistance_Click(_ sender: Any) {
        if let image = UIImage.init(named: "CornealDistance.jpg"){
            self.previewImage(image: image, title: Util.getString("CornealDistance"), message: Util.getString("CornealDistanceInfo"), imageName: "CornealDistance", ext: "jpg")
        }
    }
    
    @IBAction func PatoscopicAngle_Click(_ sender: Any) {
        if let image = UIImage.init(named: "PantoscopicAngle.jpg"){
            self.previewImage(image: image, title: Util.getString("PantoscopicAngle"), message: Util.getString("PantoscopicAngleInfo"), imageName: "PantoscopicAngle", ext: "jpg")
        }
    }
    
    @IBAction func Winding_Click(_ sender: Any) {
        if let image = UIImage.init(named: "Winding.jpg"){
            self.previewImage(image: image, title: Util.getString("Winding"), message: Util.getString("WindingInfo"), imageName: "Winding", ext: "jpg")
        }
    }
    
    class DocumentDataSource: NSObject, QLPreviewControllerDataSource, QLPreviewControllerDelegate{
        
        let urls: [URL]
        
        init(urls: [URL]) {
            self.urls = urls
        }
        
        func numberOfPreviewItems(in controller: QLPreviewController) -> Int {
            return self.urls.count
        }
        
        func previewController(_ controller: QLPreviewController, previewItemAt index: Int) -> QLPreviewItem {
           return self.urls[index] as QLPreviewItem
        }
    }
    
    func previewImage(image: String, ext: String, title: String){
        guard let img = Bundle.main.url(forResource: image, withExtension: ext) else {
            Util.GeneralAlert(viewController: self, message: "Could not load \(image).\(ext)")
            return
        }
    
        let ds = DocumentDataSource(urls: [img])
        let previewController = QLPreviewController()
        previewController.dataSource = ds
        previewController.currentPreviewItemIndex = 0
        
        self.present(previewController, animated: true)
    }
    
    func previewText(text: String, title: String){
        Util.GeneralAlert(viewController: self, message: text, title: title)
    }
    
    func previewImage(image: UIImage, title: String, message: String, imageName: String, ext: String){
        let finalImage = Util.resizeImage(sourceImage: image, newWidth: 245, newHeight: Int(245/image.size.width*image.size.height))
        
        let alertMessage = UIAlertController(title: title, message: message, preferredStyle: .alert)
        
        let imgAction = UIAlertAction(title: "", style: .default, handler: { (action) -> Void in
            self.previewImage(image: imageName, ext: ext, title: title)
        })
        imgAction.setValue(finalImage.withRenderingMode(UIImage.RenderingMode.alwaysOriginal), forKey: "image")
        alertMessage .addAction(imgAction)
        let okAction = UIAlertAction(title: "OK", style: .default, handler: nil)
        alertMessage .addAction(okAction)
        
        self.present(alertMessage, animated: true, completion: nil)
    }
}
