매체사(WebView -> Web)

// 초기화 — 객체 이름은 반드시 "addedBridge"
webView.settings.javaScriptEnabled = true
val bridge = AddedBridge(this, webView)
webView.addJavascriptInterface(bridge, "addedBridge")


class AddedBridge(
    private val activity: ComponentActivity,
    private val webView: WebView,
) {
    // @JavascriptInterface 메서드는 백그라운드(JavaBridge) 스레드에서 호출된다.
    // 화면 · 웹뷰 조작은 반드시 UI 스레드로 넘긴다(callback 은 내부에서 넘긴다).
    @JavascriptInterface
    fun interfaceName(message: String) {
        // 요청값 callback
        callback("interfaceName", "value")
    }

    /** App → Web 콜백(단일 값). JSON 인코딩으로 감싸 따옴표 · 역슬래시 · 줄바꿈이 섞여도 깨지지 않는다. */
    fun callback(name: String, value: String? = null) =
        evaluate(name, value?.let { JSONObject.quote(it) } ?: "")

    /** App → Web 콜백(다중 값). JSON 객체를 그대로 넘긴다. */
    fun callback(name: String, payload: JSONObject) = evaluate(name, payload.toString())

    private fun evaluate(name: String, arg: String) {
        // 웹이 아직 콜백을 등록하지 않았으면 조용히 넘어간다
        val js = "window.addedBridgeCallback&&addedBridgeCallback.$name&&addedBridgeCallback.$name($arg)"
        activity.runOnUiThread { webView.evaluateJavascript(js, null) }
    }
}

// 초기화 — handler 이름은 반드시 "addedBridge" (단일 채널에 method 를 실어 받는다)
let config = WKWebViewConfiguration()
config.userContentController.add(self, name: "addedBridge")
webView = WKWebView(frame: .zero, configuration: config)


func userContentController(
    _ userContentController: WKUserContentController,
    didReceive message: WKScriptMessage
) {
    guard message.name == "addedBridge" else { return }

    // body 는 { method, message } 객체다. JSON 문자열로 보내는 웹도 함께 받아 준다.
    var body = message.body as? [String: Any]
    if body == nil, let text = message.body as? String {
        body = object(text)
    }
    guard let body, let method = body["method"] as? String else { return }
    let param = body["message"] as? String ?? ""   // 값이 없는 호출은 빈 문자열

    switch method {
    case "interfaceName":
        // 요청값 callback
        callback("interfaceName", "value")
    default:
        break   // 미구현 메서드는 무시한다
    }
}

/// App → Web 콜백(단일 값). JSON 인코딩으로 감싸 따옴표 · 역슬래시 · 줄바꿈이 섞여도 깨지지 않는다.
func callback(_ name: String, _ value: String? = nil) {
    var arg = ""
    if let value, let data = try? JSONEncoder().encode(value) {
        arg = String(decoding: data, as: UTF8.self)
    }
    evaluate(name, arg)
}

/// App → Web 콜백(다중 값). JSON 객체를 그대로 넘긴다.
func callback(_ name: String, payload: [String: Any]) {
    guard let data = try? JSONSerialization.data(withJSONObject: payload) else { return }
    evaluate(name, String(decoding: data, as: UTF8.self))
}

private func evaluate(_ name: String, _ arg: String) {
    // 웹이 아직 콜백을 등록하지 않았으면 조용히 넘어간다
    let js = "window.addedBridgeCallback&&addedBridgeCallback.\(name)&&addedBridgeCallback.\(name)(\(arg))"
    DispatchQueue.main.async { self.webView.evaluateJavaScript(js) }
}

/// message(JSON 문자열) → 사전
func object(_ text: String) -> [String: Any]? {
    guard let data = text.data(using: .utf8) else { return nil }
    return (try? JSONSerialization.jsonObject(with: data)) as? [String: Any]
}

