NexilisLibraryiOS/AppBuilder/AppBuilder/ViewController.swift

//
//  ViewController.swift
//  TestQmeraLite
//
//  Created by Qindi on 29/11/21.
//

import UIKit
import NexilisLite
import AVKit
import AVFoundation
import SwiftUI
import Speech
import Alamofire
import WebKit

class ViewController: UITabBarController, UITabBarControllerDelegate, SettingMABDelegate, WKNavigationDelegate {
    let playerController = AVPlayerViewController()
    static var sURL = "https://www.google.com"
    static var tab3 = "0"
    public var isShow: Bool = false
    public static var chatButton = UIButton()
    public static var callButton = UIButton()
    public static var ccButton = UIButton()
    public static var streamingButton = UIButton()
    public static var postButton = UIButton()
    public static var middleButton = UIButton()
    var buttonChatGR : UITapGestureRecognizer?
    var buttonCallGR : UITapGestureRecognizer?
    var buttonCCGR : UITapGestureRecognizer?
    var buttonStreamGR : UITapGestureRecognizer?
    var floating : FloatingButton?
    var firstTab : FirstTabViewController?
    var secondTab : SecondTabViewController?
    var thirdTab : ThirdTabViewController?
    var fourthTab : FourthTabViewController?
    let emptyTab = EmptyTabViewController()
    public static var isTab1 = true
    public static var isTab2 = false
    public static var isTab3 = false
    public static var isTab4 = false
    public static var isExpandButton = false
    public static var alwaysHideButton = false
    static var listPullFB: [String] = []
    static var datePullFB: Date?
    let welcomeVC = UIViewController()
    let privacyPolicyVC = UIViewController()
    var termVC: UIViewController?
    let welcomeDesc = UILabel()
    let termText = "Read our Terms of Service. Tap \"Agree and Continue\" to accept Terms of Service.".localized()
    let term = "Terms of Service.".localized()
    var firstLoad = true
    let privacyWV = WKWebView()
    let indicatorCounterFB = UIView()
    let labelCounterFB = UILabel()
    var indicatorView : UIView!
    var indicatorImage : UIImageView!
    var imageIndicator: UIImage!
    
    public static var def: ViewController?

    override func viewDidLoad() {
        super.viewDidLoad()
        DispatchQueue.main.async { [self] in
            while !Utils.getFinishInitPrefsr() || HTTPCookieStorage.shared.cookies(for: URL(string: Utils.getDomainOpr())!)!.count == 0 {
                Thread.sleep(forTimeInterval: 1)
            }
            startView()
        }
    }
    
    override func viewDidDisappear(_ animated: Bool) {
        Utils.randomizeBackground(view: self.navigationController?.view)
    }
    
