/// We define an independent struct here as a key manager, it's not necessary but recommended. 
struct SettingPageService {
    static let service = "SettingPageService"
    static let taskNavigateToVC = "taskNavigateToVC"
    static let taskCreateVC = "taskCreateVC"

    static let keyGetVC = "keyGetVC"
    
    /// You must include a value for this key!
    static let keyShouldRefresh = "keyShouldRefresh"
}

/// This should be somewhere in your delegate object or a manager, NOT a view controller!!
/// Use registerVC to register anything related to navigation as well as presentation.
/// We register with the key 'taskNavigateToVC'.
/// Parameter 'userInfo' is a [String: Any] passed by the service user when they use the 'navigateVC' method.
AHServiceRouter.registerVC(SettingPageService.service, taskName: SettingPageService.taskNavigateToVC) { (userInfo) -> UIViewController? in
    /// We first check if the userInfo includes the key, if not, we return nil, assuming the value of 'keyShouldRefresh' is something that SettingPage must need to operate, otherwise it can't be used.
    guard let shouldRefresh = userInfo[SettingPageService.keyShouldRefresh] as? Bool else{
        return nil
    }
    let vc = SettingPage()
    vc.shouldRefresh = shouldRefresh
    return vc
}


/// For service users
import AHServiceRouter
import SettingPageService

/// Let's pretend we are in the mainPage now:)
/// And the following class is mainPageVC's delegate object.
/// NOTE: we use a class here, it could be a struct as well. 
/// But class is the preferred choice for VC delegates.  
class MainPageDelegateObject: MainPageDelegate {
    func mainPageDidTapSettingButton(_ vc: MainPage) {
        guard let navVC = vc.navigationController else {
            return
    }
    /// The completion closure here is called after completing the navgation by the router. It's not related to the service provider!
    AHServiceRouter.navigateVC(SettingPageService.service, taskName: SettingPageService.taskNavigateToVC, userInfo: [SettingPageService.keyShouldRefresh: true], type: .push(navVC: navVC), completion: nil)
    }
}

public enum AHServiceNavigationType{
    case present(currentVC: UIViewController)
    /// Will wrap a navVC to the target vc, presenting by currentVC
    case presentWithNavVC(currentVC: UIViewController)
    case push(navVC: UINavigationController)
}

/// You can do this if you support both presenting and navigating
var type: AHServiceNavigationType
if vc.navigationController != nil {
    type = .push(navVC: vc.navigationController!)
}else{
    type = .present(currentVC: vc)
}

/// Register first!
/// We register with the key 'taskCreateVC' this time.
/// Parameter 'completon' is an optional completion closure from the user in order to notify them when you finish, along with a flag and a dict. 'completion?(Bool, [String: Any])'.
/// If your task is needed to be done asynchronously, use the 'completion' to pass the results when finish, otherwise return the results directly.
/// In this case, we return the newly created vc directly in a [String : Any] -- the difference part from 'registerVC'.
AHServiceRouter.registerTask(SettingPageService.service, taskName: SettingPageService.taskCreateVC) { (userInfo, completion) -> [String : Any]? in
    guard let shouldRefresh = userInfo[SettingPageService.keyShouldRefresh] as? Bool else{
        completion?(false, nil)
        return nil
    }
    
    let vc = SettingPage()
    vc.shouldRefresh = shouldRefresh
    completion(true, nil)
    return [SettingPageService.keyGetVC: vc]
}


/// Now we use it
/// This method is in mainPage's delegate object
func mainPageGetSettingController(_ vc: MainPage) -> UIViewController? {
  /// use the return data from the 'doTask' method. The data is '[SettingPageService.keyGetVC: vc]' shown in above code snippet.
  guard let data = AHServiceRouter.doTask(SettingPageService.service, taskName: SettingPageService.taskCreateVC, userInfo: [SettingPageService.keyShouldRefresh: false], completion: nil) else {
    return
    }
    guard let vc = data[SettingPageService.keyGetVC] as? UIViewController else {
    return
    }
    return vc
}

