VisualTrackingManager.swift

//
//  Copyright 2020 PLAID, Inc.
//
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the License.
//  You may obtain a copy of the License at
//
//      https://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//

import KarteCore
import UIKit

internal class VisualTrackingManager {
    static let shared = VisualTrackingManager()

    private var receivers: [ActionReceiver] = []
    var tracer: ActionTracer?
    var tracker: ActionTracker?
    var isPaired: Bool {
        tracer?.pairingClient?.isPaired ?? false
    }

    private var notificationObserverToken: NSObjectProtocol?

    init() {
    }

    func configure(app: KarteApp) {
        let tracer = ActionTracer(app: app)
        self.tracer = tracer

        let tracker = ActionTracker(app: app)
        self.tracker = tracker

        register(receiver: tracer)
        register(receiver: tracker)

        let config: VisualTrackingConfiguration = app.libraryConfiguration() ?? VisualTrackingConfiguration()
        if config.automaticallyCollectLogs {
            UIApplicationProxy.shared.swizzleMethods()
            UIGestureRecognizerProxy.shared.swizzleMethods()
            UINavigationControllerProxy.shared.swizzleMethods()
            UIViewControllerProxy.shared.swizzleMethods()
        }

        notificationObserverToken = NotificationCenter.default.addObserver(forName: UIApplication.didBecomeActiveNotification, object: nil, queue: nil) { [weak self] _ in
            DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(1)) {[weak self] in
                if let config = self?.tracker?.app.configuration as? ExperimentalConfiguration, config.operationMode == OperationMode.ingest {
                    self?.tracker?.refreshDefinitions()
                }
            }
            if let notificationObserverToken = self?.notificationObserverToken {
                NotificationCenter.default.removeObserver(notificationObserverToken)
            }
        }
    }

    func unconfigure(app: KarteApp) {
        tracer?.stopPairing()

        receivers.removeAll()
        tracer = nil
        tracker = nil
    }

    func register(receiver: ActionReceiver) {
        receivers.append(receiver)
    }

    func dispatch(action: ActionProtocol?) {
        guard let action = action else {
            Logger.warn(tag: .visualTracking, message: "Action is invalid.")
            return
        }
        receivers.forEach { receiver in
            receiver.receive(action: action)
        }
    }

    deinit {
    }
}

extension VisualTrackingManager: ActionModule, DeepLinkModule, TrackModule {
    var name: String {
        String(describing: type(of: self))
    }

    var queue: DispatchQueue? {
        nil
    }

    func receive(response: [String: JSONValue], request: TrackRequest) {
        tracker?.refreshDefinitions(response: response)
    }

    func reset(sceneId: SceneId) {
    }

    func resetAll() {
    }

    func handle(app: UIApplication, open url: URL) -> Bool {
        guard let account = Account(url: url) else {
            return false
        }
        tracer?.startPairing(account: account)
        return true
    }

    func intercept(urlRequest: URLRequest) throws -> URLRequest {
        guard let tracker = tracker else {
            return urlRequest
        }
        return try tracker.intercept(urlRequest: urlRequest)
    }

    func provideEventRejectionFilterRules() -> [TrackEventRejectionFilterRule] {
        return []
    }
}