//
//  SettingsViewController.swift
//  iPOS
//
//  Created by bbc on 13/12/16.
//  Copyright © 2016 BBC. All rights reserved.
//

import Foundation
import UIKit

class SettingsViewController: UITableViewController, UITextFieldDelegate, UIPickerViewDataSource, UIPickerViewDelegate, SearchPrinterViewDelegate, Epos2PtrReceiveDelegate, UIPopoverPresentationControllerDelegate {
    
    @IBOutlet weak var tfWebServiceUrl: UITextField!
    @IBOutlet weak var tfFiscalPrinterUrl: UITextField!
    @IBOutlet weak var tfStoreId: UITextField!
    @IBOutlet weak var scPrinterType: UISegmentedControl!
    @IBOutlet weak var tfCashRegister: UITextField!
    @IBOutlet weak var scLabelPrinter: UISegmentedControl!
    @IBOutlet weak var tfTerminalId: UITextField!
    @IBOutlet weak var tfTerminalIp: UITextField!
    @IBOutlet weak var tfTerminalPort: UITextField!
    @IBOutlet weak var scFiscalDocumentType: UISegmentedControl!
    @IBOutlet weak var swEnablePrinter: UISwitch!
    @IBOutlet weak var lfDataSource: UILabel!
    @IBOutlet weak var lfStoreId: UILabel!
    @IBOutlet weak var lfCashRegister: UILabel!
    @IBOutlet weak var lfPrinterIp: UILabel!
    @IBOutlet weak var lfPrinterType: UILabel!
    @IBOutlet weak var btTestPrinter: UIButton!
    @IBOutlet weak var lfPrinterFont: UILabel!
    @IBOutlet weak var tfWSTerminal: UITextField!
    @IBOutlet weak var btSearchPrinter: UIButton!
    @IBOutlet weak var lfPrinterSeries: UILabel!
    @IBOutlet weak var tfPrinterSeries: UITextField!
    @IBOutlet weak var scPrinterFont: UISegmentedControl!
    @IBOutlet weak var lfLoggedInUserName: UILabel!
    @IBOutlet weak var btLogout: UIButton!
    @IBOutlet weak var swEnableSSL: UISwitch!
    @IBOutlet weak var lfEnableSSL: UILabel!

    var printerSeriesPicker: UIPickerView = UIPickerView(frame: CGRect(x: 0, y: 0, width: UIScreen.main.bounds.width , height: 200))
    
    var contactsViewController: UIViewController!
    var loginViewController: UIViewController!
    var pinForEdit = "7879"
    var isLoadingSettingsEnabled: Bool = true
    var isInPreConfigState = false
    
    var printerManufacturerString = ""
    var printerModelString = ""
    var modelIndex = 0
    var storeCode = ""
    
    override func viewDidLoad() {
        super.viewDidLoad()
        self.navigationItem.title = Util.getString("Settings")

        self.delegateTextField()
        self.addTapGesture()
        self.setStyleButtons()
    }
    