// 초기화 — 채널 이름은 반드시 'addedBridge'. 웹은 {method, message} JSON 문자열 1개를 보낸다
_controller = WebViewController()
  ..setJavaScriptMode(JavaScriptMode.unrestricted)
  ..addJavaScriptChannel(
    'addedBridge',
    onMessageReceived: (JavaScriptMessage m) {
      final Map<String, dynamic> body;
      try {
        body = jsonDecode(m.message) as Map<String, dynamic>;
      } catch (_) {
        return; // 형식이 다른 메시지는 무시
      }
      final method = body['method'] as String? ?? '';
      final message = body['message'] as String? ?? '';   // 값이 없는 호출은 빈 문자열
      _handle(method, message);
    },
  );


Future<void> _handle(String method, String message) async {
  switch (method) {
    case 'interfaceName':
      // 요청값 callback
      _callback('interfaceName', 'value');
      break;
  }
}

/// App → Web 콜백. jsonEncode 로 감싸 따옴표 · 역슬래시 · 줄바꿈이 섞여도 깨지지 않는다.
/// 단일 값은 String, 다중 값은 Map 을 넘긴다.
void _callback(String name, [Object? value]) {
  final arg = value == null ? '' : jsonEncode(value);
  // 웹이 아직 콜백을 등록하지 않았으면 조용히 넘어간다
  _controller.runJavaScript(
    'window.addedBridgeCallback&&addedBridgeCallback.$name&&addedBridgeCallback.$name($arg)',
  );
}

@JavascriptInterface
fun finish(message: String) {
    activity.runOnUiThread { activity.finish() }
}

case "finish":
    DispatchQueue.main.async {
        if let nav = self.navigationController {
            nav.popViewController(animated: true)
        } else {
            self.dismiss(animated: true)
        }
    }

case 'finish':
  if (mounted) Navigator.of(context).pop();
  break;

// AddedBridge — 웹이 보낸 등록 상태
@Volatile var isBackKeyRegistered = false

@JavascriptInterface
fun registerBackKey(message: String) {
    isBackKeyRegistered = message == "true"
}


// Activity — 시스템 뒤로가기(버튼 · 제스처) → onBackKeyListener
onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
    override fun handleOnBackPressed() {
        when {
            bridge.isBackKeyRegistered -> bridge.callback("onBackKeyListener")
            webView.canGoBack() -> webView.goBack()
            else -> finish()
        }
    }
})

var isBackKeyRegistered = false

case "registerBackKey":
    isBackKeyRegistered = (param == "true")