/// In mainPage VC
func settingButtonDidTap(_ sender: UIButton) {
    guard let settingVC = self.delegate?.mainPageGetSettingController(self) else{
        return
    }
    /// You can ask the SettingPage guy to register a service/task to provide additional data for the animation, if you can't handle the animation yourself within your MainPage module.
    vc.transitioningDelegate = someAnimator
    vc.modalPresentationStyle = .custom
    self.present(vc, animated: true, completion: nil)
}

public protocol AHServiceRouterDelegate {
    /// Do NOT do navigation yourself! Just return the fallback VC.
    func fallbackVC(for service: String, task: String, userInfo: [String: Any]) -> UIViewController?
    
    /// If your task is needed to be done asynchronously, use the 'completion' to pass the results when finish, otherwise return the results directly.
    func fallbackTask(for service: String, task: String, userInfo: [String: Any], completion: AHServiceCompletion?) -> [String: Any]?
}

/// If you pass a navVC then AHServiceRouter will iterate its childViewControllers and ask you if the childViewController is the one you wnat to reuse(or recycle). 
/// If you don't pass a navVC or pass a nil, AHServiceRouter will find the first UINavigationController under the keyWindow then iterate through its childViewControllers.
static func reuseVC(navigationVC: UINavigationController? = nil,_ shouldBeReused: (_ currentVC: UIViewController) -> Bool) -> UIViewController?

/// Recycling policy is only defined in the service provider side when registering. The service user doesn't know anything about recycling a viewController.
AHServiceRouter.registerVC(ShowPageServices.service, taskName: ShowPageServices.taskNavigation) { (userInfo) -> UIViewController? in
    /// Check if the user includes a showId which will be used in the 'reuseVC' method
    guard let showId = userInfo[AHFMShowPageServices.keyShowId] as? Int else {
        print("You must pass a showId into userInfo")
        return nil
    }
    
    /// Here we don't pass a navVC into 'reuseVC' method.
    /// So the default navVC is used and the method will iterate through the navVC's childViewControllers.
    /// The default navVC is the first UINavigationController under the keyWindow.
    var vc: ShowPage? = AHServiceRouter.reuseVC({ (vc) -> Bool in
        /// Check if the vc is the same kind
        guard vc.isKind(of: ShowPage.self), let showPage = vc as! ShowPage else {
            return false
        }
        /// Returning true tells the method this is the one we want to reuse.
        return showPage.showId == showId
    })
    
    if vc == nil {
        /// There's no reusable 'showPage' in the stack
        vc = ShowPage()
    }
    /// do the assigning showId again just in case there's a 'didSet' listener in the 'showPage' VC.
    vc?.showId = showId
    return vc
}

AHServiceRouter.registerVC(AudioPlayerVCServices.service, taskName: AudioPlayerVCServices.taskNavigation) { (userInfo) -> UIViewController? in
    guard let trackId = userInfo[AudioPlayerVCServices.keyTrackId] as? Int else {
        return nil
    }
    
    var vc: AudioPlayerVC? = AHServiceRouter.reuseVC({ (vc) -> Bool in
        /// Check if the vc is the same kind, if it is, return true, no further checking needed.
        if vc.isKind(of: AudioPlayerVC.self) else {
            return true
        }else{
            return false
        }
    })
    
    if vc == nil {
        vc = AudioPlayerVC()
    }

    vc?.trackId = trackId
    
    return vc
}

/// Define services and classes

struct PageBServices{
    static let service = "\(Self.self)"
    static let taskNavigateToVC = "taskNavigateToVC"
    /// Int
  static let keyOrderNumber = "keyOrderNumber"
    /// Double
  static let keyPrice = "keyPrice"
}

class PageB: UIViewController {
    var orderNumber:Int?
    var price: Double?
}

struct LoginVCServices{
    static let service = "\(Self.self)"

    /// use .presentWithNavVC to present
  static let taskPresentVC = "taskPresentVC"

    /// the value should be a closure of form '(_ succeeded: Bool)->Void'
  /// this key-value is optional!
  static let keyCompletionClosure = "keyCompletionClosure"
}