    func startView() {
        navigationController?.view.backgroundColor = self.traitCollection.userInterfaceStyle == .dark ? .black : .white
        Utils.addBackground(view: self.navigationController?.view)
        let topBorder = CALayer()
        topBorder.backgroundColor = UIColor.borderTabColor.cgColor
        topBorder.frame = CGRect(x: 0, y: 0, width: tabBar.frame.size.width, height: 1)
        tabBar.layer.addSublayer(topBorder)
        
        ViewController.def = self
        title = Bundle.main.displayName
        let customTab = PrefsUtil.getCustomTab().split(separator: ",")
        let cpaasMode = PrefsUtil.getCpaasMode()
        var tabs : [UIViewController] = []
        firstTab = storyboard?.instantiateViewController(withIdentifier: "firstTabVC") as? FirstTabViewController
        secondTab = storyboard?.instantiateViewController(withIdentifier: "secondTabVC") as? SecondTabViewController
        thirdTab = storyboard?.instantiateViewController(withIdentifier: "thirdTabVC") as? ThirdTabViewController
        fourthTab = storyboard?.instantiateViewController(withIdentifier: "fourthTabVC") as? FourthTabViewController
        
        self.delegate = self
        
        firstTab?.tabBarItem = UITabBarItem(title: "", image: resizeImage(image: self.traitCollection.userInterfaceStyle == .dark ? UIImage(named: "tab_1_icon")!.withTintColor(.white) : UIImage(named: "tab_1_icon")!, targetSize: CGSize(width: 25, height: 25)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: UIImage(named: "tab_1_icon")!, targetSize: CGSize(width: 25, height: 25)).withRenderingMode(.alwaysOriginal).withTintColor(self.traitCollection.userInterfaceStyle == .dark ? .lightGray : .mainColor))
        secondTab?.tabBarItem = UITabBarItem(title: "", image: resizeImage(image: self.traitCollection.userInterfaceStyle == .dark ? UIImage(named: "tab_2_icon")!.withTintColor(.white) : UIImage(named: "tab_2_icon")!, targetSize: CGSize(width: 25, height: 25)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: UIImage(named: "tab_2_icon")!, targetSize: CGSize(width: 25, height: 25)).withRenderingMode(.alwaysOriginal).withTintColor(self.traitCollection.userInterfaceStyle == .dark ? .lightGray : .mainColor))
        thirdTab?.tabBarItem = UITabBarItem(title: "", image: resizeImage(image: self.traitCollection.userInterfaceStyle == .dark ? UIImage(named: "tab_3_icon")!.withTintColor(.white) : UIImage(named: "tab_3_icon")!, targetSize: CGSize(width: 25, height: 25)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: UIImage(named: "tab_3_icon")!, targetSize: CGSize(width: 25, height: 25)).withRenderingMode(.alwaysOriginal).withTintColor(self.traitCollection.userInterfaceStyle == .dark ? .lightGray : .mainColor))
        fourthTab?.tabBarItem = UITabBarItem(title: "", image: resizeImage(image: self.traitCollection.userInterfaceStyle == .dark ? UIImage(named: "tab_4_icon")!.withTintColor(.white) : UIImage(named: "tab_4_icon")!, targetSize: CGSize(width: 25, height: 25)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: UIImage(named: "tab_4_icon")!, targetSize: CGSize(width: 25, height: 25)).withRenderingMode(.alwaysOriginal).withTintColor(self.traitCollection.userInterfaceStyle == .dark ? .lightGray : .mainColor))
        var i = 0
        var j = 0
        while j < customTab.count {
            if(((i == 1 && customTab.count == 3) || i == 2) &&
               (cpaasMode == PrefsUtil.CPAAS_MODE_DOCKED || cpaasMode == PrefsUtil.CPAAS_MODE_MIX)){
                tabs.append(emptyTab)
            }
            else {
                switch(customTab[j]){
                case "1":
                    tabs.append(firstTab!)
                case "2":
                    tabs.append(secondTab!)
                case "3":
                    tabs.append(thirdTab!)
                case "4":
                    tabs.append(fourthTab!)
                default:
                    break
                }
                j += 1
            }
            i += 1
        }
        DispatchQueue.global().async {
            if !Utils.getTab1Icon().isEmpty {
                let urlString = "\(PrefsUtil.getURLBase())get_file_from_path?img=\(Utils.getTab1Icon())"
                if let cachedImage = ImageCache.shared.image(forKey: urlString) {
                    DispatchQueue.main.async() {
                        tabs[0].tabBarItem = UITabBarItem(title: "", image: self.resizeImage(image: cachedImage, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal), selectedImage: self.resizeImage(image: cachedImage, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal))
                    }
                } else {
                    Utils.fetchDataWithCookiesAndUserAgent(from: URL(string: urlString)!) { data, response, error in
                        guard let data = data, error == nil else { return }
                        // always update the UI from the main thread
                        DispatchQueue.main.async() { [self] in
                            if UIImage(data: data) != nil {
                                tabs[0].tabBarItem = UITabBarItem(title: "", image: resizeImage(image: UIImage(data: data)!, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: UIImage(data: data)!, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal))
                                ImageCache.shared.save(image: UIImage(data: data)!, forKey: urlString)
                            }
                        }
                    }
                }
            }
            if !Utils.getTab2Icon().isEmpty {
                let urlString = "\(PrefsUtil.getURLBase())get_file_from_path?img=\(Utils.getTab2Icon())"
                if let cachedImage = ImageCache.shared.image(forKey: urlString) {
                    DispatchQueue.main.async() { [self] in
                        tabs[1].tabBarItem = UITabBarItem(title: "", image: resizeImage(image: cachedImage, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: cachedImage, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal))
                    }
                } else {
                    Utils.fetchDataWithCookiesAndUserAgent(from: URL(string: urlString)!) { data, response, error in
                        guard let data = data, error == nil else { return }
                        // always update the UI from the main thread
                        DispatchQueue.main.async() { [self] in
                            if UIImage(data: data) != nil {
                                tabs[1].tabBarItem = UITabBarItem(title: "", image: resizeImage(image: UIImage(data: data)!, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: UIImage(data: data)!, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal))
                                ImageCache.shared.save(image: UIImage(data: data)!, forKey: urlString)
                            }
                        }
                    }
                }
            }
            if !Utils.getTab3Icon().isEmpty {
                let urlString = "\(PrefsUtil.getURLBase())get_file_from_path?img=\(Utils.getTab3Icon())"
                if let cachedImage = ImageCache.shared.image(forKey: urlString) {
                    DispatchQueue.main.async() { [self] in
                        if cpaasMode == PrefsUtil.CPAAS_MODE_DOCKED || cpaasMode == PrefsUtil.CPAAS_MODE_MIX {
                            tabs[3].tabBarItem = UITabBarItem(title: "", image: resizeImage(image: cachedImage, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: cachedImage, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal))
                        } else {
                            tabs[2].tabBarItem = UITabBarItem(title: "", image: resizeImage(image: cachedImage, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: cachedImage, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal))
                        }
                    }
                } else {
                    Utils.fetchDataWithCookiesAndUserAgent(from: URL(string: urlString)!) { data, response, error in
                        guard let data = data, error == nil else { return }
                        // always update the UI from the main thread
                        DispatchQueue.main.async() { [self] in
                            if UIImage(data: data) != nil {
                                if cpaasMode == PrefsUtil.CPAAS_MODE_DOCKED || cpaasMode == PrefsUtil.CPAAS_MODE_MIX {
                                    tabs[3].tabBarItem = UITabBarItem(title: "", image: resizeImage(image: UIImage(data: data)!, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: UIImage(data: data)!, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal))
                                } else {
                                    tabs[2].tabBarItem = UITabBarItem(title: "", image: resizeImage(image: UIImage(data: data)!, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: UIImage(data: data)!, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal))
                                }
                                ImageCache.shared.save(image: UIImage(data: data)!, forKey: urlString)
                            }
                        }
                    }
                }
            }
            if !Utils.getTab4Icon().isEmpty {
                let urlString = "\(PrefsUtil.getURLBase())get_file_from_path?img=\(Utils.getTab4Icon())"
                if let cachedImage = ImageCache.shared.image(forKey: urlString) {
                    DispatchQueue.main.async() { [self] in
                        if cpaasMode == PrefsUtil.CPAAS_MODE_DOCKED || cpaasMode == PrefsUtil.CPAAS_MODE_MIX {
                            tabs[4].tabBarItem = UITabBarItem(title: "", image: resizeImage(image: cachedImage, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: cachedImage, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal))
                        } else {
                            tabs[3].tabBarItem = UITabBarItem(title: "", image: resizeImage(image: cachedImage, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: cachedImage, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal))
                        }
                    }
                } else {
                    Utils.fetchDataWithCookiesAndUserAgent(from: URL(string: urlString)!) { data, response, error in
                        guard let data = data, error == nil else { return }
                        // always update the UI from the main thread
                        DispatchQueue.main.async() { [self] in
                            if UIImage(data: data) != nil {
                                if cpaasMode == PrefsUtil.CPAAS_MODE_DOCKED || cpaasMode == PrefsUtil.CPAAS_MODE_MIX {
                                    tabs[4].tabBarItem = UITabBarItem(title: "", image: resizeImage(image: UIImage(data: data)!, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: UIImage(data: data)!, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal))
                                } else {
                                    tabs[3].tabBarItem = UITabBarItem(title: "", image: resizeImage(image: UIImage(data: data)!, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal), selectedImage: resizeImage(image: UIImage(data: data)!, targetSize: CGSize(width: 30, height: 30)).withRenderingMode(.alwaysOriginal))
                                }
                                ImageCache.shared.save(image: UIImage(data: data)!, forKey: urlString)
                            }
                        }
                    }
                }
            }
        }
        if((cpaasMode == PrefsUtil.CPAAS_MODE_DOCKED || cpaasMode == PrefsUtil.CPAAS_MODE_MIX)){
            createMidFloatingButton()
            navigationController?.setNavigationBarHidden(true, animated: false)
            ViewController.pullActionButton()
        }
//        if((cpaasMode == PrefsUtil.CPAAS_MODE_FLOATING || cpaasMode == PrefsUtil.CPAAS_MODE_MIX)) {
//            let rect = CGRect(x: self.view.bounds.width - 100, y: self.view.bounds.height / 2, width: 50, height: 250)
//            floating = FloatingButton()
//            floating?.frame = rect
//            floating?.isShow = true
//
//            view.addSubview(floating!)
//            navigationController?.setNavigationBarHidden(true, animated: false)
//        }
        
        self.selectedIndex = Utils.getLastTabSelected()
        self.setViewControllers(tabs, animated: false)
        if(cpaasMode == PrefsUtil.CPAAS_MODE_DOCKED || cpaasMode == PrefsUtil.CPAAS_MODE_MIX){
            if(customTab.count == 3){
                self.tabBar.items?[1].isEnabled = false
            }
            self.tabBar.items?[2].isEnabled = false
        }
        let center: NotificationCenter = NotificationCenter.default
        center.addObserver(self, selector: #selector(checkCounter), name: NSNotification.Name(rawValue: Nexilis.listenerReceiveChat), object: nil)
        center.addObserver(self, selector: #selector(checkCounter), name: NSNotification.Name(rawValue: "reloadTabChats"), object: nil)
        if !Utils.getIndicatorTabImage().isEmpty {
            let indicatorImage = Utils.getIndicatorTabImage()
            let fullUrl = "\(PrefsUtil.getURLBase())get_file_from_path?img=\(indicatorImage)"
            if let cachedImage = ImageCache.shared.image(forKey: fullUrl) {
                DispatchQueue.main.async() { [self] in
                    imageIndicator = cachedImage
                    addCustomViewAboveTabBarItem(at: Utils.getLastTabSelected(), image: imageIndicator)
                }
            } else {
                Utils.fetchDataWithCookiesAndUserAgent(from: URL(string: fullUrl)!) { data, response, error in
                    guard let data = data, error == nil else { return }
                    // always update the UI from the main thread
                    DispatchQueue.main.async() { [self] in
                        if UIImage(data: data) != nil {
                            imageIndicator = UIImage(data: data)!
                            addCustomViewAboveTabBarItem(at: Utils.getLastTabSelected(), image: imageIndicator)
                            ImageCache.shared.save(image: UIImage(data: data)!, forKey: fullUrl)
                        }
                    }
                }
            }
        }
        DispatchQueue.main.asyncAfter(deadline: .now() + 1, execute: { [self] in
            checkCounter()
        })
        willappear()
//        Nexilis.debugBroadcast()
    }
    
    func addCustomViewAboveTabBarItem(at index: Int, image: UIImage?) {
        guard let tabBarItems = tabBar.items, index < tabBarItems.count else { return }
        let tabBarFrame = tabBar.frame
        let tabBarItemWidth = tabBarFrame.width / CGFloat(tabBarItems.count)
        let multiplierValue: CGFloat = CGFloat(index + index + 1)
        let xCenter = tabBarItemWidth * multiplierValue / 2 - 20
        if image != nil {
            indicatorImage = UIImageView(image: image)
            indicatorImage.contentMode = .scaleAspectFit
            indicatorImage.frame = CGRect(x: xCenter, y: 5, width: 40, height: 40)
            tabBar.addSubview(indicatorImage)
            tabBar.sendSubviewToBack(indicatorImage)
        }
    }
    
    static func getiPhoneModel() -> String {
        var systemInfo = utsname()
        uname(&systemInfo)
        let machineMirror = Mirror(reflecting: systemInfo.machine)
        let identifier = machineMirror.children.reduce("") { identifier, element in
            guard let value = element.value as? Int8, value != 0 else { return identifier }
            return identifier + String(UnicodeScalar(UInt8(value)))
        }
        
        var model = ""
        
        if let modelName = mapToDevice(identifier: identifier) {
            model = modelName
        } else {
            model = "Unknown"
        }
        
        return model
    }

    static func mapToDevice(identifier: String) -> String? {
        // Add mappings for iPhone models as needed
        switch identifier {
            case "iPhone1,1", "iPhone1,2", "iPhone2,1", "iPhone3,1", "iPhone3,2", "iPhone3,3", "iPhone4,1", "iPhone5,1", "iPhone5,2", "iPhone5,3", "iPhone5,4", "iPhone6,1", "iPhone6,2", "iPhone7,1", "iPhone7,2", "iPhone8,1", "iPhone8,2", "iPhone8,4", "iPhone9,1", "iPhone9,2", "iPhone9,3", "iPhone9,4", "iPhone10,1", "iPhone10,2", "iPhone10,4", "iPhone10,5": return "iPhone under X"
            default: return "iPhone X or newer"
        }
    }
    
    func getPrefs(key: String) -> TMessage {
        let tMessage = NexilisLite.TMessage()
        let me = User.getMyPin()
        tMessage.mCode = "PPR"
        tMessage.mStatus = CoreMessage_TMessageUtil.getTID()
        tMessage.mBodies[CoreMessage_TMessageKey.F_PIN] = me
        tMessage.mBodies[CoreMessage_TMessageKey.KEY] = key
        return tMessage
    }
    
    @objc func checkCounter() {
        DispatchQueue.global().async {
            DispatchQueue.main.async { [self] in
                if self.viewControllers?.firstIndex(of: secondTab!) != nil {
                    let counter = queryCountCounter()
                    let indexSecondTab = self.viewControllers?.firstIndex(of: secondTab!)
                    if counter > 0 {
                        if !indicatorCounterFB.isDescendant(of: tabBar) {
                            guard let tabBarItems = tabBar.items, let index = indexSecondTab else { return }
                            let tabBarFrame = tabBar.frame
                            let tabBarItemWidth = tabBarFrame.width / CGFloat(tabBarItems.count)
                            let multiplierValue: CGFloat = CGFloat(index + index + 1)
                            let xCenter = tabBarItemWidth * multiplierValue / 2 + 10
                            indicatorCounterFB.backgroundColor = .red
                            indicatorCounterFB.layer.cornerRadius = 8
                            indicatorCounterFB.clipsToBounds = true
                            indicatorCounterFB.frame = CGRect(x: xCenter, y: 5, width: counter > 99 ? 30 : counter > 9 ? 23 : 16, height: 16)
                            tabBar.addSubview(indicatorCounterFB)
                            indicatorCounterFB.addSubview(labelCounterFB)
                            labelCounterFB.anchor(centerX: indicatorCounterFB.centerXAnchor, centerY: indicatorCounterFB.centerYAnchor)
                            labelCounterFB.font = .systemFont(ofSize: 10)
                            labelCounterFB.textColor = .white
                        }
                        if counter > 99 {
                            labelCounterFB.text = "99+"
                        } else {
                            labelCounterFB.text = "\(counter)"
                        }
                    } else {
                        if indicatorCounterFB.isDescendant(of: tabBar) {
                            indicatorCounterFB.removeFromSuperview()
                        }
                    }
                }
            }
        }
    }
    
    private func queryCountCounter() -> Int32 {
        var counter: Int32?
        Database.shared.database?.inTransaction({ (fmdb, rollback) in
            if let cursor = Database.shared.getRecords(fmdb: fmdb, query: "SELECT SUM(counter) FROM MESSAGE_SUMMARY"), cursor.next() {
                counter = cursor.int(forColumnIndex: 0)
                cursor.close()
            }
        })
        return counter ?? 0
    }

//    override func viewDidLayoutSubviews() {
//        super.viewDidLayoutSubviews()
//        tabBar.frame.size.height = 65
//        tabBar.frame.origin.y = view.frame.height - 65
//    }
    
    override func viewDidAppear(_ animated: Bool) {
        Nexilis.floatingButton.isHidden = false
    }
    
    func settingDelegate() {
        if self.navigationController?.visibleViewController == fourthTab {
            return
        }
        if self.viewControllers?.firstIndex(of: fourthTab!) == nil {
            let vc = fourthTab!
            vc.notInTab = true
            Nexilis.floatingButton.isHidden = true
            self.navigationController?.show(vc, sender: nil)
        } else {
            self.selectedIndex = (self.viewControllers?.firstIndex(of: fourthTab!))!
        }
    }
    
    static var alertChangeProfile = LibAlertController()
    
    public static func checkIsChangePerson() -> Bool {
        let isChangeProfile = Utils.getSetProfile()
        if !isChangeProfile {
            alertChangeProfile.dismiss(animated: false)
            alertChangeProfile = LibAlertController(title: "Change Profile".localized(), message: "You must change your name to use this feature".localized().localized(), preferredStyle: .alert)
            alertChangeProfile.addAction(UIAlertAction(title: "Cancel".localized(), style: .destructive, handler: {_ in
                if ViewController.def?.viewControllers?.firstIndex(of: (ViewController.def?.firstTab)!) == ViewController.def?.selectedIndex {
                    ViewController.def?.firstTab?.webView?.evaluateJavaScript("if(resumeAll){resumeAll();}")
                }
                if ViewController.def?.viewControllers?.firstIndex(of: (ViewController.def?.thirdTab)!) == ViewController.def?.selectedIndex {
                    ViewController.def?.thirdTab?.webView?.evaluateJavaScript("if(resumeAll){resumeAll();}")
                }
            }))
            alertChangeProfile.addAction(UIAlertAction(title: "OK".localized(), style: UIAlertAction.Style.default, handler: {(_) in
                ViewController.resetTabSelected()
                let controller = AppStoryBoard.Palio.instance.instantiateViewController(withIdentifier: "signupsignin") as! SignUpSignIn
                controller.forceLogin = true
                controller.isDismiss = { newThumb in
                    FirstTabViewController.forceRefresh = true
                    ThirdTabViewController.forceRefresh = true
                    FirstTabViewController.showModal = false
                    ThirdTabViewController.showModal = false
                }
                let navigationController = CustomNavigationController(rootViewController: controller)
                navigationController.modalPresentationStyle = .fullScreen
                navigationController.navigationBar.tintColor = .white
                navigationController.navigationBar.barTintColor = UIApplication.shared.windows.filter {$0.isKeyWindow}.first?.rootViewController?.traitCollection.userInterfaceStyle == .dark ? .blackDarkMode : .mainColor
                navigationController.navigationBar.isTranslucent = false
                navigationController.navigationBar.overrideUserInterfaceStyle = .dark
                navigationController.navigationBar.barStyle = .black
                let cancelButtonAttributes: [NSAttributedString.Key: Any] = [NSAttributedString.Key.foregroundColor: UIColor.white, NSAttributedString.Key.font : UIFont.systemFont(ofSize: 16)]
                UIBarButtonItem.appearance().setTitleTextAttributes(cancelButtonAttributes, for: .normal)
                let textAttributes = [NSAttributedString.Key.foregroundColor:UIColor.white]
                navigationController.navigationBar.titleTextAttributes = textAttributes
                ViewController.def?.show(b: false)
                ViewController.def?.thirdTab?.webView?.evaluateJavaScript("{if(pauseAll){pauseAll();}}")
                ViewController.def?.firstTab?.webView?.evaluateJavaScript("{if(pauseAll){pauseAll();}}")
                let rootVC = UIApplication.shared.windows.filter {$0.isKeyWindow}.first?.rootViewController
                if rootVC?.presentedViewController == nil {
                    rootVC?.present(navigationController, animated: true, completion: nil)
                } else {
                    rootVC?.presentedViewController?.present(navigationController, animated: true, completion: nil)
                }
            }))
            let rootVC = UIApplication.shared.windows.filter {$0.isKeyWindow}.first?.rootViewController
            if rootVC?.presentedViewController == nil {
                rootVC?.present(alertChangeProfile, animated: true, completion: nil)
            } else {
                rootVC?.presentedViewController?.present(alertChangeProfile, animated: true, completion: nil)
            }
            return false
        }
        return true
    }
    public static func resetTabSelected(){
        ViewController.isTab1 = true
        ViewController.isTab2 = false
        ViewController.isTab3 = false
        ViewController.isTab4 = false
    }
    
    override func tabBar(_ tabBar: UITabBar, didSelect item: UITabBarItem) {
        let cpaasMode = PrefsUtil.getCpaasMode()
        let customTab = PrefsUtil.getCustomTab().split(separator: ",")
        if(cpaasMode == PrefsUtil.CPAAS_MODE_DOCKED || cpaasMode == PrefsUtil.CPAAS_MODE_MIX){
            if(customTab.count == 2){
                ViewController.isTab1 = item == tabBar.items?[0]
                ViewController.isTab2 = item == tabBar.items?[2]
            }
            else if(customTab.count == 3){
                ViewController.isTab1 = item == tabBar.items?[0]
                ViewController.isTab2 = item == tabBar.items?[2]
                ViewController.isTab3 = item == tabBar.items?[3]
            }
            else if(customTab.count == 4){
                ViewController.isTab1 = item == tabBar.items?[0]
                ViewController.isTab2 = item == tabBar.items?[1]
                ViewController.isTab3 = item == tabBar.items?[3]
                ViewController.isTab4 = item == tabBar.items?[4]
            }
        }
        else{
            ViewController.isTab1 = item == tabBar.items?[0]
            ViewController.isTab2 = item == tabBar.items?[1]
            if(customTab.count > 2){
                ViewController.isTab3 = item == tabBar.items?[2]
            }
            if(customTab.count > 3){
                ViewController.isTab4 = item == tabBar.items?[3]
            }
        }
    }
    
    func createMidFloatingButton(){
        var minYIpX: CGFloat = 0
        let iPhoneModel = ViewController.getiPhoneModel()
        if iPhoneModel == "iPhone X or newer" {
            minYIpX += 20
        }
        var widthHeightButton: CGFloat = 45
        if Utils.getIconDockSize() == "1" {
            widthHeightButton = 55
        }
        ViewController.chatButton = UIButton(frame: CGRect(x: self.view.bounds.width / 2 - 22.5 , y: self.view.bounds.height - 80 - minYIpX, width: widthHeightButton, height: widthHeightButton))
        ViewController.chatButton.setBackgroundImage(UIImage(named: "pb_button_chat", in: Bundle.resourceBundle(for: Nexilis.self), with: nil)!.withRenderingMode(.alwaysOriginal), for: .normal)
        ViewController.chatButton.layer.shadowColor = UIColor.black.cgColor
        ViewController.chatButton.layer.shadowOpacity = 0.1
        ViewController.chatButton.layer.shadowOffset = CGSize(width: 4, height: 4)
        ViewController.chatButton.addTarget(self, action: #selector(chatTap), for: .touchUpInside)

        ViewController.callButton = UIButton(frame: CGRect(x: self.view.bounds.width / 2 - 22.5 , y: self.view.bounds.height - 80 - minYIpX, width: widthHeightButton, height: widthHeightButton))
        ViewController.callButton.setBackgroundImage(UIImage(named: "pb_button_call", in: Bundle.resourceBundle(for: Nexilis.self), with: nil)!.withRenderingMode(.alwaysOriginal), for: .normal)
        ViewController.callButton.layer.shadowColor = UIColor.black.cgColor
        ViewController.callButton.layer.shadowOpacity = 0.1
        ViewController.callButton.layer.shadowOffset = CGSize(width: 4, height: 4)
        ViewController.callButton.addTarget(self, action: #selector(callTap), for: .touchUpInside)

        ViewController.ccButton = UIButton(frame: CGRect(x: self.view.bounds.width / 2 - 22.5 , y: self.view.bounds.height - 80 - minYIpX, width: widthHeightButton, height: widthHeightButton))
        ViewController.ccButton.setBackgroundImage(UIImage(named: "pb_button_cc", in: Bundle.resourceBundle(for: Nexilis.self), with: nil)!.withRenderingMode(.alwaysOriginal), for: .normal)
        ViewController.ccButton.layer.shadowColor = UIColor.black.cgColor
        ViewController.ccButton.layer.shadowOpacity = 0.1
        ViewController.ccButton.layer.shadowOffset = CGSize(width: 4, height: 4)
        ViewController.ccButton.addTarget(self, action: #selector(ccTap), for: .touchUpInside)

        ViewController.streamingButton = UIButton(frame: CGRect(x: self.view.bounds.width / 2 - 22.5 , y: self.view.bounds.height - 80 - minYIpX, width: widthHeightButton, height: widthHeightButton))
        ViewController.streamingButton.setBackgroundImage(UIImage(named: "pb_button_stream", in: Bundle.resourceBundle(for: Nexilis.self), with: nil)!.withRenderingMode(.alwaysOriginal), for: .normal)
        ViewController.streamingButton.layer.shadowColor = UIColor.black.cgColor
        ViewController.streamingButton.layer.shadowOpacity = 0.1
        ViewController.streamingButton.layer.shadowOffset = CGSize(width: 4, height: 4)
        ViewController.streamingButton.addTarget(self, action: #selector(streamTap), for: .touchUpInside)

        ViewController.postButton = UIButton(frame: CGRect(x: self.view.bounds.width / 2 - 22.5 , y: self.view.bounds.height - 80 - minYIpX, width: widthHeightButton, height: widthHeightButton))
        ViewController.postButton.setBackgroundImage(UIImage(named: "pb_button_post", in: Bundle.resourceBundle(for: Nexilis.self), with: nil)!.withRenderingMode(.alwaysOriginal), for: .normal)
        ViewController.postButton.layer.shadowColor = UIColor.black.cgColor
        ViewController.postButton.layer.shadowOpacity = 0.1
        ViewController.postButton.layer.shadowOffset = CGSize(width: 4, height: 4)
        ViewController.postButton.addTarget(self, action: #selector(postTap), for: .touchUpInside)
        let buttonCenterX = self.view.bounds.width / 2
        let buttonCenterY = self.view.bounds.height - self.tabBar.bounds.height
        //print("buttonCenterX \(buttonCenterX)")
        //print("buttonCenterY \(buttonCenterY)")
        ViewController.middleButton = UIButton(frame: CGRect(x: buttonCenterX - 40 , y: buttonCenterY - 40, width: 80, height: 80))
        if !PrefsUtil.getIconDock().isEmpty {
            if PrefsUtil.getIconDock().contains(".gif") {
                ViewController.middleButton.sd_setBackgroundImage(with: URL(string: PrefsUtil.getIconCenterAnim()!), for: .normal, completed: nil)
            } else {
                DispatchQueue.global().async {
                    let urlString = PrefsUtil.getUrlDock()!
                    if let cachedImage = ImageCache.shared.image(forKey: urlString) {
                        DispatchQueue.main.async() {
                            ViewController.middleButton.setBackgroundImage(cachedImage, for: .normal)
                        }
                        return
                    }
                    Utils.fetchDataWithCookiesAndUserAgent(from: URL(string: urlString)!) { data, response, error in
                        guard let data = data, error == nil else { return }
                        // always update the UI from the main thread
                        DispatchQueue.main.async() {
                            if UIImage(data: data) != nil {
                                ViewController.middleButton.setBackgroundImage(UIImage(data: data), for: .normal)
                                ImageCache.shared.save(image: UIImage(data: data)!, forKey: urlString)
                            }
                        }
                    }
                }
            }
        } else {
            ViewController.middleButton.setBackgroundImage(UIImage(named: "pb_button", in: Bundle.resourceBundle(for: Nexilis.self), with: nil), for: .normal)
        }
        ViewController.middleButton.layer.shadowColor = UIColor.black.cgColor
        ViewController.middleButton.layer.shadowOffset = CGSize(width: 0.0, height: 2.0)
        ViewController.middleButton.layer.shadowOpacity = 1.0
        ViewController.middleButton.layer.shadowRadius = 5.0
        ViewController.middleButton.layer.masksToBounds = false
        ViewController.middleButton.layer.cornerRadius = 4.0
        ViewController.middleButton.addTarget(self, action: #selector(middleBtnTapped), for: .touchUpInside)
        let longPressMidButton = UILongPressGestureRecognizer(target: self, action: #selector(longPressMidBtn(gestureRecognizer:)))
        ViewController.middleButton.addGestureRecognizer(longPressMidButton)
        self.view.addSubview(ViewController.chatButton)
        self.view.addSubview(ViewController.callButton)
        self.view.addSubview(ViewController.ccButton)
        self.view.addSubview(ViewController.postButton)
        self.view.addSubview(ViewController.streamingButton)
        self.view.addSubview(ViewController.middleButton)
        
        ViewController.hideDockedButton()
    }
    
    @objc func longPressMidBtn(gestureRecognizer: UILongPressGestureRecognizer) {
        if gestureRecognizer.state == .began {
            if self.viewControllers?.firstIndex(of: fourthTab!) == nil {
                let vc = fourthTab!
                vc.notInTab = true
                self.navigationController?.show(vc, sender: nil)
            } else {
                self.selectedIndex = (self.viewControllers?.firstIndex(of: fourthTab!))!
            }
        }
    }
    
    func tabBarController(_ tabBarController: UITabBarController, shouldSelect viewController: UIViewController) -> Bool {
        if(viewController == secondTab){
            if(!ViewController.checkIsChangePerson()){
                return false
            }
        }
        return true
    }
    
    func tabBarController(_ tabBarController: UITabBarController, didSelect viewController: UIViewController) {
        if let selectedIndex = viewControllers?.firstIndex(of: viewController) {
            if indicatorImage != nil {
                indicatorImage.removeFromSuperview()
                addCustomViewAboveTabBarItem(at: selectedIndex, image: imageIndicator)
            }
            Utils.setLastTabSelected(value: selectedIndex)
        }
        if viewController != secondTab {
            let idxTabChat = self.viewControllers?.firstIndex(where: {$0 == secondTab})
            if idxTabChat != nil {
                let vcTabChats = self.viewControllers![idxTabChat!] as! SecondTabViewController
                if vcTabChats.searchController.isActive {
                    vcTabChats.searchController.isActive = false
                }
            }
        }
    }
    
    override func viewWillAppear(_ animated: Bool) {
        if !firstLoad {
            willappear()
        } else {
            firstLoad = false
        }
    }
    
    func willappear() {
        let acceptTerm = PrefsUtil.getTerms()
        let enable_privacy_policy = PrefsUtil.getEnablePrivacyPolicy()
        if !acceptTerm {
            showWelocomeView()
            return
        } else if enable_privacy_policy && !PrefsUtil.getAgreePrivacyPolicy() {
            showPrivacyPolicyView()
            return
        } else {
            if !Utils.getForceAnonymous() && !Utils.getSetProfile() {
                Nexilis.showForceSignIn()
                return
            }
        }
        self.selectedViewController?.viewWillAppear(false)
        self.selectedViewController?.viewDidAppear(false)
    }
    
    func showPrivacyPolicyView() {
        if let privacyView = privacyPolicyVC.view {
            let bgImage = UIImageView()
            privacyView.addSubview(bgImage)
            bgImage.anchor(top: privacyView.topAnchor, left: privacyView.leftAnchor, bottom: privacyView.bottomAnchor, right: privacyView.rightAnchor)
            bgImage.backgroundColor = .white
            DispatchQueue.global().async {
                DispatchQueue.main.async {
                    let listBg = PrefsUtil.getBackgroundLight().isEmpty && PrefsUtil.getBackgroundDark().isEmpty ? PrefsUtil.getBackground() :
                                        self.traitCollection.userInterfaceStyle == .dark ? PrefsUtil.getBackgroundDark() : PrefsUtil.getBackgroundLight()
                    if listBg.isEmpty {
                       return
                    }
                    var bgChoosen = ""
                    let arrayBg = listBg.split(separator: ",")
                    bgChoosen = String(arrayBg[Int.random(in: 0..<arrayBg.count)])
                    let urlString = PrefsUtil.getURLBase() + "get_file_from_path?img=" + bgChoosen
                    if let cachedImage = ImageCache.shared.image(forKey: urlString) {
                        DispatchQueue.main.async() {
                            bgImage.image = cachedImage
                        }
                        return
                    }
                    Utils.fetchDataWithCookiesAndUserAgent(from: URL(string: urlString)!) { data, response, error in
                        guard let data = data, error == nil else { return }
                        // always update the UI from the main thread
                        DispatchQueue.main.async() {
                            if UIImage(data: data) != nil {
                                bgImage.image = UIImage(data: data)!
                                ImageCache.shared.save(image: UIImage(data: data)!, forKey: urlString)
                            }
                        }
                    }
                }
            }
            
            let containerButton = UIView()
            privacyView.addSubview(containerButton)
            containerButton.anchor(left: privacyView.safeAreaLayoutGuide.leftAnchor, bottom: privacyView.safeAreaLayoutGuide.bottomAnchor, paddingLeft: 10, paddingBottom: 10, minHeight: 40)
            containerButton.rightAnchor.constraint(lessThanOrEqualTo: privacyView.safeAreaLayoutGuide.rightAnchor, constant: -10).isActive = true
            containerButton.isUserInteractionEnabled = true
            let tapgestureAgree = UITapGestureRecognizer(target: self, action: #selector(tappedOnAgreePrivacy(_ :)))
            tapgestureAgree.numberOfTapsRequired = 1
            containerButton.addGestureRecognizer(tapgestureAgree)
            
            let imageAgree = UIImageView()
            imageAgree.image = UIImage(systemName: "arrow.forward.circle")
            imageAgree.tintColor = .black
            containerButton.addSubview(imageAgree)
            imageAgree.anchor(left: containerButton.leftAnchor, centerY: containerButton.centerYAnchor, width: 40, height: 40)
            
            let titleAgree = UILabel()
            titleAgree.text = "Agree and Continue".localized()
            titleAgree.textColor = .black
            containerButton.addSubview(titleAgree)
            titleAgree.anchor(left: imageAgree.rightAnchor, right: containerButton.rightAnchor, paddingLeft: 5, centerY: containerButton.centerYAnchor)
            
            privacyWV.isOpaque = false
            privacyWV.backgroundColor = UIColor.clear
            privacyWV.scrollView.backgroundColor = UIColor.clear
            //print("URL: \(PrefsUtil.getURLPrivacyPolicy())")
            let lang: String = SecureUserDefaults.shared.value(forKey: "i18n_language") ?? "en"
            var urlPrivacyPolicy = PrefsUtil.getURLPrivacyPolicy()
            if lang == "id" {
                urlPrivacyPolicy = urlPrivacyPolicy.replacingOccurrences(of: "/en/", with: "/id/")
            }
            privacyWV.load(URLRequest(url: URL(string: urlPrivacyPolicy)!))
            privacyView.addSubview(privacyWV)
            privacyWV.navigationDelegate = self
            privacyWV.anchor(top: privacyView.safeAreaLayoutGuide.topAnchor, left: privacyView.leftAnchor, right: privacyView.rightAnchor, height: privacyView.bounds.height - 80)
            
        }
        privacyPolicyVC.modalPresentationStyle = .fullScreen
        privacyPolicyVC.modalTransitionStyle = .crossDissolve
        self.present(privacyPolicyVC, animated: true)
    }
    
    func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
        let js = "(function() { document.body.style.background='transparent'; })();"
        privacyWV.evaluateJavaScript(js) { (_, error) in
            //print(error as Any)
        }
    }
    
    func showWelocomeView() {
        if let viewWelcome = welcomeVC.view {
            viewWelcome.backgroundColor = self.traitCollection.userInterfaceStyle == .dark ? .black : .white
            Utils.addBackground(view: viewWelcome)
            let bgImage = UIImageView()
            viewWelcome.addSubview(bgImage)
            bgImage.anchor(top: viewWelcome.topAnchor, left: viewWelcome.leftAnchor, bottom: viewWelcome.bottomAnchor, right: viewWelcome.rightAnchor)
            DispatchQueue.global().async {
                DispatchQueue.main.async {
                    let listBg = PrefsUtil.getBackgroundLight().isEmpty && PrefsUtil.getBackgroundDark().isEmpty ? PrefsUtil.getBackground() :
                                        self.traitCollection.userInterfaceStyle == .dark ? PrefsUtil.getBackgroundDark() : PrefsUtil.getBackgroundLight()
                    if listBg.isEmpty {
                       return
                    }
                    var bgChoosen = ""
                    let arrayBg = listBg.split(separator: ",")
                    bgChoosen = String(arrayBg[Int.random(in: 0..<arrayBg.count)])
                    let urlString = PrefsUtil.getURLBase() + "get_file_from_path?img=" + bgChoosen
                    if let cachedImage = ImageCache.shared.image(forKey: urlString) {
                        DispatchQueue.main.async() {
                            bgImage.image = cachedImage
                        }
                        return
                    }
                    Utils.fetchDataWithCookiesAndUserAgent(from: URL(string: urlString)!) { data, response, error in
                        guard let data = data, error == nil else { return }
                        // always update the UI from the main thread
                        DispatchQueue.main.async() {
                            if UIImage(data: data) != nil {
                                bgImage.image = UIImage(data: data)!
                                ImageCache.shared.save(image: UIImage(data: data)!, forKey: urlString)
                            }
                        }
                    }
                }
            }
            let welcomeTitle = UILabel()
            welcomeTitle.text = "Welcome to".localized() + " " + (Bundle.main.displayName ?? "")
            welcomeTitle.font = .systemFont(ofSize: 25, weight: .bold)
            welcomeTitle.numberOfLines = 0
            viewWelcome.addSubview(welcomeTitle)
            welcomeTitle.anchor(top: viewWelcome.safeAreaLayoutGuide.topAnchor, left: viewWelcome.safeAreaLayoutGuide.leftAnchor, right: viewWelcome.safeAreaLayoutGuide.rightAnchor, paddingTop: 10, paddingLeft: 10, paddingRight: 10)
            
            let logoImage = UIImageView()
            logoImage.image = UIImage(named: getHighResolutionAppIconName() ?? "")
            viewWelcome.addSubview(logoImage)
            logoImage.anchor(centerX: viewWelcome.centerXAnchor, centerY: viewWelcome.centerYAnchor, width: 200, height: 200)
            
            let containerButton = UIView()
            viewWelcome.addSubview(containerButton)
            containerButton.anchor(left: viewWelcome.safeAreaLayoutGuide.leftAnchor, bottom: viewWelcome.safeAreaLayoutGuide.bottomAnchor, paddingLeft: 10, paddingBottom: 10, minHeight: 40)
            containerButton.rightAnchor.constraint(lessThanOrEqualTo: viewWelcome.safeAreaLayoutGuide.rightAnchor, constant: -10).isActive = true
            containerButton.isUserInteractionEnabled = true
            let tapgestureAgree = UITapGestureRecognizer(target: self, action: #selector(tappedOnAgree(_ :)))
            tapgestureAgree.numberOfTapsRequired = 1
            containerButton.addGestureRecognizer(tapgestureAgree)
            
            let imageAgree = UIImageView()
            imageAgree.image = UIImage(systemName: "arrow.forward.circle")
            imageAgree.tintColor = self.traitCollection.userInterfaceStyle == .dark ? UIColor.white: UIColor.black
            containerButton.addSubview(imageAgree)
            imageAgree.anchor(left: containerButton.leftAnchor, centerY: containerButton.centerYAnchor, width: 40, height: 40)
            
            let titleAgree = UILabel()
            titleAgree.text = "Agree and Continue".localized()
            titleAgree.textColor = self.traitCollection.userInterfaceStyle == .dark ? UIColor.white: UIColor.black
            containerButton.addSubview(titleAgree)
            titleAgree.anchor(left: imageAgree.rightAnchor, right: containerButton.rightAnchor, paddingLeft: 5, centerY: containerButton.centerYAnchor)
            
            let formattedText = String.format(strings: [term], inString: termText, color: self.traitCollection.userInterfaceStyle == .dark ? UIColor.white: UIColor.black)
            welcomeDesc.isUserInteractionEnabled = true
            welcomeDesc.attributedText = formattedText
            welcomeDesc.numberOfLines = 0
            viewWelcome.addSubview(welcomeDesc)
            welcomeDesc.anchor(left: viewWelcome.safeAreaLayoutGuide.leftAnchor, bottom: containerButton.topAnchor, right: viewWelcome.rightAnchor, paddingLeft: 10, paddingBottom: 10, paddingRight: 10)
            let tapgesture = UITapGestureRecognizer(target: self, action: #selector(tappedOnLabelTerms(_ :)))
            tapgesture.numberOfTapsRequired = 1
            welcomeDesc.addGestureRecognizer(tapgesture)
            
        }
        welcomeVC.modalPresentationStyle = .fullScreen
        welcomeVC.modalTransitionStyle = .crossDissolve
        self.present(welcomeVC, animated: true)
    }
    
    func getHighResolutionAppIconName() -> String? {
        guard let infoPlist = Bundle.main.infoDictionary else { return nil }
        guard let bundleIcons = infoPlist["CFBundleIcons"] as? NSDictionary else { return nil }
        guard let bundlePrimaryIcon = bundleIcons["CFBundlePrimaryIcon"] as? NSDictionary else { return nil }
        guard let bundleIconFiles = bundlePrimaryIcon["CFBundleIconFiles"] as? NSArray else { return nil }
        guard let appIcon = bundleIconFiles.lastObject as? String else { return nil }
        return appIcon
    }
    
    func showWebviewTerm() {
        termVC = UIViewController()
        if let viewTerm = termVC!.view {
            let webView = WKWebView()
            let lang: String = SecureUserDefaults.shared.value(forKey: "i18n_language") ?? "en"
            var urlTerm = "https://nexilis.io/newuniverse-tos"
            if lang == "id" {
                urlTerm = "https://nexilis.io/newuniverse-tos-id"
            }
            let url = URL (string: urlTerm)
            let requestObj = URLRequest(url: url!)
            webView.load(requestObj)
            viewTerm.addSubview(webView)
            webView.anchor(top: viewTerm.safeAreaLayoutGuide.topAnchor, left: viewTerm.safeAreaLayoutGuide.leftAnchor, bottom: viewTerm.safeAreaLayoutGuide.bottomAnchor, right: viewTerm.safeAreaLayoutGuide.rightAnchor)
        }
        let navigationController = CustomNavigationController(rootViewController: termVC!)
        navigationController.navigationBar.tintColor = .mainColor
        navigationController.navigationBar.barTintColor = .white
        navigationController.navigationBar.isTranslucent = false
        let textAttributes = [NSAttributedString.Key.foregroundColor:UIColor.mainColor]
        navigationController.navigationBar.titleTextAttributes = textAttributes
        termVC!.navigationItem.rightBarButtonItem = UIBarButtonItem(title: "Close".localized(), style: .plain, target: self, action: #selector(closeTerm))
        welcomeVC.present(navigationController, animated: true)
    }
    
    @objc func closeTerm() {
        termVC!.dismiss(animated: true)
    }
    
    @objc func tappedOnLabelTerms(_ gesture: UITapGestureRecognizer) {
        let termString = termText as NSString
        let termRange = termString.range(of: term)

        let tapLocation = gesture.location(in: welcomeDesc)
        let index = welcomeDesc.indexOfAttributedTextCharacterAtPoint(point: tapLocation)
            
        if checkRange(termRange, contain: index) == true {
            showWebviewTerm()
            return
        }

    }
    
    @objc func tappedOnAgree(_ gesture: UITapGestureRecognizer) {
        PrefsUtil.setTerms(value: true)
        welcomeVC.dismiss(animated: true)
    }
    
    @objc func tappedOnAgreePrivacy(_ gesture: UITapGestureRecognizer) {
        PrefsUtil.setAgreePrivacyPolicy(value: true)
        privacyPolicyVC.dismiss(animated: true)
    }
    
    func checkRange(_ range: NSRange, contain index: Int) -> Bool {
        return index > range.location && index < range.location + range.length
    }
    
    @objc func middleBtnTapped() {
        ViewController.expandButton()
    }



    public func show(b: Bool) {
        if(!b){
            if(ViewController.isExpandButton){
                ViewController.expandButton()
            }
        }
    }
    
    @objc func ccTap() {
        //print("ccTap")
        if(ViewController.checkIsChangePerson()){
            show(b: false)
            ViewController.def?.thirdTab?.webView?.evaluateJavaScript("{if(pauseAll){pauseAll();}}")
            ViewController.def?.firstTab?.webView?.evaluateJavaScript("{if(pauseAll){pauseAll();}}")
            if ViewController.listPullFB.count != 0 && ViewController.listPullFB.count > 2 {
                let package_id = ViewController.listPullFB[2].split(separator: "|")[0]
                var app_id = ""
                if package_id.contains("_fb") {
                    let listSplit = package_id.split(separator: "_", maxSplits: 1)
                    let numIdx = listSplit[listSplit.firstIndex(where: { $0.contains("fb") }) ?? 0]
                    let indexTap = Int(String(numIdx).substring(from: 2, to: numIdx.count))!
                    if listSplit.count == 2 {
                        app_id = String(listSplit[1])
                    }
                    if indexTap == 99 {
                        openTabPost()
                    } else {
                        Nexilis.buttonClicked(index: indexTap, id: app_id)
                    }
                } else {
                    if !app_id.isEmpty {
                        Nexilis.buttonClicked(index: 0, id: app_id)
                    }
                }
            } else {
                Nexilis.buttonClicked(index: 9)
            }
        }
    }
    
    @objc func streamTap() {
        //print("streamTap")
        if(ViewController.checkIsChangePerson()){
            show(b: false)
            ViewController.def?.thirdTab?.webView?.evaluateJavaScript("{if(pauseAll){pauseAll();}}")
            ViewController.def?.firstTab?.webView?.evaluateJavaScript("{if(pauseAll){pauseAll();}}")
            if ViewController.listPullFB.count != 0 && ViewController.listPullFB.count > 4 {
                let package_id = ViewController.listPullFB[4].split(separator: "|")[0]
                var app_id = ""
                if package_id.contains("_fb") {
                    let listSplit = package_id.split(separator: "_", maxSplits: 1)
                    let numIdx = listSplit[listSplit.firstIndex(where: { $0.contains("fb") }) ?? 0]
                    let indexTap = Int(String(numIdx).substring(from: 2, to: numIdx.count))!
                    if listSplit.count == 2 {
                        app_id = String(listSplit[1])
                    }
                    if indexTap == 99 {
                        openTabPost()
                    } else {
                        Nexilis.buttonClicked(index: indexTap, id: app_id)
                    }
                } else {
                    if !app_id.isEmpty {
                        Nexilis.buttonClicked(index: 0, id: app_id)
                    }
                }
            } else {
                Nexilis.buttonClicked(index: 8)
            }
        }
    }
    
    @objc func callTap() {
        //print("callTap")
        if(ViewController.checkIsChangePerson()){
            show(b: false)
            ViewController.def?.thirdTab?.webView?.evaluateJavaScript("{if(pauseAll){pauseAll();}}")
            ViewController.def?.firstTab?.webView?.evaluateJavaScript("{if(pauseAll){pauseAll();}}")
            if ViewController.listPullFB.count != 0 && ViewController.listPullFB.count > 1 {
                let package_id = ViewController.listPullFB[1].split(separator: "|")[0]
                var app_id = ""
                if package_id.contains("_fb") {
                    let listSplit = package_id.split(separator: "_", maxSplits: 1)
                    let numIdx = listSplit[listSplit.firstIndex(where: { $0.contains("fb") }) ?? 0]
                    let indexTap = Int(String(numIdx).substring(from: 2, to: numIdx.count))!
                    if listSplit.count == 2 {
                        app_id = String(listSplit[1])
                    }
                    if indexTap == 99 {
                        openTabPost()
                    } else {
                        Nexilis.buttonClicked(index: indexTap, id: app_id)
                    }
                } else {
                    if !app_id.isEmpty {
                        Nexilis.buttonClicked(index: 0, id: app_id)
                    }
                }
            } else {
                Nexilis.buttonClicked(index: 7)
            }
        }
    }
    
    @objc func chatTap() {
        //print("chatTap")
//        APIS.openWhiteboard()
//        return
        if(ViewController.checkIsChangePerson()){
            show(b: false)
            ViewController.def?.thirdTab?.webView?.evaluateJavaScript("{if(pauseAll){pauseAll();}}")
            ViewController.def?.firstTab?.webView?.evaluateJavaScript("{if(pauseAll){pauseAll();}}")
            if ViewController.listPullFB.count != 0 && ViewController.listPullFB.count > 0 {
                let package_id = ViewController.listPullFB[0].split(separator: "|")[0]
                var app_id = ""
                if package_id.contains("_fb") {
                    let listSplit = package_id.split(separator: "_", maxSplits: 1)
                    let numIdx = listSplit[listSplit.firstIndex(where: { $0.contains("fb") }) ?? 0]
                    let indexTap = Int(String(numIdx).substring(from: 2, to: numIdx.count))!
                    if listSplit.count == 2 {
                        app_id = String(listSplit[1])
                    }
                    if indexTap == 99 {
                        openTabPost()
                    } else {
                        Nexilis.buttonClicked(index: indexTap, id: app_id)
                    }
                } else {
                    if !app_id.isEmpty {
                        Nexilis.buttonClicked(index: 0, id: app_id)
                    }
                }
            } else {
                Nexilis.buttonClicked(index: 6)
            }
        }
    }
    
    @objc func postTap() {
        if(ViewController.checkIsChangePerson()){
            show(b: false)
            ViewController.def?.thirdTab?.webView?.evaluateJavaScript("{if(pauseAll){pauseAll();}}")
            ViewController.def?.firstTab?.webView?.evaluateJavaScript("{if(pauseAll){pauseAll();}}")
            if ViewController.listPullFB.count != 0 && ViewController.listPullFB.count > 3 {
                let package_id = ViewController.listPullFB[3].split(separator: "|")[0]
                var app_id = ""
                if package_id.contains("_fb") {
                    let listSplit = package_id.split(separator: "_", maxSplits: 1)
                    let numIdx = listSplit[listSplit.firstIndex(where: { $0.contains("fb") }) ?? 0]
                    let indexTap = Int(String(numIdx).substring(from: 2, to: numIdx.count))!
                    if listSplit.count == 2 {
                        app_id = String(listSplit[1])
                    }
                    if indexTap == 99 {
                        openTabPost()
                    } else {
                        Nexilis.buttonClicked(index: indexTap, id: app_id)
                    }
                } else {
                    if !app_id.isEmpty {
                        Nexilis.buttonClicked(index: 0, id: app_id)
                    }
                }
            } else {
                openTabPost()
            }
        }
        
    }
    
    func openTabPost() {
        let customTab = PrefsUtil.getCustomTab().split(separator: ",")
        let cpaasMode = PrefsUtil.getCpaasMode()
        var i = 0
        var j = 0
        //print("custom tab post tap = \(customTab)")
        while j < customTab.count {
            if(((i == 1 && customTab.count == 3) || i == 2) &&
               (cpaasMode == PrefsUtil.CPAAS_MODE_DOCKED || cpaasMode == PrefsUtil.CPAAS_MODE_MIX)){
                
            }
            else {
                if customTab[j] == "3" {
                    break
                }
                j += 1
            }
            i += 1
        }
        if(j < customTab.count){
            self.selectedIndex = i
            
            DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + .seconds(1), execute: {
                let me = User.getMyPin()
                let address = "\(PrefsUtil.getURLBase())nexilis/pages/tab5-new-post?f_pin=\(me ?? "")"
                self.thirdTab?.webView.evaluateJavaScript("{window.localStorage.setItem('currentTab','\(ViewController.tab3)')}")
                self.thirdTab?.webView.evaluateJavaScript("window.location = '\(address)'")
                
            })
        }
    }
    
    static func pullActionButton() {
        if datePullFB == nil || Int(Date().timeIntervalSince(datePullFB!)) >= 60 {
            datePullFB = Date()
            DispatchQueue.global().async {
                if !PrefsUtil.getCustomButtons().isEmpty {
                    DispatchQueue.main.async { [self] in
                        let customButtons = PrefsUtil.getCustomButtons().components(separatedBy: ",")
                        var customIcons = PrefsUtil.getCustomFBIcon().components(separatedBy: ",")
                        if Utils.getIsLoadThemeFromOther() {
                            customIcons = Utils.getButtonIcon().components(separatedBy: ",")
                        }
                        for i in 0..<customButtons.count {
                            let package_id = customButtons[i]
                            let app_id = ""
                            let icon = customIcons[i]
                            listPullFB.append("\(package_id)|\(app_id)")
                            DispatchQueue.global().async {
                                let urlString = PrefsUtil.getURLBase() + "get_file_from_path?img=\(icon)"
                                if let cachedImage = ImageCache.shared.image(forKey: urlString) {
                                    if i == 0 {
                                        ViewController.chatButton.setBackgroundImage(cachedImage, for: .normal)
                                    } else if i == 1 {
                                        ViewController.callButton.setBackgroundImage(cachedImage, for: .normal)
                                    }  else if i == 2 {
                                        ViewController.ccButton.setBackgroundImage(cachedImage, for: .normal)
                                    }  else if i == 3 {
                                        ViewController.postButton.setBackgroundImage(cachedImage, for: .normal)
                                    }  else if i == 4 {
                                        ViewController.streamingButton.setBackgroundImage(cachedImage, for: .normal)
                                    }
                                    return
                                }
                                Utils.fetchDataWithCookiesAndUserAgent(from: URL(string: urlString)!) { data, response, error in
                                    guard let data = data, error == nil else { return }
                                    // always update the UI from the main thread
                                    DispatchQueue.main.async() {
                                        if UIImage(data: data) != nil {
                                            if i == 0 {
                                                ViewController.chatButton.setBackgroundImage(UIImage(data: data), for: .normal)
                                            } else if i == 1 {
                                                ViewController.callButton.setBackgroundImage(UIImage(data: data), for: .normal)
                                            }  else if i == 2 {
                                                ViewController.ccButton.setBackgroundImage(UIImage(data: data), for: .normal)
                                            }  else if i == 3 {
                                                ViewController.postButton.setBackgroundImage(UIImage(data: data), for: .normal)
                                            }  else if i == 4 {
                                                ViewController.streamingButton.setBackgroundImage(UIImage(data: data), for: .normal)
                                            }
                                            ImageCache.shared.save(image: UIImage(data: data)!, forKey: urlString)
                                        }
                                    }
                                }
                            }
                        }
                    }
                    return
                }
                while Nexilis.isProcessWriteSync {
                    Thread.sleep(forTimeInterval: 0.5)
                }
                if let response = Nexilis.writeSync(message: CoreMessage_TMessageBank.pullFloatingButton(), timeout: 30 * 1000) {
                    if response.isOk() {
                        let data = response.getBody(key: CoreMessage_TMessageKey.DATA, default_value: "")
                        if !data.isEmpty {
                            if let jsonArray = try! JSONSerialization.jsonObject(with: data.data(using: String.Encoding.utf8)!, options: JSONSerialization.ReadingOptions()) as? [AnyObject] {
                                DispatchQueue.main.async { [self] in
                                    listPullFB.removeAll()
                                    if jsonArray.count != 0 {
                                        var count = 0
                                        for json in jsonArray {
                                            let package_id = json["package_act"] as! String
                                            let app_id = (json["app_id"] as? String) ?? ""
                                            let icon = (json["icon"] as? String) ?? ""
                                            listPullFB.append("\(package_id)|\(app_id)")
                                            let urlString = "https://nexilis.io/get_file?account=\(Nexilis.sAPIKey)&image=\(icon)"
                                            if count == 0 {
                                                if !icon.isEmpty {
                                                    DispatchQueue.global().async {
                                                        if let cachedImage = ImageCache.shared.image(forKey: urlString) {
                                                            DispatchQueue.main.async() {
                                                                ViewController.chatButton.setBackgroundImage(cachedImage, for: .normal)
                                                            }
                                                            return
                                                        }
                                                        Utils.fetchDataWithCookiesAndUserAgent(from: URL(string: urlString)!) { data, response, error in
                                                            guard let data = data, error == nil else { return }
                                                            // always update the UI from the main thread
                                                            DispatchQueue.main.async() {
                                                                if UIImage(data: data) != nil {
                                                                    ViewController.chatButton.setBackgroundImage(UIImage(data: data), for: .normal)
                                                                    ImageCache.shared.save(image: UIImage(data: data)!, forKey: urlString)
                                                                }
                                                            }
                                                        }
                                                    }
                                                } else {
                                                    ViewController.chatButton.setBackgroundImage(UIImage(named: "pb_button_chat", in: Bundle.resourceBundle(for: Nexilis.self), with: nil)!.withRenderingMode(.alwaysOriginal), for: .normal)
                                                }
                                            } else if count == 1 {
                                                if !icon.isEmpty {
                                                    DispatchQueue.global().async {
                                                        if let cachedImage = ImageCache.shared.image(forKey: urlString) {
                                                            DispatchQueue.main.async() {
                                                                ViewController.callButton.setBackgroundImage(cachedImage, for: .normal)
                                                            }
                                                            return
                                                        }
                                                        Utils.fetchDataWithCookiesAndUserAgent(from: URL(string: urlString)!) { data, response, error in
                                                            guard let data = data, error == nil else { return }
                                                            // always update the UI from the main thread
                                                            DispatchQueue.main.async() {
                                                                if UIImage(data: data) != nil {
                                                                    ViewController.callButton.setBackgroundImage(UIImage(data: data), for: .normal)
                                                                    ImageCache.shared.save(image: UIImage(data: data)!, forKey: urlString)
                                                                }
                                                            }
                                                        }
                                                    }
                                                } else {
                                                    ViewController.callButton.setBackgroundImage(UIImage(named: "pb_button_call", in: Bundle.resourceBundle(for: Nexilis.self), with: nil)!.withRenderingMode(.alwaysOriginal), for: .normal)
                                                }
                                            } else if count == 2 {
                                                if !icon.isEmpty {
                                                    DispatchQueue.global().async {
                                                        if let cachedImage = ImageCache.shared.image(forKey: urlString) {
                                                            DispatchQueue.main.async() {
                                                                ViewController.ccButton.setBackgroundImage(cachedImage, for: .normal)
                                                            }
                                                            return
                                                        }
                                                        Utils.fetchDataWithCookiesAndUserAgent(from: URL(string: urlString)!) { data, response, error in
                                                            guard let data = data, error == nil else { return }
                                                            // always update the UI from the main thread
                                                            DispatchQueue.main.async() {
                                                                if UIImage(data: data) != nil {
                                                                    ViewController.ccButton.setBackgroundImage(UIImage(data: data), for: .normal)
                                                                    ImageCache.shared.save(image: UIImage(data: data)!, forKey: urlString)
                                                                }
                                                            }
                                                        }
                                                    }
                                                } else {
                                                    ViewController.ccButton.setBackgroundImage(UIImage(named: "pb_button_cc", in: Bundle.resourceBundle(for: Nexilis.self), with: nil)!.withRenderingMode(.alwaysOriginal), for: .normal)
                                                }
                                            } else if count == 3 {
                                                if !icon.isEmpty {
                                                    DispatchQueue.global().async {
                                                        if let cachedImage = ImageCache.shared.image(forKey: urlString) {
                                                            DispatchQueue.main.async() {
                                                                ViewController.postButton.setBackgroundImage(cachedImage, for: .normal)
                                                            }
                                                            return
                                                        }
                                                        Utils.fetchDataWithCookiesAndUserAgent(from: URL(string: urlString)!) { data, response, error in
                                                            guard let data = data, error == nil else { return }
                                                            // always update the UI from the main thread
                                                            DispatchQueue.main.async() {
                                                                if UIImage(data: data) != nil {
                                                                    ViewController.postButton.setBackgroundImage(UIImage(data: data), for: .normal)
                                                                    ImageCache.shared.save(image: UIImage(data: data)!, forKey: urlString)
                                                                }
                                                            }
                                                        }
                                                    }
                                                } else {
                                                    ViewController.postButton.setBackgroundImage(UIImage(named: "pb_button_post", in: Bundle.resourceBundle(for: Nexilis.self), with: nil)!.withRenderingMode(.alwaysOriginal), for: .normal)
                                                }
                                            } else if count == 4 {
                                                if !icon.isEmpty {
                                                    DispatchQueue.global().async {
                                                        if let cachedImage = ImageCache.shared.image(forKey: urlString) {
                                                            DispatchQueue.main.async() {
                                                                ViewController.streamingButton.setBackgroundImage(cachedImage, for: .normal)
                                                            }
                                                            return
                                                        }
                                                        Utils.fetchDataWithCookiesAndUserAgent(from: URL(string: urlString)!) { data, response, error in
                                                            guard let data = data, error == nil else { return }
                                                            // always update the UI from the main thread
                                                            DispatchQueue.main.async() {
                                                                if UIImage(data: data) != nil {
                                                                    ViewController.streamingButton.setBackgroundImage(UIImage(data: data), for: .normal)
                                                                    ImageCache.shared.save(image: UIImage(data: data)!, forKey: urlString)
                                                                }
                                                            }
                                                        }
                                                    }
                                                } else {
                                                    ViewController.streamingButton.setBackgroundImage(UIImage(named: "pb_button_stream", in: Bundle.resourceBundle(for: Nexilis.self), with: nil)!.withRenderingMode(.alwaysOriginal), for: .normal)
                                                }
                                            }
                                            count += 1
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    public static func showDockedButton() {
        ViewController.chatButton.isHidden = false
        ViewController.callButton.isHidden = false
        ViewController.ccButton.isHidden = false
        ViewController.streamingButton.isHidden = false
        ViewController.postButton.isHidden = false
    }
    
    public static func hideDockedButton() {
        ViewController.chatButton.isHidden = true
        ViewController.callButton.isHidden = true
        ViewController.ccButton.isHidden = true
        ViewController.streamingButton.isHidden = true
        ViewController.postButton.isHidden = true
    }
    
    public static func expandButton() {
        let cpaasMode = PrefsUtil.getCpaasMode()
        if cpaasMode != PrefsUtil.CPAAS_MODE_DOCKED && cpaasMode != PrefsUtil.CPAAS_MODE_MIX {
            return
        }
        if ViewController.alwaysHideButton && !ViewController.isExpandButton {
            return
        }
        var minYIpX: CGFloat = 0
        let iPhoneModel = getiPhoneModel()
        if iPhoneModel == "iPhone X or newer" {
            minYIpX += 20
        }
        if ViewController.isExpandButton {
            ViewController.isExpandButton = false
            let xChatPosition = ViewController.chatButton.frame.origin.x + 90
            let yChatPosition = ViewController.chatButton.frame.origin.y + 20

            let xCallPosition = ViewController.callButton.frame.origin.x + 55
            let yCallPosition = ViewController.callButton.frame.origin.y + 70

            let xCCPosition = ViewController.ccButton.frame.origin.x
            let yCCPosition = ViewController.ccButton.frame.origin.y + 90

            let xPostPosition = ViewController.postButton.frame.origin.x - 55
            let yPostPosition = ViewController.postButton.frame.origin.y + 70

            let xStreamingPosition = ViewController.streamingButton.frame.origin.x - 90
            let yStreamingPosition = ViewController.streamingButton.frame.origin.y + 20
            UIView.animate(withDuration: 0.5, animations: {
//                if !ViewController.isBlue {
//                    ViewController.middleButton.transform = CGAffineTransform(rotationAngle: 0)
//                }
                ViewController.chatButton.frame.origin = CGPoint(x: xChatPosition, y: yChatPosition + minYIpX)
                ViewController.callButton.frame.origin = CGPoint(x: xCallPosition, y: yCallPosition + minYIpX)
                ViewController.ccButton.frame.origin = CGPoint(x: xCCPosition, y: yCCPosition + minYIpX)
                ViewController.streamingButton.frame.origin = CGPoint(x: xStreamingPosition, y: yStreamingPosition + minYIpX)
                ViewController.postButton.frame.origin = CGPoint(x: xPostPosition, y: yPostPosition + minYIpX)
            })
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5, execute: {
                if !ViewController.isExpandButton {
                    ViewController.hideDockedButton()
                }
            })
        } else {
            ViewController.isExpandButton = true
            ViewController.showDockedButton()
            let xChatPosition = ViewController.chatButton.frame.origin.x - 90
            let yChatPosition = ViewController.chatButton.frame.origin.y - 20

            let xCallPosition = ViewController.callButton.frame.origin.x - 55
            let yCallPosition = ViewController.callButton.frame.origin.y - 70

            let xCCPosition = ViewController.ccButton.frame.origin.x
            let yCCPosition = ViewController.ccButton.frame.origin.y - 90

            let xPostPosition = ViewController.postButton.frame.origin.x + 55
            let yPostPosition = ViewController.postButton.frame.origin.y - 70

            let xStreamingPosition = ViewController.streamingButton.frame.origin.x + 90
            let yStreamingPosition = ViewController.streamingButton.frame.origin.y - 20
            UIView.animate(withDuration: 0.5, animations: {
//                if !ViewController.isBlue{
//                    ViewController.middleButton.transform = CGAffineTransform(rotationAngle: .pi / 2)
//                }
                ViewController.chatButton.frame.origin = CGPoint(x: xChatPosition, y: yChatPosition - minYIpX)
                ViewController.callButton.frame.origin = CGPoint(x: xCallPosition, y: yCallPosition - minYIpX)
                ViewController.ccButton.frame.origin = CGPoint(x: xCCPosition, y: yCCPosition - minYIpX)
                ViewController.streamingButton.frame.origin = CGPoint(x: xStreamingPosition, y: yStreamingPosition - minYIpX)
                ViewController.postButton.frame.origin = CGPoint(x: xPostPosition, y: yPostPosition - minYIpX)
            })
        }
    }
    
    public static func removeMiddleButton() {
//        ViewController.chatButton.removeFromSuperview()
//        ViewController.callButton.removeFromSuperview()
//        ViewController.ccButton.removeFromSuperview()
//        ViewController.streamingButton.removeFromSuperview()
//        ViewController.postButton.removeFromSuperview()
        ViewController.middleButton.isHidden = true
    }

}

class EmptyTabViewController: UIViewController {
    override func viewDidLoad() {
        
    }
}
                
extension Bundle {
    // Name of the app - title under the icon.
    var displayName: String? {
            return object(forInfoDictionaryKey: "CFBundleDisplayName") as? String ??
                object(forInfoDictionaryKey: "CFBundleName") as? String
    }
}

extension BinaryInteger {
    var degreesToRadians: CGFloat { CGFloat(self) * .pi / 180 }
}

extension FloatingPoint {
    var degreesToRadians: Self { self * .pi / 180 }
    var radiansToDegrees: Self { self * 180 / .pi }
}

extension UIImage {
    class func imageWithColor(color: UIColor, size: CGSize) -> UIImage {
        let rect: CGRect = CGRect(x: 0, y: 0, width: size.width, height: size.height)
        UIGraphicsBeginImageContextWithOptions(size, false, 0)
        color.setFill()
        UIRectFill(rect)
        let image: UIImage = UIGraphicsGetImageFromCurrentImageContext()!
        UIGraphicsEndImageContext()
        return image
    }
}

extension String {
    static func format(strings: [String],
                    italicFont: UIFont = UIFont.italicSystemFont(ofSize: 12),
                    italicColor: UIColor = UIColor.systemGreen,
                    inString string: String,
                    font: UIFont = UIFont.systemFont(ofSize: 12),
                    color: UIColor = UIColor.black) -> NSAttributedString {
        let attributedString =
            NSMutableAttributedString(string: string,
                                    attributes: [
                                        NSAttributedString.Key.font: font,
                                        NSAttributedString.Key.foregroundColor: color])
        let italicFontAttribute = [NSAttributedString.Key.font: italicFont, NSAttributedString.Key.foregroundColor: italicColor]
        for italic in strings {
            attributedString.addAttributes(italicFontAttribute, range: (string as NSString).range(of: italic))
        }
        return attributedString
    }
}

extension UILabel {
    func indexOfAttributedTextCharacterAtPoint(point: CGPoint) -> Int {
        assert(self.attributedText != nil, "This method is developed for attributed string")
        let textStorage = NSTextStorage(attributedString: self.attributedText!)
        let layoutManager = NSLayoutManager()
        textStorage.addLayoutManager(layoutManager)
        let textContainer = NSTextContainer(size: self.frame.size)
        textContainer.lineFragmentPadding = 0
        textContainer.maximumNumberOfLines = self.numberOfLines
        textContainer.lineBreakMode = self.lineBreakMode
        layoutManager.addTextContainer(textContainer)

        let index = layoutManager.characterIndex(for: point, in: textContainer, fractionOfDistanceBetweenInsertionPoints: nil)
        return index
    }
}