// 시스템 뒤로가기 제스처 — WKWebView 기본 스와이프 백 대신 엣지 제스처로 직접 받는다
// (UINavigationController 의 interactivePopGestureRecognizer 를 쓴다면 이 화면에서는 꺼 둔다)
webView.allowsBackForwardNavigationGestures = false
let edge = UIScreenEdgePanGestureRecognizer(target: self, action: #selector(onEdgeSwipe(_:)))
edge.edges = .left
webView.addGestureRecognizer(edge)

@objc private func onEdgeSwipe(_ gesture: UIScreenEdgePanGestureRecognizer) {
    guard gesture.state == .recognized else { return }

    if isBackKeyRegistered {
        callback("onBackKeyListener")
    } else if webView.canGoBack {
        webView.goBack()
    } else if let nav = navigationController {
        nav.popViewController(animated: true)
    } else {
        dismiss(animated: true)
    }
}

bool _isBackKeyRegistered = false;
bool _canGoBack = false;   // onPageFinished 등에서 await _controller.canGoBack() 으로 갱신

case 'registerBackKey':
  setState(() => _isBackKeyRegistered = message == 'true');
  break;


// 시스템 뒤로가기 / 제스처
PopScope(
  canPop: !_isBackKeyRegistered && !_canGoBack,
  onPopInvokedWithResult: (didPop, result) {
    if (didPop) return;

    if (_isBackKeyRegistered) {
      _callback('onBackKeyListener');
    } else if (_canGoBack) {
      _controller.goBack();
    }
  },
  child: WebViewWidget(controller: _controller),
)

// AddedBridge
@Volatile var isBackButtonRegistered = false

@JavascriptInterface
fun registerBackButton(message: String) {
    isBackButtonRegistered = message == "true"
}


// 앱바 백버튼 → onBackButtonListener
IconButton(onClick = {
    when {
        bridge.isBackButtonRegistered -> bridge.callback("onBackButtonListener")
        webView.canGoBack() -> webView.goBack()
        else -> activity.finish()
    }
}) {
    Icon(Icons.AutoMirrored.Filled.ArrowBack, "뒤로가기")
}

var isBackButtonRegistered = false

case "registerBackButton":
    isBackButtonRegistered = (param == "true")


// 앱바 백버튼 → onBackButtonListener
navigationItem.leftBarButtonItem = UIBarButtonItem(
    image: UIImage(systemName: "chevron.backward"), style: .plain,
    target: self, action: #selector(onBackButtonTapped)
)

@objc private func onBackButtonTapped() {
    if isBackButtonRegistered {
        callback("onBackButtonListener")
    } else if webView.canGoBack {
        webView.goBack()
    } else if let nav = navigationController {
        nav.popViewController(animated: true)
    } else {
        dismiss(animated: true)
    }
}

bool _isBackButtonRegistered = false;

case 'registerBackButton':
  setState(() => _isBackButtonRegistered = message == 'true');
  break;


AppBar(
  title: const Text('WebView'),
  leading: IconButton(
    icon: const Icon(Icons.arrow_back),
    onPressed: () {
      if (_isBackButtonRegistered) {
        _callback('onBackButtonListener');
      } else if (_canGoBack) {
        _controller.goBack();
      } else {
        Navigator.of(context).pop();
      }
    },
  ),
),

// 새 문서를 열기 시작하면 등록을 초기화한다
webView.webViewClient = object : WebViewClient() {
    override fun onPageStarted(view: WebView, url: String, favicon: Bitmap?) {
        bridge.isBackKeyRegistered = false
        bridge.isBackButtonRegistered = false
    }
}

// WKNavigationDelegate — 새 문서를 열기 시작하면 등록을 초기화한다
func webView(_ webView: WKWebView, didStartProvisionalNavigation navigation: WKNavigation!) {
    isBackKeyRegistered = false
    isBackButtonRegistered = false
}

// 새 문서를 열기 시작하면 등록을 초기화한다
_controller.setNavigationDelegate(NavigationDelegate(
  onPageStarted: (url) => setState(() {
    _isBackKeyRegistered = false;
    _isBackButtonRegistered = false;
  }),
));

@JavascriptInterface
fun getAppVersion(message: String) {
    val version = activity.packageManager
        .getPackageInfo(activity.packageName, 0).versionName ?: ""
    callback("getAppVersion", version)
}

case "getAppVersion":
    let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? ""
    callback("getAppVersion", version)

// pubspec.yaml: package_info_plus 패키지 필요
case 'getAppVersion':
  final info = await PackageInfo.fromPlatform();
  _callback('getAppVersion', info.version);
  break;

// Google Play Services Ads Identifier 의존성 필요
// implementation("com.google.android.gms:play-services-ads-identifier:18.x.x")
@JavascriptInterface
fun getADID(message: String) {
    // 블로킹 조회는 별도 스레드에서 한다 — JavaBridge 메서드가 반환할 때까지 웹의 JS 도 멈춘다
    thread {
        val adId = try {
            AdvertisingIdClient.getAdvertisingIdInfo(activity).id ?: ""
        } catch (e: Exception) {
            ""   // 실패해도 응답은 보낸다 — 응답이 없으면 웹은 상한까지 기다린다
        }
        callback("getADID", adId)
    }
}

// import AdSupport, AppTrackingTransparency
// Info.plist: NSUserTrackingUsageDescription 필요. 추적을 허용받지 못하면 IDFA 는 0 으로 온다
case "getADID":
    ATTrackingManager.requestTrackingAuthorization { _ in
        let adId = ASIdentifierManager.shared().advertisingIdentifier.uuidString
        self.callback("getADID", adId)
    }

// pubspec.yaml: advertising_id 패키지 필요
case 'getADID':
  final adId = await AdvertisingId.id(true) ?? '';
  _callback('getADID', adId);
  break;

@JavascriptInterface
fun getIsAgeUnder14(message: String) {
    // 앱에서 관리하는 유저 나이 정책에 맞게 구현 — 알 수 없으면 빈 문자열
    val isUnder14: Boolean? = userRepository.isAgeUnder14()
    callback("getIsAgeUnder14", isUnder14?.toString() ?: "")
}

case "getIsAgeUnder14":
    // 앱에서 관리하는 유저 나이 정책에 맞게 구현 — 알 수 없으면 빈 문자열
    let isUnder14: Bool? = UserRepository.shared.isAgeUnder14
    callback("getIsAgeUnder14", isUnder14.map { $0 ? "true" : "false" } ?? "")

case 'getIsAgeUnder14':
  // 앱에서 관리하는 유저 나이 정책에 맞게 구현 — 알 수 없으면 빈 문자열
  final bool? isUnder14 = userRepository.isAgeUnder14;
  _callback('getIsAgeUnder14', isUnder14 == null ? '' : '$isUnder14');
  break;

@JavascriptInterface
fun getDeviceInfo(message: String) {
    val cm = activity.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val caps = cm.getNetworkCapabilities(cm.activeNetwork)
    val network = when {
        caps?.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) == true -> "wifi"
        caps?.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) == true -> "mobile"
        else -> ""
    }
    val json = JSONObject()
        .put("network", network)
        .put("model", Build.MODEL)
        .put("manufacturer", Build.MANUFACTURER)
        .put("osVersion", Build.VERSION.RELEASE)
        .toString()
    callback("getDeviceInfo", json)   // JSON 문자열로 전달
}

