LONDON-IOS/GME Remit/Utilities/AppConstants.swift

//
//  AppConstants.swift
//  GMERemittance
//
//  Created by gme_2 on 10/09/2018.
//  Copyright © 2018 Gobal Money Express Co. Ltd. All rights reserved.
//

import Foundation
import UIKit

class AppConstants {
    static let uuid = "uuid"
    static let dateFormat = "yyyy-MM-dd"
    static let humanReadableDateFormat = "MMM d, yyyy"
    static let errorBorderWidth: CGFloat = 0.1
    static let emergencyLogoutErrorCode = -1111
    static let maxKoreanMobileNoLength = 11
    static let MainWireFrameNotificationName = "MainViewControllerSelect"
    static let yearlyLimitNotification = "Yearly LImit"
    static let tabbarItemChangeNotification = "changeTabItem"
}

enum Devices {
    case iphone5
    case iphone678
    case iphone678Plus
    case iphoneX
    case ipad
    case other
}

//pennyTestStatus='0'-----0 not started, 1 requested , 2 completed

enum PennyTestStatusCode: String {
    case notStarted = "0"
    case requested = "1"
    case completed = "2"
    case cancelled = "3"
}

enum Language: String {
    case en
    case kr
    case kh
    case lk
    case th
    case id
    case mn
    case mm
    case np
    case bd
    case ru
    case uz
    case vn
    case pk
    case jp
    case ja
    
    var code: String {
        switch self {
        case .en, .th, .id, .mn, .uz:
            return self.rawValue
        case .pk:
            return "ur-PK"
        case .kr:
            return "ko"
        case .kh:
            return "km"
        case .lk:
            return "si"
        case .mm:
            return "my"
        case .np:
            return "ne"
        case .bd:
            return "bn"
        case .ru:
            return "ru-RU"
        case .vn:
            return "vi-VN"
        case .jp:
            return "jp"
        case .ja:
            return "ja"
        }
    }
    
    var title: String {
        switch self {
        case .en:
            return "English"
        case .kr:
            return "한국"
        case .kh:
            return "ភាសាខ្មែរ"
        case .lk:
            return "සිංහල"
        case .th:
            return "ไทย"
        case .id:
            return "Bahasa Indonesia"
        case .mn:
            return "Монгол"
        case .mm:
            return "Myanmar"
        case .np:
            return "नेपाली"
        case .bd:
            return "বাংলা"
        case .ru:
            return "русский"
        case .uz:
            return "O\'zbek"
        case .vn:
            return "Tiếng Việt"
        case .pk:
            return "پاکستان"
        case .jp, .ja:
            return "日本語"
        }
    }
}

extension String {
    var languageCode: Language? {
        switch self {
        case "ko", "kr":
            return .kr
        case "km", "kh":
            return .kh
        case "si", "lk":
            return .lk
        case "my", "mm":
            return .mm
        case "ne", "np":
            return .np
        case "bn", "bd":
            return .bd
        case "ru-RU", "ru":
            return .ru
        case "vi-VN", "vn":
            return .vn
        case "ur-PK", "pk":
            return .pk
        case "jp" , "ja":
            return .ja
        case "en", "th", "id", "mn", "uz":
            return Language.init(rawValue: self)!
            
        default:
            return nil
        }
    }
}

class Utility {
    static let database = GMEDB.shared
    
    static func getDeviceModel() -> Devices {
        if UIDevice.current.userInterfaceIdiom == .phone {
            switch UIScreen.main.nativeBounds.height {
            case 1136:
                return .iphone5
            case 1334:
                return .iphone678
            case 2208:
                return .iphone678Plus
            case 2436:
                return .iphoneX
            default:
                return .other
            }
        } else {
            return .ipad
        }
    }
    
    static func getLanguageHeader(for currentLanugage: String) -> String {
        var header = ""
        switch currentLanugage {
        case "ko":
            header = "kr"
        case "km":
            header = "kh"
        case "si":
            header = "lk"
        case "my":
            header = "mm"
        case "ne":
            header = "np"
        case "bn":
            header = "bd"
        case "ru-RU":
            header = "ru"
        case "vi-VN":
            header = "vn"
        case "uz":
            header = "uz"
        case "mn":
            header = "mn"
        case "id":
            header = "id"
        case "th":
            header = "th"
        case "ur-PK":
            header = "pk"
        case "jp", "ja":
            header = "ja"
        default:
            header = "en"
        }
        
        return header
    }
    
    static func isVerifiedUser() -> Bool {
        return database.user.bool(.verified)
    }
    
    static func didSubmitKyc() -> Bool {
        return database.user.bool(.kyc)
    }
    
