neiyout_ios/class/Transport/VPNHelper.swift

//
//  VPNHelper.swift
//  SwiftV2Ray
//
//  Created by David.Dai on 2019/12/27.
//  Copyright © 2019 david. All rights reserved.
//

import Foundation
import NetworkExtension

let kProxyServiceVPNStatusNotification = "kProxyServiceVPNStatusNotification"

enum VPNStatus {
    case off
    case connecting
    case on
    case disconnecting
}


public enum VPNSTATUS {
    case connecting
    case connectd
    case close
}


class VPNHelper {
    static let `shared` = VPNHelper()
    var manager: NETunnelProviderManager? = nil
    private var openVPNClosure: ((_ error: Error?) -> Void)? = nil
    private var openStatusVPN: ((_ status: VPNSTATUS?) -> Void)? = nil
    private var closeVPNClosure: (() -> Void)? = nil
    
    var observerAdded: Bool = false
    
    fileprivate(set) var vpnStatus = VPNStatus.off {
        didSet {
            NotificationCenter.default.post(name: Notification.Name(rawValue: kProxyServiceVPNStatusNotification), object: nil)
        }
    }
    
    deinit {
        NotificationCenter.default.removeObserver(self)
    }
    
    
    init() {
        loadProviderManager{
            guard let manager = $0 else{return}
            self.updateVPNStatus(manager)
            self.manager = manager
        }
        addVPNStatusObserver()
    }
    
    func addVPNStatusObserver() {
        guard !observerAdded else{
            return
        }
        loadProviderManager { [unowned self] (manager) -> Void in
            if let manager = manager {
                self.observerAdded = true
                NotificationCenter.default.addObserver(forName: NSNotification.Name.NEVPNStatusDidChange, object: manager.connection, queue: OperationQueue.main, using: { [unowned self] (notification) -> Void in
                    self.updateVPNStatus(manager)
                    })
            }
        }
    }
    

    func updateVPNStatus(_ manager: NEVPNManager) {
            switch manager.connection.status {
            case .connected:
                self.vpnStatus = .on
            case .connecting, .reasserting:
                self.vpnStatus = .connecting
            case .disconnecting:
                self.vpnStatus = .disconnecting
            case .disconnected, .invalid:
                self.vpnStatus = .off
            @unknown default: break
                
            }
            print(self.vpnStatus)
    }
    
    
 
    func open(with message: PacketTunnelMessage, completion: @escaping((_ error: Error?) -> Void)) {
//        guard openVPNClosure == nil else {
//            completion(NSError(domain: "VPNHelper", code: -1, userInfo: ["error" : "正在处理中"]))
//            return
//        }
//
////        guard openStatusVPN == nil else {
////            completion(NSError(domain: "VPNHelper", code: -1, userInfo: ["error" : "正在处理中"]))
////            return
////        }
//
//
//        self.openVPNClosure = completion
        
        let fetchClosure = {[weak self] (manager: NETunnelProviderManager?, error: Error?) in
            var openError = error
            guard let manager = manager else {
                completion(openError)
                return
            }
            if self?.manager == nil {
                self?.updateVPNStatus(manager)
                self?.addVPNStatusObserver()
            }
          
            
            guard manager.connection.status != .connected else {
                completion(nil)
                self?.openVPNClosure = nil
                self?.openStatusVPN = nil
                return
            }
            
            PacketTunnelMessage.messageTo(manager.connection as? NETunnelProviderSession, message) { (error, response) in
                guard error == nil else {
                    completion(error)
                    self?.stopObservingStatus(manager)
                    return
                }
          
                //self?.observeStatus(manager)
                do {
                    try manager.connection.startVPNTunnel(options: [:])
                } catch let starError {
                    NSLog(starError.localizedDescription)
                    openError = starError
                }
                
                guard openError == nil else {
                    completion(openError)
                    self?.stopObservingStatus(manager)
                    return
                }
                
                
                if self?.manager == nil {
                    
                    self?.manager = manager
                }
                
            }
        }
        
      
        
        // 获取VPN配置
        NETunnelProviderManager.loadAllFromPreferences { (managers, error) in
            guard let vpnManagers = managers else {
                fetchClosure(nil, error)
                return
            }

            if vpnManagers.count > 0 {
                vpnManagers[0].isEnabled = true
                vpnManagers[0].saveToPreferences(completionHandler: { (error) in
                    if error != nil {
                        fetchClosure(nil, error)
                        return
                    }

                    vpnManagers[0].loadFromPreferences(completionHandler: { (error) in
                        fetchClosure(vpnManagers[0], error)
                    })
                })
                return
            }

            let manager = NETunnelProviderManager()
            manager.protocolConfiguration = NETunnelProviderProtocol()
            manager.protocolConfiguration?.serverAddress = "127.0.0.1"
            manager.localizedDescription = "Naiyou"
            manager.isEnabled = true
            manager.saveToPreferences(completionHandler: { (error) in
                if error != nil {
                    fetchClosure(nil, error)
                    return
                }

                manager.loadFromPreferences(completionHandler: { (error) in
                    fetchClosure(manager, error)
                })
            })
        }
    }
    