case "getDeviceInfo":
    let info: [String: String] = [
        "network": NetworkMonitor.shared.currentType(),   // "wifi" | "mobile" — 앱의 NWPathMonitor 래퍼
        "model": UIDevice.current.model,
        "manufacturer": "Apple",
        "osVersion": UIDevice.current.systemVersion,
    ]
    if let data = try? JSONSerialization.data(withJSONObject: info) {
        callback("getDeviceInfo", String(decoding: data, as: UTF8.self))   // JSON 문자열로 전달
    }

// pubspec.yaml: device_info_plus, connectivity_plus(6.x) 패키지 필요
case 'getDeviceInfo':
  final deviceInfo = DeviceInfoPlugin();
  final connectivity = await Connectivity().checkConnectivity();   // List<ConnectivityResult>
  final network = connectivity.contains(ConnectivityResult.wifi)
      ? 'wifi'
      : connectivity.contains(ConnectivityResult.mobile) ? 'mobile' : '';
  String model = '', manufacturer = '', osVersion = '';
  if (Platform.isAndroid) {
    final android = await deviceInfo.androidInfo;
    model = android.model;
    manufacturer = android.manufacturer;
    osVersion = android.version.release;
  } else if (Platform.isIOS) {
    final ios = await deviceInfo.iosInfo;
    model = ios.model;
    manufacturer = 'Apple';
    osVersion = ios.systemVersion;
  }
  _callback('getDeviceInfo', jsonEncode({   // JSON 문자열로 전달
    'network': network,
    'model': model,
    'manufacturer': manufacturer,
    'osVersion': osVersion,
  }));
  break;

@JavascriptInterface
fun pushUrl(message: String) {
    val obj = JSONObject(message)
    val url = obj.optString("url")
    val replace = obj.optBoolean("replace", false)
    activity.runOnUiThread {
        webView.loadUrl(url)
        // replace=true: WebView 에는 항목 교체 API 가 없다 —
        // 로드가 끝난 뒤(onPageFinished) clearHistory() 로 이전 항목을 지운다
    }
}