    static func isExistingUser() -> Bool {
        return database.user.bool(.isExistingUser)
    }
    
    static func hasUpdatedDefaultCredentials() -> Int {
        return database.user.integer(.hasUpdatedDefaultCredentials)
    }
    
    static func notificationCount() -> String {
        return database.user.string(.notificationCount) ?? "0"
    }
    
    static func isCriticalUpdate() -> Bool {
        return database.app.string(.criticalUpdate)?.lowercased() == "Y".lowercased()
    }
    
    static func getMyUserName() -> String {
        return database.user.string(.userId) ?? ""
    }
    
    static func getMyId() -> String {
        return database.user.string(.senderId) ?? ""
    }
    
    static func getMyKftcClientId() -> String {
        return database.user.string(.kftcClientId) ?? ""
    }
    
    static func getMyIdNumber() -> String {
        return database.user.string(.idNumber) ?? ""
    }
    
    static func getMyPrimaryAccountNumber() -> String {
        return database.user.string(.primaryAccountNumber) ?? ""
    }
    
    static func hasVerifiedOtp() -> Bool {
        return database.user.bool(.hasVerifiedOTP)
    }
    
    static func isValidEmail(email: String) -> Bool {
        let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}"
        let emailTest = NSPredicate(format:"SELF MATCHES %@", emailRegex)
        return emailTest.evaluate(with: email)
    }
    
    static func getCommaSeperatedString(numberString: String) -> String? {
        let text = numberString.extract(regex: "[0-9.]")
        if let number = Double(text) {
            let nsNumber = NSNumber.init(value: number)
            let currencyFormatter = NumberFormatter()
            currencyFormatter.locale = Locale(identifier: "en_US")
            currencyFormatter.numberStyle = .decimal
            let commaSeperatedNumberString = currencyFormatter.string(for: nsNumber)
            let text = commaSeperatedNumberString?.replacingOccurrences(of: ".", with: ",")
            return text
        }
        return nil
    }
    
    static func getCommaSeperatedStringWithDecimal(numberString: String) -> String? {
        let text = numberString.extract(regex: "[0-9.]")
        if let number = Double(text) {
            let nsNumber = NSNumber.init(value: number)
            let currencyFormatter = NumberFormatter()
            currencyFormatter.locale = Locale(identifier: "en_US")
            currencyFormatter.numberStyle = .decimal
            currencyFormatter.groupingSize = 3
            currencyFormatter.usesGroupingSeparator = true
            let commaSeperatedNumberString = currencyFormatter.string(for: nsNumber)
            return commaSeperatedNumberString
        }
        return nil
    }
    
    static func save(
        user: User?,
        accessCodeBase64: String? = nil,
        password: String? = nil,
        login: Bool? = false
    ) {
        if login ?? false {
            GMEDB
                .shared
                .user
                .set(accessCodeBase64, .accessCode)
                .set(user?.kftcClientId, .kftcClientId)
        }
        
        GMEDB
            .shared
            .setUser(user)
        
        // save remind day of KFTC Token
        let remindDay = calculateDDay(registDate: user?.accessTokenRegTime)
        //    let remindDay = calculateDDay(registDate: "7/20/2018 4:49:32 PM")
        GMEDB.shared.user.set(remindDay, .remindKFTCTokenDay)
        
        guard let encryptedPassword = password else { return }
        
        let id = GMEDB.shared.user.string(.userId) ?? ""
        
        if id != KeyChain.shared.get(key: .id) {
            KeyChain.shared.remove(key: .biometricAuth)
        }
        
        KeyChain.shared.save(data: id, key: .id)
        KeyChain.shared.save(data: encryptedPassword, key: .password)
        KeyChain.shared.save(data: "1", key: .login)
    }
    
    static func calculateDDay(registDate: String?) -> String? {
        let dateFormatter = DateFormatter()
        
        dateFormatter.dateFormat = "M/d/yyyy h:mm:ss a"
        dateFormatter.locale = Locale(identifier: "ko_kr")
        dateFormatter.timeZone = TimeZone(abbreviation: "KST")
        
        var dateComponent = DateComponents()
        dateComponent.year = 1
        
        guard
            let resigstDate = registDate,
            let date = dateFormatter.date(from: resigstDate),
            let expireDate = Calendar.current.date(byAdding: dateComponent, to: date) else {return nil}
        
        let now = Date()
        
        let calendar = Calendar.current
        
        let startDate = calendar.startOfDay(for: now)
        let endDate = calendar.startOfDay(for: expireDate)
        
        guard let remindDay = calendar.dateComponents([.day], from: startDate, to: endDate).day else {
            return nil
        }
        
        return "\(remindDay)"
    }
    
    static func numberWithoutprecedingZero(str: String) -> String {
        let formatter = NumberFormatter()
        let number = formatter.number(from: str)
        return "\(number ?? 0)"
    }
    
    static func getAppVersion () -> String? {
        let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String
        return version
    }
    
    static func getOsVersion() -> String {
        let version = UIDevice.current.systemVersion
        return version
    }
    
    static func getPhoneBrand() -> String {
        let phoneName = UIDevice.current.model
        return phoneName
    }
    
    static func getPhoneOs() -> String {
        let os = UIDevice.current.systemName
        return os
    }
    
    static func getUUid() -> String? {
        let uuid =  UIDevice.current.identifierForVendor?.uuidString
        return uuid
    }
    
    static func getCliendId() -> String {
        //live value
        
        return "5220221D2E737FD60C28243"
        //uat value
//        return "162021E171B825A55C52024823"
    }
}