    func addTapGesture(){
        let tap: UITapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(dismissKeyboard))
        view.addGestureRecognizer(tap)
    }
    
    func createSaveSettingButton(){
        let applyButton = UIBarButtonItem(barButtonSystemItem: .save, target: self, action: #selector(applyButtonPressed(_:)))
        self.navigationItem.rightBarButtonItem = applyButton
    }
    
    func setStyleButtons(){
        self.btLogout.setTitle(Util.getString("Logout"), for: .normal)
        self.btLogout.backgroundColor = UIColor(red:0.12, green:0.56, blue:1.00, alpha:1.0)
        self.btLogout.setTitleColor(UIColor.white, for: .normal)
        self.btLogout.layer.cornerRadius = 5
        self.btLogout.layer.borderWidth = 1
        self.btLogout.layer.borderColor = UIColor(red:0.12, green:0.56, blue:1.00, alpha:1.0).cgColor
    }
    
    @objc func dismissKeyboard() {
        view.endEditing(true)
    }
    
    func delegateTextField(){
        tfWebServiceUrl.delegate = self
        tfFiscalPrinterUrl.delegate = self
        tfStoreId.delegate = self
        tfCashRegister.delegate = self
        tfTerminalId.delegate = self
        tfTerminalIp.delegate = self
        tfTerminalPort.delegate = self
        printerSeriesPicker.delegate = self
        printerSeriesPicker.dataSource = self
        tfWSTerminal.delegate = self
    }
    
    func textFieldShouldReturn(_ textField: UITextField) -> Bool {
        view.endEditing(true)
        return true
    }

    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        
        if self.isLoadingSettingsEnabled{
            self.getDefaultSettings()
            self.changeAdvancedSettingsStatus(isEnabled: false)
        }
        else{
            self.isLoadingSettingsEnabled = true
            self.changeAdvancedSettingsStatus(isEnabled: true)
        }
        
        self.changePrinterSettingsStatus(isEnabled: self.swEnablePrinter.isOn)
        
        if self.swEnablePrinter.isOn{
            let isFiscal = self.scPrinterType.selectedSegmentIndex == 0 ? true : false
            self.changePrinterType(isFiscal: isFiscal)
        }
        else{
            self.tableView.reloadData()
        }
        
        if self.isInPreConfigState{
            self.navigationItem.hidesBackButton = true
            self.removeNavigationBarItem()
        }
        else{
            self.setNavigationBarItem()
        }
        createSaveSettingButton()
    }
    
    override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
        super.viewWillTransition(to: size, with: coordinator)
    }
    
    override func tableView(_ tableView: UITableView, heightForHeaderInSection section: Int) -> CGFloat {
        if(self.isInPreConfigState && section == 0){
            return 0.0
        }
        return self.tableView.sectionHeaderHeight
    }
    
    override func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
        if(self.isInPreConfigState && indexPath.section == 0){
            return 0
        }
        
        if indexPath.section == 2 && indexPath.row == 4 {
            if self.scPrinterFont.isHidden{
                return 0
            }
        }
        
        if indexPath.section == 2 && (indexPath.row == 1 || indexPath.row == 2 || indexPath.row == 3 || indexPath.row == 4 || indexPath.row == 5){
            if self.swEnablePrinter.isOn == false{
                return 0
            }
        }
        
        return self.tableView.rowHeight
    }
    
    public func getDefaultSettings(){
        self.tfWebServiceUrl.text = settings.DataServiceUrl
        self.tfFiscalPrinterUrl.text = settings.FiscalPrinterUrl
        self.tfStoreId.text = settings.StoreId
        self.scPrinterType.selectedSegmentIndex = settings.PrinterType
        self.printerManufacturerString = settings.PrinterManufacturerString
        self.scFiscalDocumentType.selectedSegmentIndex = settings.FiscalDocumentType
        self.tfCashRegister.text = settings.CashRegister
        self.scLabelPrinter.selectedSegmentIndex = settings.PrinterLabel
        self.tfTerminalId.text = settings.TerminalId
        self.tfTerminalIp.text = settings.TerminalIp
        self.tfTerminalPort.text = settings.TerminalPort
        self.swEnablePrinter.isOn = settings.EnablePrinter
        self.tfWSTerminal.text = settings.WSTerminalIP
        self.printerModelString = settings.PrinterModelString
        self.storeCode = settings.StoreCode
        
        self.tfPrinterSeries.text = self.printerManufacturerString
        
        if !self.printerModelString.isEmpty{
            self.tfPrinterSeries.text?.append("[" + self.printerModelString + "]")
            
            self.modelIndex = self.getPrinterSeriesRowNumber(item: self.printerModelString)
            let columns = PrinterData.getPrinterColumns(manufacturer: self.printerManufacturerString, type: self.scPrinterType.selectedSegmentIndex)
            self.changeSCPrinterFont(numberOfSegments: columns[modelIndex].count)
        }
        
        self.scPrinterFont.selectedSegmentIndex = settings.PrinterFont
        self.lfLoggedInUserName.text = settings.LoggedInUserName
        self.swEnableSSL.isOn = settings.EnableSSL
    }
    
    func setDefaultSettings() -> Bool {
        if let tfWebServiceUrl = self.tfWebServiceUrl.text{
            settings.DataServiceUrl = tfWebServiceUrl
        }
        if let tfFiscalPrinterUrl = self.tfFiscalPrinterUrl.text {
            settings.FiscalPrinterUrl = tfFiscalPrinterUrl
        }
        if let tfStoreId = self.tfStoreId.text {
            if let isStoreIdNumber = Int(tfStoreId){
                settings.StoreId = isStoreIdNumber.description
                settings.StoreCode = self.storeCode
            }
            else{
                Util.AlertSystemError(viewController: self, message: Util.getString("Store ID must be a number!"))
                return false
            }
        }
        if let tfCashRegister = self.tfCashRegister.text {
            if let isCashRegisterNumber = Int(tfCashRegister){
                settings.CashRegister = isCashRegisterNumber.description
            }
            else{
                Util.AlertSystemError(viewController: self, message: Util.getString("Cash Register must be a number!"))
                return false
            }
        }
        if let terminalId = self.tfTerminalId.text{
            settings.TerminalId = terminalId
        }
        if let terminalIp = self.tfTerminalIp.text{
            settings.TerminalIp = terminalIp
        }
        if let terminalPort = self.tfTerminalPort.text{
            settings.TerminalPort = terminalPort
        }
        settings.PrinterFont = self.scPrinterFont.selectedSegmentIndex
        settings.EnablePrinter = self.swEnablePrinter.isOn
        settings.PrinterType = self.scPrinterType.selectedSegmentIndex
        settings.PrinterLabel = self.scLabelPrinter.selectedSegmentIndex
        settings.FiscalDocumentType = self.scFiscalDocumentType.selectedSegmentIndex
        
        if self.scPrinterType.selectedSegmentIndex == PrinterType.fiscalPrinter.rawValue{
            settings.PrinterColumns = Defaults.defaultPrinterColumns
        }
        else{
            self.modelIndex = self.getPrinterSeriesRowNumber(item: self.printerModelString)
            let columns = PrinterData.getPrinterColumns(manufacturer: self.printerManufacturerString, type: self.scPrinterType.selectedSegmentIndex)
            if columns[modelIndex].count > 0{
                settings.PrinterColumns = columns[modelIndex][self.scPrinterFont.selectedSegmentIndex]
                settings.PrinterRowNumber = modelIndex
            }
            else{
                settings.PrinterColumns = Defaults.defaultPrinterColumns
                settings.PrinterRowNumber = modelIndex
            }
        }
        
        if let wsTerminalIP = self.tfWSTerminal.text{
            settings.WSTerminalIP = wsTerminalIP
        }
        
        settings.PrinterManufacturerString = self.printerManufacturerString
        settings.PrinterModelString = self.printerModelString
        settings.EnableSSL = self.swEnableSSL.isOn
        
        settings.save()
        return true
    }
    
    @objc func applyButtonPressed(_ sender: Any){
        if self.setDefaultSettings() {
            if self.isInPreConfigState{
                State.createSessionManager(dataSource: settings.DataServiceUrl)
                self.loadLoginViewController()
             }
            else{
                let storyboard = UIStoryboard(name: "Main", bundle: nil)
                let contactsViewController = storyboard.instantiateViewController(withIdentifier: "contactsViewController") as! MasterViewController
                self.contactsViewController = UINavigationController(rootViewController: contactsViewController)
                self.slideMenuController()?.changeMainViewController(self.contactsViewController, close: true)
            }
        }
    }
    
    func changeAdvancedSettingsStatus(isEnabled: Bool){
        if isInPreConfigState{
            self.lfDataSource.isEnabled = isEnabled
            self.tfWebServiceUrl.isEnabled = isEnabled
        }
        else{
            self.lfDataSource.isEnabled = false
            self.tfWebServiceUrl.isEnabled = false
        }
        
        self.lfStoreId.isEnabled = isEnabled
        self.lfCashRegister.isEnabled = isEnabled
        self.tfStoreId.isEnabled = isEnabled
        self.tfCashRegister.isEnabled = isEnabled
        self.lfEnableSSL.isEnabled = isEnabled
        self.swEnableSSL.isEnabled = isEnabled
    }
    
    func changePrinterSettingsStatus(isEnabled: Bool){
        self.lfPrinterIp.isEnabled = isEnabled
        self.lfPrinterType.isEnabled = isEnabled
        self.lfPrinterFont.isEnabled = isEnabled
        self.tfFiscalPrinterUrl.isEnabled = isEnabled
        self.scPrinterFont.isEnabled = isEnabled
        self.scPrinterType.isEnabled = isEnabled
        self.btTestPrinter.isEnabled = isEnabled
        self.btSearchPrinter.isEnabled = isEnabled
        self.lfPrinterSeries.isEnabled = isEnabled
        self.tfPrinterSeries.isEnabled = isEnabled
    }
    
    @IBAction func btEditAdvancedSettings_Click(_ sender: Any) {
        self.showInsertPinAlert(message: Util.getString("Insert PIN"))
    }
    
    @IBAction func btTestAdvanceSettings_Click(_ sender: Any) {
        if let webServiceUrl = self.tfWebServiceUrl.text, webServiceUrl.isEmpty == false{
            var storeId: String?
            if self.tfStoreId.text != nil && self.tfStoreId.text != ""{
                storeId = self.tfStoreId.text
            }
            State.testConnection(testIp: webServiceUrl, type: "dataSource", storeId: storeId, terminalId: nil, terminalPort: nil, webServiceIp: nil,completionHandler: {result in
                    Util.GeneralAlert(viewController: self, message: result)
            })
        }
        else{
            Util.GeneralAlert(viewController: self, message: Util.getString("Please insert data source URL"))
        }
    }
    
    @IBAction func swEnablePrinter_ValueChanged(_ sender: Any) {
        self.changePrinterSettingsStatus(isEnabled: self.swEnablePrinter.isOn)
        if self.swEnablePrinter.isOn{
            self.changePrinterType(isFiscal: (self.scPrinterType.selectedSegmentIndex == 0) ? true : false)
        }
        self.tableView.reloadData()
    }

    @IBAction func btSearchPrinter_Click(_ sender: Any) {
        let searchPrinterViewController = (self.storyboard?.instantiateViewController(withIdentifier: "searchPrinterViewController") as! SearchPrinterViewController)
        searchPrinterViewController.delegate = self
        self.navigationController?.pushViewController(searchPrinterViewController, animated: true)
    }
    
    @IBAction func btTestPrinter_Click(_ sender: Any) {
        if let text = self.tfFiscalPrinterUrl.text, text.isEmpty == false{
            if self.scPrinterType.selectedSegmentIndex == PrinterType.fiscalPrinter.rawValue{
                if self.printerManufacturerString == PrinterManufacturer.epsonInteligent.rawValue{
                    self.testFiscalPrinter()
                }
                else if self.printerManufacturerString == PrinterManufacturer.ditron.rawValue{
                    let ditron = DitronFiscalPrinter()
                    ditron.ecrIpAddress = text
                    ditron.testFiscalPrinter(completionHandler: { result in
                        guard let result = result else{
                            NetworkController.AlertConnectionError(viewController: self)
                            return
                        }
                        if result == false {
                            Util.AlertSystemError(viewController: self)
                        }
                        else{
                            Util.GeneralAlert(viewController: self, message: "Connection succeeded!")
                        }
                    })
                }
                else{
                    Util.GeneralAlert(viewController: self, message: Util.getString("Please select printer manufacturer"))
                }
            }
            if self.scPrinterType.selectedSegmentIndex == PrinterType.nonFiscalPrinter.rawValue{
                if self.printerManufacturerString == PrinterManufacturer.epson.rawValue{
                    if self.tfPrinterSeries != nil && self.tfPrinterSeries.text != ""{
                        settings.FiscalPrinterUrl = self.tfFiscalPrinterUrl.text!
                        settings.PrinterFont = self.scPrinterFont.selectedSegmentIndex
                        settings.PrinterType = self.scPrinterType.selectedSegmentIndex
                        settings.PrinterManufacturerString = self.printerManufacturerString
                        settings.PrinterModelString = self.printerModelString
                        self.modelIndex = self.getPrinterSeriesRowNumber(item: self.printerModelString)
                        let columns = PrinterData.getPrinterColumns(manufacturer: self.printerManufacturerString, type: self.scPrinterType.selectedSegmentIndex)
                        settings.PrinterColumns = columns[self.modelIndex][self.scPrinterFont.selectedSegmentIndex]
                        settings.PrinterRowNumber = self.modelIndex
                        settings.save()
                        self.testNonFiscalPrinter()
                    }
                    else{
                        Util.GeneralAlert(viewController: self, message: Util.getString("Please insert printer series"))
                    }
                }
                else if self.printerManufacturerString == PrinterManufacturer.ditron.rawValue{
                    
                }
                else{
                    Util.GeneralAlert(viewController: self, message: Util.getString("Please select printer manufacturer"))
                }
            }
            
        }
        else{
            Util.GeneralAlert(viewController: self, message: Util.getString("Please insert printer address"))
        }
    }
    
    @IBAction func btTestTerminal_Click(_ sender: Any) {
        if let wsTerminal = self.tfWSTerminal.text, wsTerminal.isEmpty == false
         , let terminalIp = self.tfTerminalIp.text, terminalIp.isEmpty == false
         , let terminalId = self.tfTerminalId.text, terminalId.isEmpty == false
         , let terminalPort = self.tfTerminalPort.text, terminalPort.isEmpty == false{
            State.testConnection(testIp: terminalIp, type: "terminal", storeId: nil,  terminalId: terminalId, terminalPort: terminalPort, webServiceIp: wsTerminal, completionHandler: {result in
                Util.GeneralAlert(viewController: self, message: result)
            })
        }
        else{
            Util.GeneralAlert(viewController: self, message: Util.getString("Insert all fields"))
        }
    }
    
    func testFiscalPrinter(){
        State.testConnection(testIp: self.tfFiscalPrinterUrl.text!, type: "printer", storeId: nil, terminalId: nil, terminalPort: nil, webServiceIp: nil, completionHandler: {result in
            Util.GeneralAlert(viewController: self, message: result)
        })
    }
    
    func testNonFiscalPrinter(){
        let printer = EpsonNonFiscalPrinter()
        let result = printer.testPrinter()
        if result != EPOS2_SUCCESS.rawValue{
            Util.GeneralAlert(viewController: self, message: Util.getString("Connection failed!"))
        }
        else{
            Util.GeneralAlert(viewController: self, message: Util.getString("Connection established!"))
        }
    }
    
    func selectedPrinter(printerName: String, printerIp: String) {
        self.isLoadingSettingsEnabled = false
        self.printerManufacturerString = PrinterData.getPrinterManufacturers(type: self.scPrinterType.selectedSegmentIndex)[0]
        self.modelIndex = getPrinterSeriesRowNumber(item: printerName)
        let columns = PrinterData.getPrinterColumns(manufacturer: self.printerManufacturerString, type: self.scPrinterType.selectedSegmentIndex)
        self.changeSCPrinterFont(numberOfSegments: columns[modelIndex].count)
        
        let models = PrinterData.getPrinterSeries(manufacturer: self.printerManufacturerString, type:  scPrinterType.selectedSegmentIndex)
        self.tfPrinterSeries.text = self.printerManufacturerString
        if models.count > 0{
            self.tfPrinterSeries.text?.append("[" + models[self.modelIndex] + "]")
            self.printerModelString = models[self.modelIndex]
        }
        
        self.tfFiscalPrinterUrl.text = printerIp
        self.scPrinterType.selectedSegmentIndex = 1
        _ = self.navigationController?.popViewController(animated: true)
    }
    
    func onPtrReceive(_ printerObj: Epos2Printer!, code: Int32, status: Epos2PrinterStatusInfo!, printJobId: String!) {
        
    }
    
    @IBAction func printerType_ValueChanged(_ sender: UISegmentedControl) {
        self.resetPrinterStrings()

        if sender.selectedSegmentIndex == PrinterType.fiscalPrinter.rawValue{
            self.changePrinterType(isFiscal: true)
        }
        else if sender.selectedSegmentIndex == PrinterType.nonFiscalPrinter.rawValue{
            self.changePrinterType(isFiscal: false)
        }
    }
    
    func resetPrinterStrings(){
        self.tfPrinterSeries.text = nil
        self.printerManufacturerString = ""
        self.printerModelString = ""
    }
    
    func changePrinterType(isFiscal: Bool){
        self.btSearchPrinter.isHidden = isFiscal
        self.lfPrinterFont.isHidden = isFiscal
        self.scPrinterFont.isHidden = isFiscal
        
        self.tableView.reloadData()
    }
    
    func showInsertPinAlert(message: String){
        let alert = UIAlertController(title: "iPOS", message: message, preferredStyle: .alert)
        alert.addTextField { (textField) in
            textField.keyboardType = UIKeyboardType.numberPad
            textField.isSecureTextEntry = true
            textField.addTarget(self, action: #selector(self.textChanged), for: .editingChanged)
        }
        alert.addAction(UIAlertAction(title: "Ok", style: .default, handler: { (action) in
            if alert.textFields?[0].text == self.pinForEdit{
                self.changeAdvancedSettingsStatus(isEnabled: true)
            }
            else{
                self.showInsertPinAlert(message: Util.getString("Wrong input!\nPlease try again!"))
            }
        }))
        alert.addAction(UIAlertAction(title: Util.getString("Cancel"), style: .destructive, handler: {(action) in
            return
        }))
        alert.actions[0].isEnabled = false
        present(alert, animated: true, completion: nil)
    }
    
    @objc func textChanged(_ sender: Any) {
        let tf = sender as! UITextField
        var resp : UIResponder! = tf
        while !(resp is UIAlertController) { resp = resp.next }
        let alert = resp as! UIAlertController
        alert.actions[0].isEnabled = (tf.text!.count > 0)
    }
    
    func numberOfComponents(in pickerView: UIPickerView) -> Int {
        if scPrinterType.selectedSegmentIndex == PrinterType.fiscalPrinter.rawValue{
            if printerManufacturerString == PrinterManufacturer.epsonInteligent.rawValue{
                return 1
            }
            else if printerManufacturerString == PrinterManufacturer.ditron.rawValue{
                return 1
            }
            return 1
        }
        else if scPrinterType.selectedSegmentIndex == PrinterType.nonFiscalPrinter.rawValue{
            if printerManufacturerString == PrinterManufacturer.epson.rawValue{
                return 2
            }
            else if printerManufacturerString == PrinterManufacturer.ditron.rawValue{
                return 1
            }
            return 2
        }
        
        return 0
    }
    
    func pickerView(_ pickerView: UIPickerView, widthForComponent component: Int) -> CGFloat {
        if component == 0{
            return self.view.frame.width / 2
        }
        else{
            return self.view.frame.width / 2
        }
    }
    
    func pickerView(_ pickerView: UIPickerView, numberOfRowsInComponent component: Int) -> Int {
        if component == 0{
            let manufacturers = PrinterData.getPrinterManufacturers(type: scPrinterType.selectedSegmentIndex)
            return manufacturers.count
        }
        else{
            self.printerManufacturerString = PrinterData.getPrinterManufacturers(type: scPrinterType.selectedSegmentIndex)[0]
            let series = PrinterData.getPrinterSeries(manufacturer: self.printerManufacturerString, type: scPrinterType.selectedSegmentIndex)
            return series.count
        }
    }
    
    func pickerView(_ pickerView: UIPickerView, titleForRow row: Int, forComponent component: Int) -> String? {
        if component == 0{
            let manufacturers = PrinterData.getPrinterManufacturers(type: scPrinterType.selectedSegmentIndex)
            return manufacturers[row]
        }
        else{
            self.printerManufacturerString = PrinterData.getPrinterManufacturers(type: scPrinterType.selectedSegmentIndex)[0]
            let series = PrinterData.getPrinterSeries(manufacturer: self.printerManufacturerString, type: scPrinterType.selectedSegmentIndex)
            return series[row]
        }
    }
    
    func pickerView(_ pickerView: UIPickerView, didSelectRow row: Int, inComponent component: Int) {
        if component == 0{
            printerSeriesPicker.reloadAllComponents()
            
            let manufacturerName = PrinterData.getPrinterManufacturers(type: self.scPrinterType.selectedSegmentIndex)[row]
            self.tfPrinterSeries.text = manufacturerName
            self.printerManufacturerString = manufacturerName
            
            if self.printerSeriesPicker.numberOfComponents == 2{
                let index = self.printerSeriesPicker.selectedRow(inComponent: 1)
                let models = PrinterData.getPrinterSeries(manufacturer: self.printerManufacturerString, type:  scPrinterType.selectedSegmentIndex)
                if models.count > 0{
                    self.printerModelString = models[index]
                    self.tfPrinterSeries.text?.append("[" + printerModelString + "]")
                    
                    self.modelIndex = index
                    let columns = PrinterData.getPrinterColumns(manufacturer: self.printerManufacturerString, type: scPrinterType.selectedSegmentIndex)
                    changeSCPrinterFont(numberOfSegments: columns[modelIndex].count)
                }
            }
        }
        else if component == 1{
            printerSeriesPicker.reloadAllComponents()
            
            let models = PrinterData.getPrinterSeries(manufacturer: self.printerManufacturerString, type:  scPrinterType.selectedSegmentIndex)
            self.tfPrinterSeries.text = self.printerManufacturerString
            if models.count > 0{
                self.printerModelString = models[row]
                self.tfPrinterSeries.text?.append("[" + printerModelString + "]")
                
                self.modelIndex = row
                let columns = PrinterData.getPrinterColumns(manufacturer: self.printerManufacturerString, type: scPrinterType.selectedSegmentIndex)
                changeSCPrinterFont(numberOfSegments: columns[modelIndex].count)
            }
        }
    }

    func changeSCPrinterFont(numberOfSegments: Int){
        if scPrinterFont.numberOfSegments == numberOfSegments{
            scPrinterFont.selectedSegmentIndex = 0
        }
        else if scPrinterFont.numberOfSegments < numberOfSegments{
            while (scPrinterFont.numberOfSegments != numberOfSegments){
                scPrinterFont.insertSegment(withTitle: "\(scPrinterFont.numberOfSegments + 1)", at: scPrinterFont.numberOfSegments, animated: false)
            }
            scPrinterFont.selectedSegmentIndex = 0
        }
        else{
            while (scPrinterFont.numberOfSegments != numberOfSegments){
                scPrinterFont.removeSegment(at: scPrinterFont.numberOfSegments - 1, animated: false)
            }
            scPrinterFont.selectedSegmentIndex = 0
        }
    }
    
    @IBAction func selectPrinterSeries(_ sender: UITextField) {
        sender.inputAssistantItem.trailingBarButtonGroups = []
        sender.inputAssistantItem.leadingBarButtonGroups = []
        
        self.printerSeriesPicker.frame.origin.x = (self.view.frame.size.width - self.printerSeriesPicker.frame.size.width)/2
        let inputView = UIView(frame: CGRect(x: 0, y: 0, width: self.view.frame.size.width, height: self.printerSeriesPicker.frame.size.height))
        inputView.backgroundColor = UIColor.white
        inputView.addSubview(printerSeriesPicker)
        
        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()
    }
    
    func handleOpenPicker(){
        self.printerSeriesPicker.reloadAllComponents()
        
        if self.printerSeriesPicker.numberOfComponents == 1{
            self.selectItemInPickerViewSimple(item: self.self.printerManufacturerString, picker: self.printerSeriesPicker)
        }
        
        if self.printerSeriesPicker.numberOfComponents == 2{
            self.selectItemInPickerViewDouble(item: self.printerModelString, picker: self.printerSeriesPicker, component: 1)
        }
    }

    @objc func donePicker(_ picker: UIPickerView){
        self.tfPrinterSeries.resignFirstResponder()
    }

    @objc func cancelPicker(_ picker: UIPickerView){
        self.scPrinterFont.selectedSegmentIndex = 0
        self.tfPrinterSeries.text = ""
        self.tfPrinterSeries.resignFirstResponder()
    }
    
    func selectItemInPickerViewDouble (item: String, picker: UIPickerView,component: Int) {
        var rowIndex: Int? = 0
        if(component == 0){
            rowIndex = self.getPrinterManufacturerRowNumber(item: item)
        }
        else if(component == 1){
            rowIndex = self.getPrinterSeriesRowNumber(item: item)
        }
        if let rowIndex = rowIndex {
            picker.selectRow(rowIndex, inComponent: component, animated: true)
            picker.delegate?.pickerView!(picker, didSelectRow: rowIndex, inComponent: component)
        }
    }
    
    func selectItemInPickerViewSimple (item: String, picker: UIPickerView) {
        var rowIndex: Int? = nil
        rowIndex = getPrinterManufacturerRowNumber(item: item)
        if let rowIndex = rowIndex {
            picker.reloadAllComponents()
            picker.selectRow(rowIndex, inComponent: 0, animated: true)
            picker.delegate?.pickerView!(picker, didSelectRow: rowIndex, inComponent: 0)
        }
    }
    
    func getPrinterManufacturerRowNumber(item: String) -> Int{
        let manufacturers = PrinterData.getPrinterManufacturers(type: self.scPrinterType.selectedSegmentIndex)
        for manufacturer in manufacturers{
            if item == manufacturer{
                if let index = manufacturers.firstIndex(of: manufacturer){
                    return index
                }
            }
        }
        return 0
    }
    
    func getPrinterSeriesRowNumber(item: String) -> Int{
        let models = PrinterData.getPrinterSeries(manufacturer: self.printerManufacturerString, type: self.scPrinterType.selectedSegmentIndex)
        for model in models{
            if item.uppercased().contains(model){
                if let index = models.firstIndex(of: model){
                    return index
                }
            }
        }
        return 0
    }
    
    func textFieldShouldBeginEditing(_ textField: UITextField) -> Bool {
        if textField == self.tfStoreId{
            self.dismissKeyboard()
        }
        return true
    }
    
    func textFieldDidBeginEditing(_ textField: UITextField) {
        if textField == self.tfStoreId{
            textField.resignFirstResponder()
        }
    }
    
    func textFieldDidEndEditing(_ textField: UITextField) {
        if textField == self.tfWebServiceUrl{
            State.createSessionManager(dataSource: textField.text!)
        }
    }
    
    @IBAction func tfStoreId_Click(_ sender: Any) {
        if self.tfWebServiceUrl.text != nil && self.tfWebServiceUrl.text != ""{
            State.loadStores(dataSource: self.tfWebServiceUrl.text!, nil) { result in
                if result{
                    self.openPopUp(self.tfStoreId, State.stores, "Store", Util.getString("Stores"))
                }
                else{
                    Util.GeneralAlert(viewController: self, message: Util.getString("Connection failed!"))
                }
            }
        }
        else{
            Util.GeneralAlert(viewController: self, message: Util.getString("Please insert data source URL"))
        }
    }
    
    func adaptivePresentationStyle(for controller: UIPresentationController) -> UIModalPresentationStyle {
        return .fullScreen
    }
    
    func openPopUp(_ textField: UITextField, _ dataSource: [INameable], _ dataSourceType: String, _ title: String ) {
        let popupSelectorViewController = self.storyboard?.instantiateViewController(withIdentifier: "popupSelectorViewController") as! PopupSelectorViewController
        popupSelectorViewController.shouldBeSearchBarHidden = true
        popupSelectorViewController.itemSelectedCallback = selectedValue
        popupSelectorViewController.dataSource = dataSource
        popupSelectorViewController.dataSourceType = dataSourceType
        popupSelectorViewController.shouldBeSearchBarHidden = false
        popupSelectorViewController.dataSourceURL = self.tfWebServiceUrl.text!
        popupSelectorViewController.title = title
        let nav = UINavigationController(rootViewController: popupSelectorViewController)
        nav.modalPresentationStyle = UIModalPresentationStyle.fullScreen
        let popover = nav.popoverPresentationController
        popover?.permittedArrowDirections = .up
        popupSelectorViewController.preferredContentSize = CGSize(width: self.view.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?){
        self.isLoadingSettingsEnabled = false
        let store = item as! Store
        
        self.tfStoreId.text = store.storeId.description
        self.storeCode = store.code
    }
    
    @IBAction func btLogout_Click(_ sender: Any) {
        settings.LoggedInUserName = nil
        settings.LoggedInUserId = nil
        settings.LoggedInUserPassword = nil
        State = StateController()
        State.createSessionManager(dataSource: settings.DataServiceUrl)
        self.loadLoginViewController()
    }
    
    func loadLoginViewController(){
        let storyboard = UIStoryboard(name: "Main", bundle: nil)
        let loginViewController = storyboard.instantiateViewController(withIdentifier: "loginViewController") as! LoginViewController
        self.loginViewController = UINavigationController(rootViewController: loginViewController)
        self.slideMenuController()?.changeMainViewController(self.loginViewController, close: true)
    }
}