    func close(completion: @escaping(() -> Void)) {
//        guard self.closeVPNClosure == nil else {
//            completion()
//            return
//        }
        
        guard let manager = self.manager else {
            completion()
            return
        }
        
        self.closeVPNClosure = completion
        manager.connection.stopVPNTunnel()
        //self.stopObservingStatus(manager)
    }
    
    private func observeStatus(_ manager: NETunnelProviderManager) {
        NotificationCenter.default.removeObserver(self, name: NSNotification.Name.NEVPNStatusDidChange, object: manager.connection)
        NotificationCenter.default.addObserver(forName: NSNotification.Name.NEVPNStatusDidChange, object: manager.connection, queue: OperationQueue.main,using: {
            [weak self] notification in
            let connection = notification.object as? NEVPNConnection
            switch connection?.status {
                case .none:
                    print("无")
                
                case .some(.invalid):
                    print("无效")
                    self?.openVPNClosure?(NSError(domain: "VPNHelper", code: (connection?.status)!.rawValue, userInfo: ["error" : "连接无效"]))
                    self?.openVPNClosure = nil
                    self?.closeVPNClosure?()
                    self?.closeVPNClosure = nil
                    self?.openStatusVPN?(VPNSTATUS.close)
                    //self?.openStatusVPN = nil
                    self?.vpnStatus = .off
                
                case .some(.connecting):
                    print("VPN通道连接中")
                    self?.openStatusVPN?(VPNSTATUS.connecting)
                    //self?.openStatusVPN = nil
                    self?.vpnStatus = .connecting
                case .some(.connected):
                    print("VPN通道连接上了")
                    self?.openVPNClosure?(nil)
                    self?.openVPNClosure = nil
                    self?.openStatusVPN?(VPNSTATUS.connectd)
                    self?.openStatusVPN = nil
                    self?.vpnStatus = .on
                
                case .some(.reasserting):
                    print("断言")
                    self?.openVPNClosure?(NSError(domain: "VPNHelper", code: (connection?.status)!.rawValue, userInfo: ["error" : "断言"]))
                    self?.openVPNClosure = nil
                    self?.closeVPNClosure?()
                    self?.closeVPNClosure = nil
                    self?.openStatusVPN?(VPNSTATUS.close)
                    self?.openStatusVPN = nil
                    self?.vpnStatus = .off
                    
                case .some(.disconnecting):
                    print("VPN通道断开连接中")
                    self?.openVPNClosure?(NSError(domain: "VPNHelper", code: (connection?.status)!.rawValue, userInfo: ["error" : "断开连接"]))
                    self?.openVPNClosure = nil
                    self?.openStatusVPN?(VPNSTATUS.close)
                    //self?.openStatusVPN = nil
                    self?.vpnStatus = .disconnecting
                
                case .some(_):
                    print("其他")
                    self?.openVPNClosure?(NSError(domain: "VPNHelper", code: (connection?.status)!.rawValue, userInfo: ["error" : "其他"]))
                    self?.openVPNClosure = nil
                    self?.openStatusVPN?(VPNSTATUS.close)
                    self?.vpnStatus = .off
                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.15) {
                        self?.closeVPNClosure?()
                        self?.closeVPNClosure = nil
                        self?.openStatusVPN?(VPNSTATUS.close)
                        self?.openStatusVPN = nil
                        self?.vpnStatus = .off
                    }
            }
        })
    }

    private func stopObservingStatus(_ manager: NETunnelProviderManager) {
        NotificationCenter.default.removeObserver(self, name: NSNotification.Name.NEVPNStatusDidChange, object: manager.connection)
    }
}
// load VPN Profiles
extension VPNHelper{

   
    func loadProviderManager(_ complete: @escaping (NETunnelProviderManager?) -> Void){
        NETunnelProviderManager.loadAllFromPreferences { (managers, error) in
            if let managers = managers {
                if managers.count > 0 {
                    let manager = managers[0]
                    complete(manager)
                    return
                }
            }
            complete(nil)
        }
    }
    
    
    func delDupConfig(_ arrays:[NETunnelProviderManager]){
        if (arrays.count)>1{
            for i in 0 ..< arrays.count{
                print("Del DUP Profiles")
                arrays[i].removeFromPreferences(completionHandler: { (error) in
                    if(error != nil){print(error.debugDescription)}
                })
            }
        }
    }
}