/// The lifecycle stages of a router scope.
public enum RouterLifecycle {

    /// Router did load.
    case didLoad
    
    /// Router will attach child
    case willAttachChild(Routing)
    
    /// Router did attach child
    case didAttachChild(Routing)
    
    /// Router will detach child
    case willDetachChild(Routing)

    /// Router did detach child
    case didDetachChild(Routing)
}

open class Router<InteractorType>: Routing {
    /// Attaches the given router as a child.
    ///
    /// - parameter child: The child `Router` to attach.
    public final func attachChild(_ child: Routing) {
        assert(!(children.contains { $0 === child }), "Attempt to attach child: \(child), which is already attached to \(self).")
        lifecycleSubject.onNext(.willAttachChild(child))
        
        children.append(child)
        
        // Activate child first before loading. Router usually attaches immutable children in didLoad.
        // We need to make sure the RIB is activated before letting it attach immutable children.
        child.interactable.activate()
        child.load()
        
        lifecycleSubject.onNext(.didAttachChild(child))
    }

    /// Detaches the given `Router` from the tree.
    ///
    /// - parameter child: The child `Router` to detach.
    public final func detachChild(_ child: Routing) {
        lifecycleSubject.onNext(.willDetachChild(child))

        child.interactable.deactivate()
        children.removeElementByReference(child)
        
        lifecycleSubject.onNext(.didDetachChild(child))
    }
}

func observeRouter(_ router: Routing) {
    let didBecomeActive = router.interactable.isActiveStream.skip(1).filter { $0 == false }
    
    let willAttachChild = router
        .lifecycle
        .compactMap { lifecycle -> Routing? in
            if case .willAttachChild(let child) = lifecycle {
                return child
            } else {
                return nil
            }
        }
        .takeUntil(didBecomeActive)
    
    let didAttachChild = router
        .lifecycle
        .compactMap { lifecycle -> Routing? in
            if case .didAttachChild(let child) = lifecycle {
                return child
            } else {
                return nil
            }
        }
        .takeUntil(didBecomeActive)

    _ = willAttachChild
        .subscribe(onNext: { child in            
            /// Recursive observe child router
            observeRouter(child)
        })
    
    _ = willAttachChild
        .flatMap { child -> Observable<(Routing)> in
            return child.interactable.isActiveStream.filter { $0 }.map { _ in return child }
        }
        .subscribe(onNext: { child in
            /// Start Performance Tracing Interator didBecomeActive
        })
    
    _ = didAttachChild
        .subscribe(onNext: { child in
            /// Stop Performance Tracing here
        })
}