platform-ios/RainbowPlanet/RainbowPlanet/Service/SwiftMoyaService/SwiftMoyaServiceManger/SwiftMoyaNetWorkManager/SwiftMoyaNetWorkManager.swift

//
//  SwiftMoyaNetWorkManager.swift
//  RainbowPlanet
//
//  Created by 南鑫林 on 2018/8/7.
//  Copyright © 2018年 南鑫林. All rights reserved.
//

import Foundation
import Alamofire
import Moya
import SwiftyJSON
import ObjectMapper
import RxSwift
import RxCocoa
import Result

/// 超时时长
private var requestTimeOut:Double = 10

///网络请求的基本设置,这里可以拿到是具体的哪个网络请求，可以在这里做一些设置
private let myEndpointClosure = { (target: MultiTarget) -> Endpoint in
    ///这里把endpoint重新构造一遍主要为了解决网络请求地址里面含有? 时无法解析的bug https://github.com/Moya/Moya/issues/1198
    let url = target.baseURL.absoluteString + target.path
    var task = target.task
    /*
     👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆
     如果需要在每个请求中都添加类似token参数的参数请取消注释上面代码
     */
    var endpoint = Endpoint(
        url: url,
        sampleResponseClosure: { .networkResponse(200, target.sampleData) },
        method: target.method,
        task: task,
        httpHeaderFields: target.headers
    )
    requestTimeOut = 10//每次请求都会调用endpointClosure 到这里设置超时时长 也可单独每个接口设置
    
    return endpoint
}

///网络请求的设置
private let requestClosure = { (endpoint: Endpoint, done: MoyaProvider.RequestResultClosure) in
    do {
        var request = try endpoint.urlRequest()
        //设置请求时长
        request.timeoutInterval = requestTimeOut
        // 打印请求参数
        if let requestData = request.httpBody {
            let parameter = "\(String(data: request.httpBody!, encoding: String.Encoding.utf8) ?? "")"
            NXLLog("\n"+"请求地址:"+"\(request.url!)"+"\n"+"请求方式:"+"\(request.httpMethod ?? "")"+"\n"+"请求头部:"+"\(String(describing: request.allHTTPHeaderFields!))"+"\n"+"发送参数:" + String(describing: parameter.removingPercentEncoding!))
        }else{
            let urlStr = "\(request.url!)"
            NXLLog("\n"+"请求地址:"+String(describing: urlStr.removingPercentEncoding!)+"\n"+"请求方式:"+"=\(String(describing: request.httpMethod!))"+"\n"+"请求头部:"+"\(String(describing: request.allHTTPHeaderFields!))")
        }
        done(.success(request))
    } catch {
        done(.failure(MoyaError.underlying(error, nil)))
    }
}

/// NetworkActivityPlugin插件用来监听网络请求，界面上做相应的展示
///但这里我没怎么用这个。。。 loading的逻辑直接放在网络处理里面了
private let networkPlugin = NetworkActivityPlugin.init { (changeType, targetType) in
    print("networkPlugin \(changeType)")
    //targetType 是当前请求的基本信息
    switch(changeType){
    case .began:
        DispatchQueue.main.async(execute: { () -> Void in
            UIApplication.shared.isNetworkActivityIndicatorVisible = true
        })
    case .ended:
        DispatchQueue.main.async(execute: { () -> Void in
            UIApplication.shared.isNetworkActivityIndicatorVisible = false
        })
    }
    
}


private let provider = MoyaProvider<MultiTarget>(endpointClosure: myEndpointClosure, requestClosure: requestClosure, plugins: [networkPlugin], trackInflights: false)

/// 基于Alamofire,网络是否连接，，这个方法不建议放到这个类中,可以放在全局的工具类中判断网络链接情况
/// 用get方法是因为这样才会在获取isNetworkConnect时实时判断网络链接请求，如有更好的方法可以fork
private var isNetworkConnect: Bool {
    get{
        let network = NetworkReachabilityManager()
        return network?.isReachable ?? true //无返回就默认网络已连接
    }
}


public class SwiftMoyaNetWorkManager: NSObject {

    private let disposeBag = DisposeBag()
    private var dataBaseName : String = "RainbowPlanet"


    private static let _sharedInstance = SwiftMoyaNetWorkManager()
    private override init() {} // 私有化init方法
    /// 获取单例
    ///
    /// - Returns: SwiftMoyaNetWorkManager对象
    class func shared() -> SwiftMoyaNetWorkManager {
        return _sharedInstance
    }

    /// 成功回调
    typealias successCallback = (_ data: Any) -> Void
    /// 成功回调带泛型
    typealias successCallTBack = (_ T: BaseMappable) -> Void
    
    typealias successCallArrayTback = (_ T: [BaseMappable]) -> Void