case "pushUrl":
    guard let json = object(param),
          let urlStr = json["url"] as? String,
          let url = URL(string: urlStr) else { return }
    let replace = json["replace"] as? Bool ?? false
    DispatchQueue.main.async {
        self.webView.load(URLRequest(url: url))
        // replace=true: WKWebView 에는 히스토리 항목을 지우는 API 가 없어 별도 정책이 필요하다
    }

case 'pushUrl':
  final data = jsonDecode(message) as Map<String, dynamic>;
  final url = data['url'] as String;
  final replace = (data['replace'] as bool?) ?? false;
  _controller.loadRequest(Uri.parse(url));
  // replace=true 의 경우 history 관리 정책 필요
  break;

@JavascriptInterface
fun openInternalBrowser(message: String) {
    activity.runOnUiThread {
        val intent = Intent(activity, WebViewActivity::class.java).apply {
            putExtra("url", message)
        }
        activity.startActivity(intent)
    }
}

case "openInternalBrowser":
    guard let url = URL(string: param) else { return }
    DispatchQueue.main.async {
        let vc = WebViewController(url: url)
        if let nav = self.navigationController {
            nav.pushViewController(vc, animated: true)
        } else {
            self.present(vc, animated: true)
        }
    }

case 'openInternalBrowser':
  Navigator.of(context).push(MaterialPageRoute(
    builder: (_) => WebViewPage(url: message),
  ));
  break;

@JavascriptInterface
fun setTitle(message: String) {
    activity.runOnUiThread {
        // Compose 상태값 업데이트 등 앱바 구현에 맞게 반영
        appBarTitle.value = message
    }
}

case "setTitle":
    DispatchQueue.main.async {
        self.title = param
        self.navigationItem.title = param
    }

case 'setTitle':
  setState(() => _title = message);
  break;

// build.gradle: implementation("com.google.android.gms:play-services-ads:24.x.x")
// AndroidManifest: <meta-data android:name="com.google.android.gms.ads.APPLICATION_ID" .../>

// 앱 시작 시 1회
MobileAds.initialize(context) {}

@JavascriptInterface
fun adInit(message: String) {
    // message = { test, networks:[{ key:"admob", app:{ appId } }] }
    val obj = JSONObject(message)
    if (obj.optBoolean("test")) {
        MobileAds.setRequestConfiguration(
            RequestConfiguration.Builder()
                .setTestDeviceIds(listOf(AdRequest.DEVICE_ID_EMULATOR))
                .build()
        )
    }
}

// SPM: Google-Mobile-Ads-SDK 12 (import GoogleMobileAds)
// Info.plist: GADApplicationIdentifier = ca-app-pub-XXXX~YYYY

// 앱 시작 시 1회
MobileAds.shared.start(completionHandler: nil)

case "adInit":
    // 시뮬레이터는 자동으로 테스트 기기다. 실기기는 콘솔 로그에 찍히는 기기 ID 를 넣는다
    if object(param)?["test"] as? Bool == true {
        MobileAds.shared.requestConfiguration.testDeviceIdentifiers = ["<테스트 기기 ID>"]
    }

// pubspec.yaml: google_mobile_ads
// 앱 시작 시 1회
await MobileAds.instance.initialize();

case 'adInit':
  final obj = jsonDecode(message) as Map<String, dynamic>;
  if (obj['test'] == true) {
    MobileAds.instance.updateRequestConfiguration(
      RequestConfiguration(testDeviceIds: ['<테스트 기기 ID>']),
    );
  }
  break;

private val loadedAds = ConcurrentHashMap<String, Any>()   // requestId → RewardedAd | InterstitialAd
private val defaultUnits = mapOf(                          // ids.adUnitId 가 비었을 때
    "rewarded" to "ca-app-pub-XXXX/ZZZZ",
    "interstitial" to "ca-app-pub-XXXX/WWWW",
)

// 광고 콜백 — payload 는 객체로 전달(웹은 객체/JSON 문자열 모두 허용)
private fun adEvent(name: String, requestId: String, vararg extra: Pair<String, Any>) {
    val payload = JSONObject().put("requestId", requestId)
    extra.forEach { payload.put(it.first, it.second) }
    callback(name, payload)
}

