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

import Foundation

enum DocumentTypeEnum: Int {
    case Receipt = 0
    case Invoice = 1
}

let settings = SettingsController()
class SettingsController {

    var printer: IPrinter?
    var customerDisplay: ICustomerDiplay?
    var printerDiscoverType: LWPrintDiscoverConnectionType?
    var userSettings: UserValidationResponse = UserValidationResponse()
    var storeSetupSettings: StoreSetup_Result = StoreSetup_Result()
    let isDemoVersion = false
    
    internal let defaults = UserDefaults.standard

    struct keys {
        static var ST_DATASERVICE = "ST_DATASERVICE"
        static var ST_FISCALPRINTER = "ST_FISCALPRINTER"
        static var ST_STOREID = "ST_STOREID"
        static var ST_PRINTERTYPE = "ST_PRINTERTYPE"
        static var ST_PRINTERMANUFACTURER = "ST_PRINTERMANUFACTURER"
        static var ST_PRINTERMODEL = "ST_PRINTERMODEL"
        static var ST_FISCALDOCUMENTTYPE = "ST_FISCALDOCUMENTTYPE"
        static var ST_CASHREGISTER = "ST_CASHREGISTER"
        static var ST_PRINTERLABEL = "ST_PRINTERLABEL"
        static var ST_PRINTERCOLUMNS = "ST_PRINTERCOLUMNS"
        static var ST_TERMINALID = "ST_TERMINALID"
        static var ST_TERMINALIP = "ST_TERMINALIP"
        static var ST_TERMINALPORT = "ST_TERMINALPORT"
        static var ST_ENABLEPRINTER = "ST_ENABLEPRINTER"
        static var ST_PRINTERFONT = "ST_PRINTERFONT"
        static var ST_WSTERMINALIP = "ST_WSTERMINALIP"
        static var ST_PRINTERROWNUMBER = "ST_PRINTERROWNUMBER"
        static var ST_LOGGEDINUSERNAME = "ST_LOGGEDINUSERNAME"
        static var ST_LOGGEDINUSERID = "ST_LOGGEDINUSERID"
        static var ST_LOGGEDINUSERPASSWORD = "ST_LOGGEDINUSERPASSWORD"
        static var ST_ENABLESSL = "ST_ENABLESSL"
        static var ST_STORECODE = "ST_STORECODE"
        static var ST_LOGGEDINUSERCODE = "ST_LOGGEDINUSERCODE"
        static var ST_LOGGEDINUSERROLES = "ST_LOGGEDINUSERROLES"
        static var ST_LOGGEDINUSERPERMISSIONS = "ST_LOGGEDINUSERPERMISSONS"
    }
    
    var DataServiceUrl: String {
        get {
            if let dataServiceUrl = self.defaults.string(forKey: keys.ST_DATASERVICE) {
                return dataServiceUrl
            }
            else{
                return Defaults.defaultDataService
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_DATASERVICE)
        }
    }

    var FiscalPrinterUrl: String {
        get {
            if let fiscalPrinterUrl = self.defaults.string(forKey: keys.ST_FISCALPRINTER) {
                return fiscalPrinterUrl
            }
            else{
                return Defaults.defaultFiscalPrinter
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_FISCALPRINTER)
        }
    }
    
    var StoreId: String {
        get {
            if let storeId = self.defaults.string(forKey: keys.ST_STOREID) {
                return storeId
            }
            else{
                return Defaults.defaultStoreId
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_STOREID)
        }
    }
    
    var CashRegister: String {
        get {
            if let cashRegister = self.defaults.string(forKey: keys.ST_CASHREGISTER) {
                return cashRegister
            }
            else{
                return Defaults.defaultCashRegister
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_CASHREGISTER)
        }
    }
    
    var PrinterManufacturerString: String {
        get {
            if let printerManufacturer = self.defaults.string(forKey: keys.ST_PRINTERMANUFACTURER){
                return printerManufacturer
            }
            else{
                return PrinterManufacturer.epsonInteligent.rawValue
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_PRINTERMANUFACTURER)
        }
    }
    
    var PrinterModelString: String {
        get {
            if let printerModel = self.defaults.string(forKey: keys.ST_PRINTERMODEL){
                return printerModel
            }
            else{
                return ""
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_PRINTERMODEL)
        }
    }