    typealias falseCallback = () -> Void
    var falseCallback : falseCallback?

    /// 网络请求
    ///
    /// - Parameters:
    ///   - type: 模型
    ///   - target: 请求地址加参数
    ///   - isCache: 是否缓存
    ///   - completion: 回调
    func request<T: BaseMappable>(_ type: T.Type ,target: MultiTarget,isCustomAlert:Bool = false,completion: @escaping successCallTBack) -> Void {
        //判断是否链接网络
        if !isNetworkConnect{
             SwiftProgressHUD.shared().showError("网络链接失败,请检查网络")
            return
        }

        provider.rx
            .request(target)
            .map(T.self)
            .subscribeOn(ConcurrentDispatchQueueScheduler(qos: .userInitiated))
            .observeOn(MainScheduler.instance)
            .subscribe(onSuccess: { [weak self] element in

                guard let element = element else {
                    if let falseCallback = self?.falseCallback  {
                        falseCallback()
                    }
                    return
                }
                completion(element)
            }) {
                [weak self] (error) in
                if let falseCallback = self?.falseCallback  {
                    falseCallback()
                }
                SwiftProgressHUD.shared().showError("网络链接失败,请检查网络")
            }
            .disposed(by: disposeBag)
    }
    
    /// 网络请求
    ///
    /// - Parameters:
    ///   - type: 模型
    ///   - target: 请求地址加参数
    ///   - isCache: 是否缓存
    ///   - completion: 回调
    func requestArray<T: BaseMappable>(_ type: T.Type ,target: MultiTarget,isCustomAlert:Bool = false,completion: @escaping successCallArrayTback) -> Void {
        //判断是否链接网络
        if !isNetworkConnect{
            SwiftProgressHUD.shared().showError("网络链接失败,请检查网络")
            return
        }
        
        provider.rx
            .request(target)
            .mapArray(T.self)
            .subscribeOn(ConcurrentDispatchQueueScheduler(qos: .userInitiated))
            .observeOn(MainScheduler.instance)
            .subscribe(onSuccess: { [weak self] element in
                
                guard let element = element else {
                    if let falseCallback = self?.falseCallback  {
                        falseCallback()
                    }
                    return
                }
                completion(element)
            }) {
                [weak self] (error) in
                if let falseCallback = self?.falseCallback  {
                    falseCallback()
                }
                SwiftProgressHUD.shared().showError("网络链接失败,请检查网络")
            }
            .disposed(by: disposeBag)
    }

    /// 缓存请求
    ///
    /// - Parameters:
    ///   - target: 请求地址加参数
    ///   - alwaysFetchCache: 是否总是缓存
    ///   - cacheType: 缓存类型
    ///   - completion: 请求成功回调
//    func cacheRequest<T: BaseMappable>(_ type: T.Type,target: MultiTarget,isCustomAlert:Bool = false,alwaysFetchCache: Bool = false,cacheType: MMCache.CacheKeyType = .default,completion: @escaping successCallback) -> Void {
//
//        //判断是否链接网络
//        if !isNetworkConnect{
//            SwiftProgressHUD.shared().showError("网络链接失败,请检查网络")
//            return
//        }

//        var cacheResponse: Response? = nil

//        if alwaysFetchCache {
//            cacheResponse = MMCache.shared.fetchResponseCache(target: target)
//            self.getResponseStatusCode(response: cacheResponse!, isCustomAlert: isCustomAlert, completion: completion)
//        } else {
//            if MMCache.shared.isNoRecord(target, cacheType: cacheType) {
//                MMCache.shared.record(target)
//                cacheResponse = MMCache.shared.fetchResponseCache(target: target)
//                self.getResponseStatusCode(response: cacheResponse!, isCustomAlert: isCustomAlert, completion: completion)
//            }
//        }

//        provider.rx
//            .request(target)
//            .map(T.self)
//            .subscribeOn(ConcurrentDispatchQueueScheduler(qos: .userInitiated))
//            .observeOn(MainScheduler.instance)
//            .subscribe(onSuccess: { [weak self] response in
//                MMCache.shared.cacheResponse(response as!  Response, target: target)
//                self?.getResponseStatusCode(response: response as! Response, isCustomAlert: isCustomAlert, completion: completion)
//            }) {
//                [weak self] (error) in
//                if let falseCallback = self?.falseCallback  {
//                    falseCallback()
//                }
//                SwiftProgressHUD.shared().showError("网络链接失败,请检查网络")
//            }
//            .disposed(by: disposeBag)
//
//    }