@JavascriptInterface
fun adLoad(message: String) {
    val obj = JSONObject(message)
    val requestId = obj.optString("requestId")
    val format = obj.optString("format")
    // 지원하지 않는 형식은 즉시 실패로 알린다(웹이 상한까지 기다리지 않게)
    val fallbackUnit = defaultUnits[format]
        ?: return adEvent("onAdFailed", requestId, "stage" to "load", "code" to "UNSUPPORTED_FORMAT")
    val adUnitId = obj.optJSONObject("ids")?.optString("adUnitId").orEmpty().ifBlank { fallbackUnit }

    fun loaded(ad: Any) {
        loadedAds[requestId] = ad
        adEvent("onAdLoaded", requestId)
    }
    fun failed(e: LoadAdError) =
        adEvent("onAdFailed", requestId, "stage" to "load", "code" to e.code.toString())

    activity.runOnUiThread {
        val request = AdRequest.Builder().build()
        when (format) {
            "rewarded" -> RewardedAd.load(activity, adUnitId, request,
                object : RewardedAdLoadCallback() {
                    override fun onAdLoaded(ad: RewardedAd) = loaded(ad)
                    override fun onAdFailedToLoad(e: LoadAdError) = failed(e)
                })
            "interstitial" -> InterstitialAd.load(activity, adUnitId, request,
                object : InterstitialAdLoadCallback() {
                    override fun onAdLoaded(ad: InterstitialAd) = loaded(ad)
                    override fun onAdFailedToLoad(e: LoadAdError) = failed(e)
                })
        }
    }
}

private var loadedAds: [String: FullScreenPresentingAd] = [:]   // requestId → RewardedAd | InterstitialAd
private var showing: [ObjectIdentifier: String] = [:]            // 표시 중인 광고 → requestId
private let defaultUnits = [                                     // ids.adUnitId 가 비었을 때
    "rewarded": "ca-app-pub-XXXX/ZZZZ",
    "interstitial": "ca-app-pub-XXXX/WWWW",
]

// 광고 콜백 — payload 는 객체로 전달
func adEvent(_ name: String, _ requestId: String, _ extra: [String: Any] = [:]) {
    var payload = extra
    payload["requestId"] = requestId
    callback(name, payload: payload)
}

case "adLoad":
    guard let json = object(param), let requestId = json["requestId"] as? String else { return }
    let format = json["format"] as? String ?? ""
    guard let fallbackUnit = defaultUnits[format] else {
        // 지원하지 않는 형식은 즉시 실패로 알린다(웹이 상한까지 기다리지 않게)
        adEvent("onAdFailed", requestId, ["stage": "load", "code": "UNSUPPORTED_FORMAT"])
        return
    }
    let ids = json["ids"] as? [String: Any]
    let unit = (ids?["adUnitId"] as? String).flatMap { $0.isEmpty ? nil : $0 } ?? fallbackUnit

    // 로드 결과 — 두 형식이 같은 처리를 쓴다
    let done: (FullScreenPresentingAd?, Error?) -> Void = { [weak self] ad, error in
        guard let self else { return }
        if let ad {
            self.loadedAds[requestId] = ad
            self.adEvent("onAdLoaded", requestId)
        } else {
            self.adEvent("onAdFailed", requestId, ["stage": "load", "code": "\((error as NSError?)?.code ?? -1)"])
        }
    }
    if format == "rewarded" {
        RewardedAd.load(with: unit, request: Request()) { ad, error in done(ad, error) }
    } else {
        InterstitialAd.load(with: unit, request: Request()) { ad, error in done(ad, error) }
    }

final Map<String, AdWithoutView> _loadedAds = {};   // requestId → RewardedAd | InterstitialAd
static const _defaultUnits = {                       // ids.adUnitId 가 비었을 때
  'rewarded': 'ca-app-pub-XXXX/ZZZZ',
  'interstitial': 'ca-app-pub-XXXX/WWWW',
};

