GmaWebViewManager.swift

import GoogleMobileAds
import React
import SafariServices
import UIKit
import WebKit

/// Starts GMA once and registers every WKWebView before its first URL load.
@MainActor
private enum GmaWebViewRegistration {
  private static var isReady = false
  private static var isStarting = false
  private static var completions: [() -> Void] = []

  static func register(_ webView: WKWebView, completion: @escaping () -> Void) {
    let registration = {
      MobileAds.shared.register(webView)
      completion()
    }

    if isReady {
      registration()
      return
    }

    completions.append(registration)
    guard !isStarting else { return }
    isStarting = true

    MobileAds.shared.start { _ in
      Task { @MainActor in
        isReady = true
        isStarting = false
        let pending = completions
        completions.removeAll()
        pending.forEach { $0() }
      }
    }
  }
}

/// React Native manager for the app-owned, GMA-registered WKWebView.
@objc(GmaWebViewManager)
final class GmaWebViewManager: RCTViewManager {
  override func view() -> UIView! {
    GmaWebView()
  }

  override static func requiresMainQueueSetup() -> Bool {
    true
  }
}

/**
 * WKWebView configured for ads, safe click-outs, and per-instance GMA
 * registration. Host allowlisting is applied only to top-level navigation.
 */
final class GmaWebView: UIView, WKNavigationDelegate, WKUIDelegate {
  @objc var sourceUrl: NSString? {
    didSet {
      guard sourceUrl != oldValue else { return }
      pendingSourceUrl = sourceUrl as String?
      loadPendingSource()
    }
  }

  @objc var reloadToken: NSNumber = 0 {
    didSet {
      guard reloadToken != oldValue else { return }
      webView.reload()
    }
  }

  @objc var goBackToken: NSNumber = 0 {
    didSet {
      guard goBackToken != oldValue, webView.canGoBack else { return }
      webView.goBack()
    }
  }

  @objc var onLoadProgress: RCTDirectEventBlock?
  @objc var onError: RCTDirectEventBlock?
  @objc var onNavigationStateChange: RCTDirectEventBlock?

  private let webView: WKWebView
  private var progressObservation: NSKeyValueObservation?
  private var isGmaReady = false
  private var pendingSourceUrl: String?
  private var currentSourceUrl: String?

  override init(frame: CGRect) {
    let configuration = WKWebViewConfiguration()
    configuration.allowsInlineMediaPlayback = true
    configuration.mediaTypesRequiringUserActionForPlayback = []
    configuration.websiteDataStore = .default()
    configuration.preferences.javaScriptCanOpenWindowsAutomatically = true

    webView = WKWebView(frame: .zero, configuration: configuration)
    super.init(frame: frame)

    backgroundColor = .white
    webView.backgroundColor = .white
    webView.isOpaque = false
    webView.navigationDelegate = self
    webView.uiDelegate = self
    webView.allowsBackForwardNavigationGestures = true
    addSubview(webView)

    progressObservation = webView.observe(
      \.estimatedProgress,
      options: [.initial, .new]
    ) { [weak self] webView, _ in
      DispatchQueue.main.async {
        self?.emitProgress(webView.estimatedProgress)
      }
    }

    GmaWebViewRegistration.register(webView) { [weak self] in
      self?.isGmaReady = true
      self?.loadPendingSource()
    }
  }

  required init?(coder: NSCoder) {
    fatalError("init(coder:) has not been implemented")
  }

  override func layoutSubviews() {
    super.layoutSubviews()
    webView.frame = bounds
  }

  private func loadPendingSource() {
    guard
      isGmaReady,
      let source = pendingSourceUrl,
      source != currentSourceUrl,
      let url = URL(string: source)
    else {
      return
    }

    pendingSourceUrl = nil
    currentSourceUrl = source
    webView.load(URLRequest(url: url))
  }

  private func emitProgress(_ progress: Double) {
    onLoadProgress?(["progress": progress])
  }

  private func emitNavigationState() {
    onNavigationStateChange?(["canGoBack": webView.canGoBack])
  }

  private func emitError(_ message: String) {
    onError?(["message": message])
  }

  func webView(
    _ webView: WKWebView,
    decidePolicyFor navigationAction: WKNavigationAction,
    decisionHandler: @escaping (WKNavigationActionPolicy) -> Void
  ) {
    guard let url = navigationAction.request.url else {
      decisionHandler(.allow)
      return
    }

    // A false main-frame flag denotes an iframe. Never apply the top-level
    // allowlist to game engines, ad tags, analytics, or about: documents.
    if navigationAction.targetFrame?.isMainFrame == false {
      decisionHandler(.allow)
      return
    }

    // A nil target frame is target=_blank or window.open(..., "_blank").
    if navigationAction.targetFrame == nil {
      openClickOut(url)
      decisionHandler(.cancel)
      return
    }

    if Self.isAllowedInWebView(url) {
      decisionHandler(.allow)
    } else {
      openClickOut(url)
      decisionHandler(.cancel)
    }
  }

  func webView(
    _ webView: WKWebView,
    createWebViewWith configuration: WKWebViewConfiguration,
    for navigationAction: WKNavigationAction,
    windowFeatures: WKWindowFeatures
  ) -> WKWebView? {
    if let url = navigationAction.request.url {
      openClickOut(url)
    }
    return nil
  }

  func webView(_ webView: WKWebView, didStartProvisionalNavigation navigation: WKNavigation!) {
    emitProgress(0)
    emitNavigationState()
  }

  func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
    emitProgress(1)
    emitNavigationState()
  }

  func webView(
    _ webView: WKWebView,
    didFailProvisionalNavigation navigation: WKNavigation!,
    withError error: Error
  ) {
    emitError(error.localizedDescription)
    emitNavigationState()
  }

  private func openClickOut(_ url: URL) {
    let scheme = url.scheme?.lowercased() ?? ""
    let host = url.host?.lowercased() ?? ""

    if !["http", "https"].contains(scheme) ||
      host == "apps.apple.com" ||
      host == "play.google.com"
    {
      UIApplication.shared.open(url) { [weak self] opened in
        if !opened {
          self?.emitError("Could not open \(url.absoluteString)")
        }
      }
      return
    }

    guard let viewController = nearestViewController else {
      emitError("Could not present \(url.absoluteString)")
      return
    }

    viewController.present(SFSafariViewController(url: url), animated: true)
  }

  private var nearestViewController: UIViewController? {
    var responder: UIResponder? = self
    while let current = responder {
      if let viewController = current as? UIViewController {
        return viewController
      }
      responder = current.next
    }
    return nil
  }

  /// Only called for top-level navigation; subframes bypass this policy.
  static func isAllowedInWebView(_ url: URL) -> Bool {
    let scheme = url.scheme?.lowercased() ?? ""
    if ["about", "blob", "data"].contains(scheme) {
      return true
    }
    guard scheme == "https", let host = url.host?.lowercased() else {
      return false
    }
    return host == "google.github.io" ||
      host == "gamezop.com" ||
      host.hasSuffix(".gamezop.com")
  }
}