    // MARK: - 网络请求
    /// 网络请求
    ///
    /// - Parameters:
    ///   - target: 请求地址加参数
    ///   - completion: 请求成功回调
    func request(target: MultiTarget,isCustomAlert:Bool = false,completion: @escaping successCallback) -> Void {
        //判断是否链接网络
        if !isNetworkConnect{
            SwiftProgressHUD.shared().showText("网络链接失败,请检查网络")

            return
        }

        provider.rx
            .request(target)
            .subscribeOn(ConcurrentDispatchQueueScheduler(qos: .userInitiated))
            .observeOn(MainScheduler.instance)
            .subscribe(onSuccess: { [weak self] response in
                self?.getResponseStatusCode(response: response, isCustomAlert: isCustomAlert, completion: completion)
            }) {
                [weak self] (error) in
                SwiftProgressHUD.shared().showText(error.localizedDescription)
                if let falseCallback = self?.falseCallback  {
                    falseCallback()
                }
            }
            .disposed(by: disposeBag)
    }


    /// 缓存请求
    ///
    /// - Parameters:
    ///   - target: 请求地址加参数
    ///   - alwaysFetchCache: 是否总是缓存
    ///   - cacheType: 缓存类型
    ///   - completion: 请求成功回调
//    func cacheRequest(target: MultiTarget,isCustomAlert:Bool = false,alwaysFetchCache: Bool = false,cacheType: MMCache.CacheKeyType = .default,completion: @escaping successCallback) -> Void {
//
//        //判断是否链接网络
//        if !isNetworkConnect{
//            SwiftProgressHUD.shared().showError("网络链接失败,请检查网络")
//            return
//        }

//        var cacheResponse: Response? = nil

//        if alwaysFetchCache {
//            cacheResponse = MMCache.shared.fetchResponseCache(target: target)
//            self.getResponseStatusCode(response: cacheResponse!, isCustomAlert: isCustomAlert, completion: completion)
//        } else {
//            if MMCache.shared.isNoRecord(target, cacheType: cacheType) {
//                MMCache.shared.record(target)
//                cacheResponse = MMCache.shared.fetchResponseCache(target: target)
//                self.getResponseStatusCode(response: cacheResponse!, isCustomAlert: isCustomAlert, completion: completion)
//            }
//        }

//        provider.rx
//            .request(target)
//            .subscribeOn(ConcurrentDispatchQueueScheduler(qos: .userInitiated))
//            .observeOn(MainScheduler.instance)
//            .subscribe(onSuccess: { [weak self] response in
//                MMCache.shared.cacheResponse(response, target: target)
//                self?.getResponseStatusCode(response: response, isCustomAlert: isCustomAlert, completion: completion)
//            }) {
//                [weak self] (error) in
//                if let falseCallback = self?.falseCallback  {
//                    falseCallback()
//                }
//                SwiftProgressHUD.shared().showError("网络链接失败,请检查网络")
//            }
//            .disposed(by: disposeBag)
//
//    }


    // MARK: - 获取状态码
    /// 获取状态码
    ///
    /// - Parameters:
    ///   - response: 响应结果
    ///   - completion: 回调
    private func getResponseStatusCode(response:Response, isCustomAlert:Bool , completion: @escaping successCallback) -> Void {
        let json = try? JSON(response.mapJSON())
        if response.statusCode == 200 {
            NXLLog("\nstatusCode=\(response.statusCode)\njson=\n\(json!.description)");
            let json = JSON(parseJSON: json!.description)
            let rootModel = RootModel(JSONString: json.description)
            let data = JSON(json["data"]).description
            rootModel?.data = data
            if rootModel!.code == 0 {
                 completion(rootModel as Any)
            }else if rootModel!.code  == 1 {
                if !isCustomAlert {
                     SwiftProgressHUD.shared().showText(rootModel!.msg ?? "信息有误!!!", textAlignment: .left)
                }
                if let falseCallback = self.falseCallback  {
                    falseCallback()
                }
                
            }else {
                SwiftProgressHUD.shared().showError(rootModel!.msg ?? "信息有误!!!")
                if let falseCallback = self.falseCallback  {
                    falseCallback()
                }
            }
        }else if response.statusCode == 401 {
            NXLLog("\nstatusCode=\(response.statusCode)\njson=\n\(json!.description)");
            let infoModel = InfoModel(JSONString: json?.description ?? "")
            kAppDelegate.setLoginController()
            SwiftProgressHUD.shared().showText(infoModel!.message ?? "登录过期,请重新登录")

            if let falseCallback = self.falseCallback  {
                falseCallback()
            }
        } else {
            NXLLog("\nstatusCode=\(response.statusCode)\nerror=\n\(response.description)");
            SwiftProgressHUD.shared().showText(response.description)

            if let falseCallback = self.falseCallback  {
                falseCallback()
            }
        }
    }


