import ContentsquareModule
import WebKit

@objc(ContentsquareSDKInterfaceLegacy)
public class ContentsquareSDKInterfaceLegacy: NSObject {
    
    let contentsquareType: _Contentsquare.Type
    let webViewInjector: _WebViewInjector
    let csEventEmitterType: _CSEventEmitter.Type
    
    @objc
    public convenience override init() {
        self.init(Contentsquare.self,
                  webViewInjector: WebViewInjector(Contentsquare.self, viewFinder: ViewFinder()),
                  csEventEmitterType: CSEventEmitter.self
        )
    }
    
    init(_ contentsquareType: _Contentsquare.Type,
         webViewInjector: _WebViewInjector,
         csEventEmitterType: _CSEventEmitter.Type) {
        self.contentsquareType = contentsquareType
        self.webViewInjector = webViewInjector
        self.csEventEmitterType = csEventEmitterType
        
        let externalBridgeInterface = ExternalBridgeFactory.create(emitter: csEventEmitterType)
        
        registerExternalBridge(interface: externalBridgeInterface)
        
        contentsquareType.mask(viewsOfType: CSMaskedView.self)
        contentsquareType.unmask(viewsOfType: CSUnmaskedView.self)
    }
    
    @objc
    public func start() {
        contentsquareType.start()
    }
    
    @objc
    public func stopTracking() {
        contentsquareType.stopTracking()
    }
    
    @objc
    public func resumeTracking() {
        contentsquareType.resumeTracking()
    }
    
    @objc
    public func optIn() {
        contentsquareType.optIn()
    }
    
    @objc
    public func optOut() {
        contentsquareType.optOut()
    }
    
    @objc
    public func initComponents(params: Dictionary<String, Any>) {
        var updatedParams = params
#if RCT_NEW_ARCH_ENABLED
        updatedParams["xpf_rn_new_arch_enabled"] = true
#endif
        updatedParams["xpf_csq_sdk_enabled"] = false
        
        for (key, value) in updatedParams {
            switch key {
            case "xpf_type":
                let selectorXPFType = NSSelectorFromString("_setXPFType:")
                if Contentsquare.responds(to: selectorXPFType) {
                    _ = Contentsquare.perform(selectorXPFType, with: value)
                }
            case "xpf_version":
                let selectorXPFVersion = NSSelectorFromString("_setXPFVersion:")
                if Contentsquare.responds(to: selectorXPFVersion) {
                    _ = Contentsquare.perform(selectorXPFVersion, with: value)
                }
            case "xpf_bridge_version":
                let selectorXPFBridgeVersion = NSSelectorFromString("_setXPFBridgeVersion:")
                if Contentsquare.responds(to: selectorXPFBridgeVersion) {
                    _ = Contentsquare.perform(selectorXPFBridgeVersion, with: value)
                }
            default:
                let selectorCollect = NSSelectorFromString("_telemetryCollect:withValue:")
                if Contentsquare.responds(to: selectorCollect) {
                    _ = Contentsquare.perform(selectorCollect, with: key, with: value)
                }
            }
        }
    }
    
    @objc
    public func handle(url: URL) {
        contentsquareType.handle(url: url)
    }
    
    @objc
    public var currentSessionReplayLink: URL? {
        get {
            contentsquareType.currentSessionReplayLink
        }
    }
    
    @objc
    public var userID: String? {
        get {
            contentsquareType.userID
        }
    }
    
    @objc
    public func send(transactionId id: String?,
                     value:Float,
                     currency: Currency) {
        let transaction = CustomerTransaction(id: id, value: value, currency: currency)
        contentsquareType.send(transaction: transaction)
    }
    
    @objc
    public func send(transactionId id: String?,
                     value:Float,
                     stringCurrency currency: String) {
        let transaction = CustomerTransaction(id: id, value: value, currency: currency)
        contentsquareType.send(transaction: transaction)
    }
    
    @objc
    public func send(screenViewWithName name: String, cvars: [[String: Any]]) {
        var computedCvars: [CustomVar] = [];
        for cvar in cvars {
            computedCvars.append(CustomVar(index: cvar["index"] as! UInt32, name: cvar["key"] as! String, value: cvar["value"] as! String))
        }
        contentsquareType.send(screenViewWithName: name, cvars: computedCvars)
    }
    
    @objc
    public func send(dynamicVar key: String,
                     stringValue value: String) {
        let dynVar = DynamicVar(key: key, value: value)
        print("send(dynamicVar key: String, stringValue value: String) called")
        contentsquareType.send(dynamicVar: dynVar)
    }
    
    @objc
    public func send(dynamicVar key: String,
                     intValue value: UInt32) {
        let dynVar = DynamicVar(key: key, value: value)
        print("send(dynamicVar key: INT called")
        contentsquareType.send(dynamicVar: dynVar)
    }
    
    @objc
    public func injectWebView(withTag tag: NSNumber,
                              in uiManager: _RCTUIManager) {
        webViewInjector.injectWebview(withTag: tag,
                                      in: uiManager);
    }
    
    @objc
    public func removeInjectionInWebView(withTag tag: NSNumber,
                                         in uiManager: _RCTUIManager) {
        webViewInjector.removeInjectionInWebView(withTag: tag,
                                                 in: uiManager);
    }
    
    @objc
    public func setDefaultMasking(isMasking masked: Bool) {
        contentsquareType.setDefaultMasking(masked)
    }
    
    @objc
    public func sendUserIdentifier(_ userIdentifier: String) {
        contentsquareType.sendUserIdentifier(userIdentifier);
    }
    
    @objc
    public func setOnSessionReplayLinkChange() {
        contentsquareType.onSessionReplayLinkChange { url in
            print("Session Replay Link Changed: \(url.absoluteString)")
            
            self.csEventEmitterType.shared?.sendSessionReplayLink(url: url.absoluteString)
        }
    }
    
    @objc
    public func monitorWarn(_ params: Dictionary<String, Any>) {
        let selectorLogWarn = NSSelectorFromString("_logWarnWithParameters:")
        if Contentsquare.responds(to: selectorLogWarn) {
            _ = Contentsquare.perform(selectorLogWarn, with: params)
        }
    }
    
    @objc
    public func monitorError(_ params: Dictionary<String, Any>) {
        let selectorLogError = NSSelectorFromString("_logErrorWithParameters:")
        if Contentsquare.responds(to: selectorLogError) {
            _ = Contentsquare.perform(selectorLogError, with: params)
        }
    }
}