class LoginVC: UIViewController {
    var completion: ((_ succeeded: Bool)->Void)?
    
    func dismissButtonTapped(_ sender: UIButton) {
        /// invoke the completion closure when dismiss, with a failed login status
      completion?(false)
    }

    /// Called when finish authentication
  func handleClosure(_ isSucceeded: Bool) {
        completion?(isSucceeded)
    }
}

/// Register first!!

/// Register PageBServices
AHServiceRouter.registerVC(PageBServices.service, taskName: PageBServices.taskNavigation) { (userInfo) -> UIViewController? in
  guard let orderNumber = userInfo[PageBServices.keyOrderNumber] as? Int,
        let price = userInfo[PageBServices.keyPrice] as? Double else {
    return nil
  }
  let vc = PageB()
  vc.orderNumber = orderNumber
  vc.price = price
  return vc
}

/// Register LoginVCServices
AHServiceRouter.registerVC(LoginVCServices.service, taskName: LoginVCServices.taskNavigation) { (userInfo) -> UIViewController? in

    let vc = LoginVC()
    /// the completion closure is optional parameter.
  if let comletion = userInfo[LoginVCServices.keyCompletionClosure] as? ((_ succeeded: Bool)->Void) else {
    vc.comletion = comletion
  }
    
  return vc
}



/// Now let's pretend we are in pageA's delegate class.

import AHServiceRouter
import PageBServices
/// You have to import the actual module, not just the service module.
import PageB
import LoginVCServices
/// You have to import the actual module, not just the service module.
import LoginVC

class PageADelegateObject: NSObject, PageADelegate {
    func comfirmButtonDidTap(_ vc: PageB, orderNumber: Int, price: Double) {
        guard let navVC = vc.navigationController else {return}

        if checkLogin() {
            /// route to pageB directly with a infoDict required by its services.
          navigateToPageB(orderNumber, price)
        }else{
            /// user not loggd in !!!
          let completion: (_ succeeded: Bool)->Void = { (succeeded) in
                if succeeded {
                    self.navigateToPageB(orderNumber, price)
                }else{
                    // error handling here, it might be a network error
              }
            }

            let closureDict = [LoginVCServices.keyCompletionClosure: completion]
            AHServiceRouter.navigateVC(LoginVCServices.service, taskName: LoginVCServices.taskPresentVC, userInfo: closureDict, type: .presentWithNavVC(currentVC: vc), completion: nil)
        }
    }

    func navigateToPageB(_ orderNumber: Int, _ price: Double) {
        /// Make sure the infoDict has the correct info for routing to pageB
      let infoDict = [PageBServices.keyOrderNumber: orderNumber, PageBServices.keyPrice: price]
        AHServiceRouter.navigateVC(PageBServices.service, taskName: PageBServices.taskNavigateToVC, userInfo: infoDict, type: .push(navVC: navVC), completion: nil)
    }

    func checkLogin() -> Bool {
        /// .... logics to decide if the current user is logged in or not .... it could be another service provided by the LoginVCServices.
  }
}

/// Register this way
AHServiceRouter.registerTask(LoginVCServices.service, taskName: LoginVCServices.taskCreateVC) { (userInfo, completion) -> [String : Any]? in
    let vc = LoginVC()
    /// instead of invoking the comletion here, assigning it to the vc.
  vc.completion = completion
    /// You need to return a dict when regisgter tasks!
  return [LoginVCServices.keyGetVC: vc]
}

/// Use it
func navigateToPageB(_ pageA: PageA) {
    let completionClosure: ((_ succeeded: Bool, info: [String : Any]?)) = { (succeeded,info) in
        if succeeded {
            // navigate to pageB here
      }
    }
    /// pass 'completionClosure' to 'doTask' method
  guard let data = AHServiceRouter.doTask(LoginVCServices.service, taskName: LoginVCServices.taskCreateVC, userInfo: [:], completion: completionClosure) else {
    return
    }
    guard let vc = data[LoginVCServices.keyGetVC] as? UIViewController else {
    return
    }
    
    // present vc here
}