extension Utility {
    static func getLanguages() -> [SendMoneyCountryViewModel] {
        let english = SendMoneyCountryViewModel()
        english.name = "english_language_text".localized()
        english.id = "english_language_text"
        english.title = "English"
        english.code = "en"
        
        let korean = SendMoneyCountryViewModel()
        korean.name = "korean_language_text".localized()
        korean.id = "korean_language_text"
        korean.title = "한국"
        korean.code = "kr"
        
        let cambodia = SendMoneyCountryViewModel()
        cambodia.name = "cambodia_lanugage_text".localized()
        cambodia.id = "cambodia_lanugage_text"
        cambodia.title = "ភាសាខ្មែរ"
        cambodia.code = "kh"
        
        let srilanka = SendMoneyCountryViewModel()
        srilanka.name = "srilanka_lanugage_text".localized()
        srilanka.id = "srilanka_lanugage_text"
        srilanka.title = "සිංහල"
        srilanka.code = "lk"
        
        let myanmar = SendMoneyCountryViewModel()
        myanmar.name = "myanmar_language_text".localized()
        myanmar.id = "myanmar_language_text"
        myanmar.title = "Myanmar"
        myanmar.code = "mm"
        
        let russian = SendMoneyCountryViewModel()
        russian.name = "russian_langugae_text".localized()
        russian.id = "русский"
        russian.title = "русский"
        russian.code = "ru"
        
        let vietnam = SendMoneyCountryViewModel()
        vietnam.name = "vietnam_language_text".localized()
        vietnam.id = "vietnam_language_text"
        vietnam.title = "Tiếng Việt"
        vietnam.code = "vn"
        
        let thailand = SendMoneyCountryViewModel()
        thailand.name = "thailand_language_text".localized()
        thailand.id = "thailand_language_text"
        thailand.title = "ไทย"
        thailand.code = "th"
        
        let indonesia = SendMoneyCountryViewModel()
        indonesia.name = "indonesia_language_text".localized()
        indonesia.id = "indonesia_language_text"
        indonesia.title = "Bahasa Indonesia"
        indonesia.code = "id"
        
        let mongolia = SendMoneyCountryViewModel()
        mongolia.name = "mongolia_language_text".localized()
        mongolia.id = "mongolia_language_text"
        mongolia.title = "Монгол"
        mongolia.code = "mn"
        
        let nepal = SendMoneyCountryViewModel()
        nepal.name = "nepali_language_text".localized()
        nepal.id = "nepali_language_text"
        nepal.title = "नेपाली"
        nepal.code = "np"
        
        let bangladesh = SendMoneyCountryViewModel()
        bangladesh.name = "bengali_language_text".localized()
        bangladesh.id = "bengali_language_text"
        bangladesh.title = "বাংলা"
        bangladesh.code = "bd"
        
        let uzbek = SendMoneyCountryViewModel()
        uzbek.name = "uzbek_language_text".localized()
        uzbek.id = "uzbek_language_text"
        uzbek.title = "O'zbek"
        uzbek.code = "uz"
        
        let pakistan = SendMoneyCountryViewModel()
        pakistan.name = "pakistan_language_text".localized()
        pakistan.id = "pakistan_language_text"
        pakistan.title = "پاکستان"
        pakistan.code = "pk"
        
        let japanese = SendMoneyCountryViewModel()
        japanese.name = "japanese_language_text".localized()
        japanese.id = "japanese_language_text"
        japanese.title = "日本語"
        japanese.code = "ja"
        
        let languages = [
            english, japanese, bangladesh, nepal, vietnam, srilanka
        ]
        return languages
    }
}