// 광고 콜백 — payload 는 객체로 전달
void _adEvent(String name, String requestId, [Map<String, Object?> extra = const {}]) =>
    _callback(name, {'requestId': requestId, ...extra});

case 'adLoad':
  final obj = jsonDecode(message) as Map<String, dynamic>;
  final requestId = obj['requestId'] as String;
  final format = obj['format'] as String? ?? '';
  final fallbackUnit = _defaultUnits[format];
  if (fallbackUnit == null) {
    // 지원하지 않는 형식은 즉시 실패로 알린다(웹이 상한까지 기다리지 않게)
    _adEvent('onAdFailed', requestId, {'stage': 'load', 'code': 'UNSUPPORTED_FORMAT'});
    break;
  }
  final unit = (obj['ids']?['adUnitId'] as String?) ?? '';
  final adUnitId = unit.isEmpty ? fallbackUnit : unit;

  void loaded(AdWithoutView ad) {
    _loadedAds[requestId] = ad;
    _adEvent('onAdLoaded', requestId);
  }
  void failed(LoadAdError err) =>
      _adEvent('onAdFailed', requestId, {'stage': 'load', 'code': err.code.toString()});

  if (format == 'rewarded') {
    RewardedAd.load(
      adUnitId: adUnitId,
      request: const AdRequest(),
      rewardedAdLoadCallback: RewardedAdLoadCallback(onAdLoaded: loaded, onAdFailedToLoad: failed),
    );
  } else {
    InterstitialAd.load(
      adUnitId: adUnitId,
      request: const AdRequest(),
      adLoadCallback: InterstitialAdLoadCallback(onAdLoaded: loaded, onAdFailedToLoad: failed),
    );
  }
  break;

// 호스트는 adShowRewarded 와 adShow 를 모두 받는다 — 둘 다 requestId 로 로드한 광고를 그 형식대로 표시한다
@JavascriptInterface
fun adShowRewarded(message: String) = showAd(JSONObject(message).optString("requestId"))

@JavascriptInterface
fun adShow(message: String) = showAd(JSONObject(message).optString("requestId"))

private fun showAd(requestId: String) {
    val ad = loadedAds.remove(requestId)         // 1회성 — 표시하며 캐시에서 제거
        ?: return adEvent("onAdFailed", requestId, "stage" to "show", "code" to "NOT_READY")
    // 노출/클릭/닫힘/실패 — 두 형식이 같은 전체화면 콜백을 쓴다
    val callback = object : FullScreenContentCallback() {
        override fun onAdShowedFullScreenContent() = adEvent("onAdShown", requestId)
        override fun onAdClicked() = adEvent("onAdClicked", requestId)
        override fun onAdDismissedFullScreenContent() = adEvent("onAdClosed", requestId)
        override fun onAdFailedToShowFullScreenContent(e: AdError) =
            adEvent("onAdFailed", requestId, "stage" to "show", "code" to e.code.toString())
    }
    activity.runOnUiThread {
        when (ad) {
            is RewardedAd -> {
                ad.fullScreenContentCallback = callback
                ad.show(activity) { reward ->        // 보상 조건 충족 — onAdClosed 보다 먼저 보낸다
                    adEvent("onAdRewarded", requestId, "type" to reward.type, "amount" to reward.amount)
                }
            }
            is InterstitialAd -> {                   // 전면형 — 보상 콜백 없음
                ad.fullScreenContentCallback = callback
                ad.show(activity)
            }
        }
    }
}