    // MARK: - 取消所有请求
    /// 取消所有请求
    func cancelAllRequest() {
        provider.manager.session.getTasksWithCompletionHandler { dataTasks, uploadTasks, downloadTasks in
            dataTasks.forEach { $0.cancel() }
            uploadTasks.forEach { $0.cancel() }
            downloadTasks.forEach { $0.cancel() }
        }
    }

    // MARK: - 取消指定请求
    /// 取消指定请求
    ///
    /// - Parameter url: 指定的网络请求地址
    func cancelDesignationRequest(url:String) {
        provider.manager.session.getTasksWithCompletionHandler {
            (sessionDataTask, uploadData, downloadData) in
            sessionDataTask.forEach {
                //只取消指定url的请求
                if ($0.originalRequest?.url?.absoluteString == url) {
                    $0.cancel()
                }
            }
        }
    }
    
}


// MARK: - 泛型返回
extension PrimitiveSequence where TraitType == SingleTrait, ElementType == Response {
    func map<T: BaseMappable>(_ type: T.Type) -> Single<T?> {
        return flatMap { response -> Single<T?> in
            do {
                let json = try JSON(response.mapJSON())
                if response.statusCode == 200 {
                    NXLLog("\nstatusCode=\(response.statusCode)\njson=\n\(json.description)");

                    let json = JSON(parseJSON: json.description)
                    let rootModel = RootModel(JSONString: json.description)
                    let data = JSON(json["data"]).description
                    rootModel?.data = data
                    if rootModel!.code  == 0 {
                        let mapper = T(JSONString:  rootModel!.data ?? "")
                        return Single<T?>.just(mapper)
                    }else if rootModel!.code  == 1 {
                        SwiftProgressHUD.shared().showText(rootModel!.msg ?? "信息有误!!!", textAlignment: .left)
                        return Single<T?>.just(nil)
                    }else {
                        NXLLog("\nstatusCode=\(response.statusCode)\nerror=\n\(response.description)");
                        SwiftProgressHUD.shared().showText(response.description)
                        return Single<T?>.just(nil)
                    }
                }else if response.statusCode == 401 {
                    NXLLog("\nstatusCode=\(response.statusCode)\njson=\n\(json.description)");
                    let infoModel = InfoModel(JSONString: json.description)
                    SwiftProgressHUD.shared().showText(infoModel!.message ?? "登录过期,请重新登录")
                    kAppDelegate.setLoginController()
                    return Single<T?>.just(nil)
                }else {                NXLLog("\nstatusCode=\(response.statusCode)\nerror=\n\(response.description)");
                    SwiftProgressHUD.shared().showText(response.description)
                    return Single<T?>.just(nil)
                }

            } catch {
                NXLLog("\nstatusCode=\(response.statusCode)\nerror=\n\(response.description)");
                SwiftProgressHUD.shared().showText(response.description)
                return Single<T?>.just(nil)
            }
        }
    }
    
    func mapArray<T: BaseMappable>(_ type: T.Type) -> Single<[T]?> {
        return flatMap { response -> Single<[T]?> in
            do {
                let json = try JSON(response.mapJSON())
                if response.statusCode == 200 {
                    NXLLog("\nstatusCode=\(response.statusCode)\njson=\n\(json.description)");
                    
                    let json = JSON(parseJSON: json.description)
                    let rootModel = RootModel(JSONString: json.description)
                    let data = JSON(json["data"]).description
                    rootModel?.data = data
                    if rootModel!.code  == 0 {
                        let mapper = Mapper<T>().mapArray(JSONString: rootModel!.data!)
                        return Single<[T]?>.just(mapper)
                    }else if rootModel!.code  == 1 {
                        SwiftProgressHUD.shared().showText(rootModel!.msg ?? "信息有误!!!", textAlignment: .left)
                        return Single<[T]?>.just(nil)
                    }else {
                        NXLLog("\nstatusCode=\(response.statusCode)\nerror=\n\(response.description)");
                        SwiftProgressHUD.shared().showText(response.description)
                        return Single<[T]?>.just(nil)
                    }
                }else if response.statusCode == 401 {
                    NXLLog("\nstatusCode=\(response.statusCode)\njson=\n\(json.description)");
                    let infoModel = InfoModel(JSONString: json.description)
                    SwiftProgressHUD.shared().showText(infoModel!.message ?? "登录过期,请重新登录")
                    kAppDelegate.setLoginController()
                    return Single<[T]?>.just(nil)
                }else {                NXLLog("\nstatusCode=\(response.statusCode)\nerror=\n\(response.description)");
                    SwiftProgressHUD.shared().showText(response.description)
                    return Single<[T]?>.just(nil)
                }
                
            } catch {
                NXLLog("\nstatusCode=\(response.statusCode)\nerror=\n\(response.description)");
                SwiftProgressHUD.shared().showText(response.description)
                return Single<[T]?>.just(nil)
            }
        }
    }
}