    var PrinterType: Int {
        get {
            return self.defaults.integer(forKey: keys.ST_PRINTERTYPE)
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_PRINTERTYPE)
            self.setSelectedPrinter()
            self.getPrinterSerialNumber()
            self.getPrinterFirmwareVersion()
        }
    }
    
    func getPrinterSerialNumber(){
        settings.printer?.getFiscalPrinterSerialNumber { sn in
            if let serialNumber = sn, serialNumber.count == 11{
                State.fiscalPrinterSN = serialNumber
                print(serialNumber)
            }
        }
    }
    
    func getPrinterFirmwareVersion(){
        settings.printer?.getFiscalPrinterFirmwareVersion { fv in
            if let firmwareVersion = fv{
                State.firmwareVersion = firmwareVersion
                print(firmwareVersion)
            }
        }
    }
    
    func setSelectedPrinter() {
        if !self.EnablePrinter{
            self.printer = nil
            self.customerDisplay = nil
        }
        else{
            if self.PrinterType == 0 {
                if self.PrinterManufacturerString == PrinterManufacturer.epsonInteligent.rawValue{
                    if self.storeSetupSettings.printerModel == "RT"{
                        self.printer = EpsonFiscalPrinterRT()
                    }
                    else{
                        self.printer = EpsonFiscalPrinter()
                    }
                    self.customerDisplay = EpsonCustomerDisplayFiscal()
                }
                if self.PrinterManufacturerString == PrinterManufacturer.ditron.rawValue{
                    self.printer = DitronFiscalPrinter()
                    self.customerDisplay = nil
                }
            }
            else if PrinterType == 1{
                self.printer = EpsonNonFiscalPrinter()
                self.customerDisplay = EpsonCustomerDisplayNonFiscal()
            }
        }
    }
    
    var FiscalDocumentType: Int {
        get {
            return self.defaults.integer(forKey: keys.ST_FISCALDOCUMENTTYPE)
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_FISCALDOCUMENTTYPE)
        }
    }
    
    var PrinterLabel: Int {
        get {
            return self.defaults.integer(forKey: keys.ST_PRINTERLABEL)
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_PRINTERLABEL)
            self.setSelectedPrinterLabel()
        }
    }
    
    var PrinterColumns: Int {
        get {
            if self.defaults.integer(forKey: keys.ST_PRINTERCOLUMNS) == 0{
                return Defaults.defaultPrinterColumns
            }
            return self.defaults.integer(forKey: keys.ST_PRINTERCOLUMNS)
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_PRINTERCOLUMNS)
        }
    }
    
    var PrinterRowNumber: Int {
        get {
            return self.defaults.integer(forKey: keys.ST_PRINTERROWNUMBER)
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_PRINTERROWNUMBER)
        }
    }
    
    var PrinterFont: Int{
        get {
            return self.defaults.integer(forKey: keys.ST_PRINTERFONT)
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_PRINTERFONT)
        }
    }
    
    func setSelectedPrinterLabel(){
        if PrinterLabel == 0 {
            self.printerDiscoverType = LWPrintDiscoverConnectionType.ConnectionTypeBluetooth
        }
        else{
            self.printerDiscoverType = LWPrintDiscoverConnectionType.ConnectionTypeNetwork
        }
    }
    
    var TerminalId: String {
        get {
            if let terminalId = self.defaults.string(forKey: keys.ST_TERMINALID) {
                return terminalId
            }
            else{
                return ""
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_TERMINALID)
        }
    }
    
    var WSTerminalIP: String{
        get {
            if let wsTerminalIp = self.defaults.string(forKey: keys.ST_WSTERMINALIP) {
                return wsTerminalIp
            }
            else{
                return ""
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_WSTERMINALIP)
        }
    }
    
    var TerminalIp: String {
        get {
            if let terminalIp = self.defaults.string(forKey: keys.ST_TERMINALIP) {
                return terminalIp
            }
            else{
                return ""
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_TERMINALIP)
        }
    }
    
    var TerminalPort: String{
        get {
            if let terminalPort = self.defaults.string(forKey: keys.ST_TERMINALPORT) {
                return terminalPort
            }
            else{
                return ""
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_TERMINALPORT)
        }
    }
    
    var EnablePrinter: Bool{
        get {
            return self.defaults.bool(forKey: keys.ST_ENABLEPRINTER)
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_ENABLEPRINTER)
        }
    }
    
    var EnableSSL: Bool{
        get {
            return self.defaults.bool(forKey: keys.ST_ENABLESSL)
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_ENABLESSL)
        }
    }
    
    var LoggedInUserName: String? {
        get {
            if let loggedInUserName = self.defaults.string(forKey: keys.ST_LOGGEDINUSERNAME) {
                return loggedInUserName
            }
            else{
                return nil
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_LOGGEDINUSERNAME)
        }
    }
    
    var LoggedInUserId: String? {
        get {
            if let loggedInUserId = self.defaults.string(forKey: keys.ST_LOGGEDINUSERID) {
                return loggedInUserId
            }
            else{
                return nil
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_LOGGEDINUSERID)
        }
    }
    
    var LoggedInUserPassword: String? {
        get {
            if let loggedInUserPassword = self.defaults.string(forKey: keys.ST_LOGGEDINUSERPASSWORD) {
                return loggedInUserPassword
            }
            else{
                return nil
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_LOGGEDINUSERPASSWORD)
        }
    }
    
    var StoreCode: String {
        get {
            if let storeCode = self.defaults.string(forKey: keys.ST_STORECODE){
                return storeCode
            }
            else{
                return ""
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_STORECODE)
        }
    }
    
    var LoggedInUserCode: String? {
        get {
            if let loggedInUserCode = self.defaults.string(forKey: keys.ST_LOGGEDINUSERCODE) {
                return loggedInUserCode
            }
            else{
                return nil
            }
        }
        set {
            self.defaults.set(newValue, forKey: keys.ST_LOGGEDINUSERCODE)
        }
    }
    
    var LoggedInUserRoles: [String]? {
        get{
            if let loggedInUserRoles = self.defaults.stringArray(forKey: keys.ST_LOGGEDINUSERROLES){
                return loggedInUserRoles
            }
            else{
                return nil
            }
        }
        set{
            self.defaults.set(newValue, forKey: keys.ST_LOGGEDINUSERROLES)
        }
    }
    
    var LoggedInUserPermissons: [String]? {
        get{
            if let loggedInUserPermissons = self.defaults.stringArray(forKey: keys.ST_LOGGEDINUSERPERMISSIONS){
                return loggedInUserPermissons
            }
            else{
                return nil
            }
        }
        set{
            self.defaults.set(newValue, forKey: keys.ST_LOGGEDINUSERPERMISSIONS)
        }
    }
    
    func save() {
        defaults.synchronize()
    }
    
    func remove() {
        if let bundleIdentifier = Bundle.main.bundleIdentifier {
            defaults.removePersistentDomain(forName: bundleIdentifier)
            defaults.synchronize()
        }
    }
}