// 호스트는 adShowRewarded 와 adShow 를 모두 받는다 — 둘 다 requestId 로 로드한 광고를 그 형식대로 표시한다
case "adShowRewarded", "adShow":
    guard let requestId = object(param)?["requestId"] as? String else { return }
    guard let ad = loadedAds.removeValue(forKey: requestId) else {   // 1회성 — 표시하며 캐시에서 제거
        adEvent("onAdFailed", requestId, ["stage": "show", "code": "NOT_READY"])
        return
    }
    showing[ObjectIdentifier(ad as AnyObject)] = requestId
    ad.fullScreenContentDelegate = self          // SDK 가 전체화면/닫기 UI 를 소유
    if let rewarded = ad as? RewardedAd {
        rewarded.present(from: self) {           // 보상 조건 충족 — onAdClosed 보다 먼저 보낸다
            let r = rewarded.adReward
            self.adEvent("onAdRewarded", requestId, ["type": r.type, "amount": r.amount.intValue])
        }
    } else if let interstitial = ad as? InterstitialAd {
        interstitial.present(from: self)         // 전면형 — 보상 콜백 없음
    }


// FullScreenContentDelegate — 표시 중인 광고 → requestId (두 형식 공통)
private func requestId(of ad: FullScreenPresentingAd) -> String {
    showing[ObjectIdentifier(ad as AnyObject)] ?? ""
}
func adDidRecordImpression(_ ad: FullScreenPresentingAd) { adEvent("onAdShown", requestId(of: ad)) }
func adDidRecordClick(_ ad: FullScreenPresentingAd) { adEvent("onAdClicked", requestId(of: ad)) }
func adDidDismissFullScreenContent(_ ad: FullScreenPresentingAd) {
    let rid = requestId(of: ad)
    showing[ObjectIdentifier(ad as AnyObject)] = nil
    adEvent("onAdClosed", rid)
}
func ad(_ ad: FullScreenPresentingAd, didFailToPresentFullScreenContentWithError error: Error) {
    adEvent("onAdFailed", requestId(of: ad), ["stage": "show", "code": "\((error as NSError).code)"])
}

// 호스트는 adShowRewarded 와 adShow 를 모두 받는다 — 둘 다 requestId 로 로드한 광고를 그 형식대로 표시한다
case 'adShowRewarded':
case 'adShow':
  final requestId = (jsonDecode(message) as Map<String, dynamic>)['requestId'] as String;
  final ad = _loadedAds.remove(requestId);       // 1회성 — 표시하며 캐시에서 제거
  if (ad is RewardedAd) {
    ad.fullScreenContentCallback = _fullScreenCallback<RewardedAd>(requestId);
    ad.show(onUserEarnedReward: (ad, reward) {   // 보상 조건 충족 — onAdClosed 보다 먼저 보낸다
      _adEvent('onAdRewarded', requestId, {'type': reward.type, 'amount': reward.amount});
    });
  } else if (ad is InterstitialAd) {
    ad.fullScreenContentCallback = _fullScreenCallback<InterstitialAd>(requestId);
    ad.show();                                   // 전면형 — 보상 콜백 없음
  } else {
    _adEvent('onAdFailed', requestId, {'stage': 'show', 'code': 'NOT_READY'});
  }
  break;


// 노출/클릭/닫힘/실패 — 두 형식이 같은 전체화면 콜백을 쓴다
FullScreenContentCallback<T> _fullScreenCallback<T extends AdWithoutView>(String requestId) =>
    FullScreenContentCallback<T>(
      onAdShowedFullScreenContent: (ad) => _adEvent('onAdShown', requestId),
      onAdClicked: (ad) => _adEvent('onAdClicked', requestId),
      onAdDismissedFullScreenContent: (ad) {
        ad.dispose();
        _adEvent('onAdClosed', requestId);
      },
      onAdFailedToShowFullScreenContent: (ad, err) {
        ad.dispose();
        _adEvent('onAdFailed', requestId, {'stage': 'show', 'code': err.code.toString()});
      },
    );

@JavascriptInterface
fun adDestroy(message: String) {
    loadedAds.remove(JSONObject(message).optString("requestId"))
}

case "adDestroy":
    if let requestId = object(param)?["requestId"] as? String {
        loadedAds.removeValue(forKey: requestId)
    }

case 'adDestroy':
  final requestId = (jsonDecode(message) as Map<String, dynamic>)['requestId'] as String;
  _loadedAds.remove(requestId)?.dispose();
  break;