lingxia-platform 0.18.0

use super::with_env;
use crate::AssetFileEntry;
use crate::error::PlatformError;
use crate::traits::app_runtime::AppRuntime;
use crate::traits::app_runtime::LxAppOpenMode;
use jni::objects::{Global, JClass, JObject, JString, JValue};
use jni::sys::jobject;
use jni::{Env, jni_sig, jni_str};
use std::ffi::CString;
use std::io::{Read, Result as IoResult};
use std::path::{Path, PathBuf};

// Platform for Android
pub struct Platform {
    asset_manager: *mut ndk_sys::AAssetManager,
    java_asset_manager: Global<JObject<'static>>,
    data_dir: String,
    cache_dir: String,
    locale: String,
}

impl Clone for Platform {
    fn clone(&self) -> Self {
        let java_asset_manager = with_env(
            |env| -> Result<Global<JObject<'static>>, Box<dyn std::error::Error>> {
                Ok(env.new_global_ref(self.java_asset_manager.as_ref())?)
            },
        )
        .expect("Failed to clone Platform java_asset_manager");

        Platform {
            asset_manager: self.asset_manager,
            java_asset_manager,
            data_dir: self.data_dir.clone(),
            cache_dir: self.cache_dir.clone(),
            locale: self.locale.clone(),
        }
    }
}

unsafe impl Send for Platform {}
unsafe impl Sync for Platform {}

fn android_installed_from_store() -> bool {
    let Ok(update_manager_class) = super::get_cached_class(super::CachedClass::UpdateManager)
    else {
        return false;
    };
    with_env(|env| -> Result<bool, PlatformError> {
        let result = env.call_static_method(
            update_manager_class,
            jni_str!("installedFromStore"),
            jni_sig!("()Z"),
            &[],
        )?;
        Ok(result.z()?)
    })
    .unwrap_or(false)
}

fn android_update_manager_bool(open_store: bool, info_json: &str) -> Result<bool, PlatformError> {
    let update_manager_class: &JClass = super::get_cached_class(super::CachedClass::UpdateManager)
        .map_err(|e| PlatformError::Platform(e.to_string()))?;
    with_env(|env| -> Result<bool, PlatformError> {
        let info_jstring = env.new_string(info_json)?;
        let result = if open_store {
            env.call_static_method(
                update_manager_class,
                jni_str!("openUpdateStore"),
                jni_sig!("(Ljava/lang/String;)Z"),
                &[JValue::Object(&info_jstring)],
            )?
        } else {
            env.call_static_method(
                update_manager_class,
                jni_str!("presentStoreUpdate"),
                jni_sig!("(Ljava/lang/String;)Z"),
                &[JValue::Object(&info_jstring)],
            )?
        };
        Ok(result.z()?)
    })
    .map_err(|e| PlatformError::Platform(format!("Failed to call UpdateManager: {e}")))
}

impl crate::traits::update::UpdateService for Platform {
    fn self_update_supported(&self) -> bool {
        // Android can install via PackageInstaller when the channel is direct.
        true
    }

    fn installed_from_store(&self) -> bool {
        android_installed_from_store()
    }

    fn open_update_store(&self, info_json: &str) -> Result<bool, PlatformError> {
        android_update_manager_bool(true, info_json)
    }

    fn present_store_update(&self, info_json: &str) -> Result<bool, PlatformError> {
        android_update_manager_bool(false, info_json)
    }

    fn install_update(&self, apk_path: &Path, info_json: &str) -> Result<(), PlatformError> {
        let update_manager_class: &JClass =
            super::get_cached_class(super::CachedClass::UpdateManager)
                .map_err(|e| PlatformError::Platform(e.to_string()))?;

        with_env(|env| -> Result<(), PlatformError> {
            let path_str = apk_path
                .to_str()
                .ok_or_else(|| PlatformError::Platform("Invalid APK path".to_string()))?;
            let path_jstring = env.new_string(path_str)?;
            let info_jstring = env.new_string(info_json)?;

            let result = env.call_static_method(
                update_manager_class,
                jni_str!("installUpdate"),
                jni_sig!("(Ljava/lang/String;Ljava/lang/String;)Z"),
                &[JValue::Object(&path_jstring), JValue::Object(&info_jstring)],
            )?;
            if !result.z()? {
                return Err(PlatformError::Platform(
                    "installUpdate returned false".to_string(),
                ));
            }
            Ok(())
        })
        .map_err(|e| PlatformError::Platform(format!("Failed to install update: {}", e)))
    }
}

/// Reader for a single asset file
struct AssetReader {
    asset: *mut ndk_sys::AAsset,
}

impl Read for AssetReader {
    fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
        let read =
            unsafe { ndk_sys::AAsset_read(self.asset, buf.as_mut_ptr() as *mut _, buf.len()) };
        if read < 0 {
            Err(std::io::Error::other("AAsset_read failed"))
        } else {
            Ok(read as usize)
        }
    }
}

impl Drop for AssetReader {
    fn drop(&mut self) {
        unsafe { ndk_sys::AAsset_close(self.asset) };
    }
}

// Using Java AssetManager.list() via JNI for directory listing because the NDK's
// AAssetManager_openDir and AAssetDir_getNextFileName have shown inconsistent behavior
// in listing subdirectories or distinguishing files from directories reliably across
// all scenarios in this project. The Java API is generally more robust for listing.
// NDK AAssetManager_open() is still used for reading files once paths are known.
struct RecursiveAssetIterator<'a> {
    app: &'a Platform,
    // Stack of directory paths (relative to asset root) to visit.
    dir_stack: Vec<String>,
    // Queue of discovered file paths (full paths) ready to be yielded.
    file_queue: Vec<String>,
    _marker: std::marker::PhantomData<&'a ()>,
}

impl<'a> RecursiveAssetIterator<'a> {
    fn new(app: &'a Platform, initial_path: &str) -> Self {
        RecursiveAssetIterator {
            app,
            dir_stack: vec![initial_path.to_string()],
            file_queue: Vec::new(),
            _marker: std::marker::PhantomData,
        }
    }

    // Helper function to simplify error handling for JNI operations
    fn handle_jni_error<T>(
        result: Result<T, jni::errors::Error>,
        path: &str,
    ) -> Result<T, PlatformError> {
        result.map_err(|e| {
            PlatformError::Platform(format!("JNI operation failed for path '{}': {:?}", path, e))
        })
    }

    fn list_via_jni(&self, path_to_list: &str) -> Result<Option<Vec<String>>, PlatformError> {
        with_env(|env| -> Result<Option<Vec<String>>, PlatformError> {
            let path_jstring = Self::handle_jni_error(env.new_string(path_to_list), path_to_list)?;

            let java_am_obj = self.app.java_asset_manager.as_ref();
            let jvalue = Self::handle_jni_error(
                env.call_method(
                    java_am_obj,
                    jni_str!("list"),
                    jni_sig!("(Ljava/lang/String;)[Ljava/lang/String;"),
                    &[JValue::from(&path_jstring)],
                ),
                path_to_list,
            )?;

            if env.exception_check() {
                env.exception_clear();
                Ok(None)
            } else {
                let jobject_array = Self::handle_jni_error(jvalue.l(), path_to_list)?;

                if jobject_array.is_null() {
                    Ok(None)
                } else {
                    let jobject_array = unsafe {
                        jni::objects::JObjectArray::<JObject>::from_raw(
                            env,
                            jobject_array.into_raw() as _,
                        )
                    };
                    let array_len = jobject_array.len(env)?;

                    if array_len == 0 {
                        return Ok(Some(Vec::new()));
                    }

                    let mut entries = Vec::with_capacity(array_len);
                    for i in 0..array_len {
                        let entry_str = env.with_local_frame(1, |env| {
                            let entry_jobject: JObject = jobject_array.get_element(env, i)?;
                            let entry_jstring_wrapper = unsafe {
                                jni::objects::JString::from_raw(env, entry_jobject.into_raw() as _)
                            };
                            Self::handle_jni_error(
                                entry_jstring_wrapper.try_to_string(env),
                                path_to_list,
                            )
                        })?;
                        entries.push(entry_str);
                    }
                    Ok(Some(entries))
                }
            }
        })
        .map_err(|e| PlatformError::Platform(format!("Failed to get JNIEnv: {}", e)))
    }
}

impl<'a> Iterator for RecursiveAssetIterator<'a> {
    type Item = Result<AssetFileEntry<'a>, PlatformError>;

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            if let Some(file_path_to_yield) = self.file_queue.pop() {
                let c_path = match CString::new(file_path_to_yield.clone()) {
                    Ok(c) => c,
                    Err(e) => {
                        return Some(Err(PlatformError::Platform(format!(
                            "Invalid CString for asset path '{}': {}",
                            file_path_to_yield, e
                        ))));
                    }
                };
                unsafe {
                    let asset_ptr = ndk_sys::AAssetManager_open(
                        self.app.asset_manager,
                        c_path.as_ptr(),
                        ndk_sys::AASSET_MODE_STREAMING as i32,
                    );
                    if asset_ptr.is_null() {
                        return Some(Err(PlatformError::Platform(format!(
                            "Asset '{}' was in file_queue, but NDK AAssetManager_open failed.",
                            file_path_to_yield
                        ))));
                    }
                    let reader = AssetReader { asset: asset_ptr };
                    return Some(Ok(AssetFileEntry {
                        path: file_path_to_yield,
                        reader: Box::new(reader),
                    }));
                }
            }

            if let Some(dir_to_scan) = self.dir_stack.pop() {
                match self.list_via_jni(&dir_to_scan) {
                    Ok(Some(child_entry_names)) => {
                        let mut discovered_files_in_this_scan = Vec::new();
                        for child_name in child_entry_names {
                            let full_child_path = if dir_to_scan.is_empty() {
                                child_name
                            } else {
                                format!("{}/{}", dir_to_scan, child_name)
                            };

                            let c_full_child_path = match CString::new(full_child_path.clone()) {
                                Ok(c) => c,
                                Err(_e) => continue,
                            };
                            let asset_ptr_check = unsafe {
                                ndk_sys::AAssetManager_open(
                                    self.app.asset_manager,
                                    c_full_child_path.as_ptr(),
                                    ndk_sys::AASSET_MODE_STREAMING as i32,
                                )
                            };

                            if !asset_ptr_check.is_null() {
                                unsafe { ndk_sys::AAsset_close(asset_ptr_check) };
                                discovered_files_in_this_scan.push(full_child_path);
                            } else {
                                self.dir_stack.push(full_child_path);
                            }
                        }
                        discovered_files_in_this_scan.reverse();
                        self.file_queue.append(&mut discovered_files_in_this_scan);
                        continue;
                    }
                    Ok(None) => continue,
                    Err(e) => return Some(Err(e)),
                }
            } else {
                return None;
            }
        }
    }
}

impl Platform {
    /// # Safety
    /// Caller must ensure `java_asset_manager_obj` is a valid `android.content.res.AssetManager`
    /// and `java_application_context_obj` is a valid `android.content.Context`.
    pub unsafe fn from_java(
        jni_env: &mut Env,
        java_asset_manager_obj: jobject,
        java_application_context_obj: jobject,
        data_dir: String,
        cache_dir: String,
        locale: String,
    ) -> Result<Self, String> {
        // Get the native asset manager pointer from the Java AssetManager
        let asset_manager_ptr = unsafe {
            ndk_sys::AAssetManager_fromJava(
                jni_env.get_raw() as *mut _,
                java_asset_manager_obj as *mut _,
            )
        };

        if asset_manager_ptr.is_null() {
            return Err("Failed to get native AssetManager".to_string());
        }

        // Create a global reference to the Java AssetManager for later use
        let java_asset_manager = jni_env
            .new_global_ref(unsafe { JObject::from_raw(jni_env, java_asset_manager_obj) })
            .map_err(|e| format!("Failed to create global reference: {:?}", e))?;

        // Register the host application context so platform APIs that need a
        // Context (display metrics, Settings.Secure, resources) can resolve
        // it without going through the lxapp business layer.
        let app_context = unsafe { JObject::from_raw(jni_env, java_application_context_obj) };
        if app_context.is_null() {
            return Err("Application context is null".to_string());
        }
        super::set_application_context(jni_env, &app_context)?;

        Ok(Platform {
            asset_manager: asset_manager_ptr,
            java_asset_manager,
            data_dir,
            cache_dir,
            locale,
        })
    }

    fn resolve_app_identifier(jni_env: &mut Env) -> Result<String, PlatformError> {
        let context = super::application_context(jni_env).ok_or_else(|| {
            PlatformError::Platform(
                "Application context not registered via set_application_context".to_string(),
            )
        })?;

        let package_obj = jni_env
            .call_method(
                context,
                jni_str!("getPackageName"),
                jni_sig!("()Ljava/lang/String;"),
                &[],
            )
            .and_then(|val| val.l())
            .map_err(|e| PlatformError::Platform(format!("Failed to get package name: {:?}", e)))?;
        if package_obj.is_null() {
            return Err(PlatformError::Platform("Package name is null".to_string()));
        }

        let package_jstring = unsafe { JString::from_raw(jni_env, package_obj.into_raw() as _) };
        let package_name = package_jstring.try_to_string(jni_env).map_err(|e| {
            PlatformError::Platform(format!("Failed to read package name: {:?}", e))
        })?;

        Ok(package_name)
    }
}

impl AppRuntime for Platform {
    /// Read asset file from platform-specific location as a streaming reader
    fn read_asset<'a>(&'a self, path: &str) -> Result<Box<dyn Read + 'a>, PlatformError> {
        unsafe {
            // Convert path to CString to ensure proper null-termination
            let c_path = std::ffi::CString::new(path)
                .map_err(|e| PlatformError::Platform(format!("Invalid path: {}", e)))?;

            let asset = ndk_sys::AAssetManager_open(
                self.asset_manager,
                c_path.as_ptr(),
                ndk_sys::AASSET_MODE_STREAMING as i32,
            );

            if asset.is_null() {
                return Err(PlatformError::AssetNotFound(format!(
                    "Failed to open asset: {}",
                    path
                )));
            }

            // Return a reader instead of reading the entire asset into memory
            Ok(Box::new(AssetReader { asset }))
        }
    }

    /// Iterate over files in an asset directory
    fn asset_dir_iter<'a>(
        &'a self,
        asset_dir: &str,
    ) -> Box<dyn Iterator<Item = Result<AssetFileEntry<'a>, PlatformError>> + 'a> {
        Box::new(RecursiveAssetIterator::new(self, asset_dir))
    }

    /// Get data directory path
    fn app_data_dir(&self) -> PathBuf {
        PathBuf::from(&self.data_dir)
    }

    /// Get cache directory path
    fn app_cache_dir(&self) -> PathBuf {
        PathBuf::from(&self.cache_dir)
    }

    fn get_app_identifier(&self) -> Result<String, PlatformError> {
        with_env(Platform::resolve_app_identifier)
            .map_err(|e| PlatformError::Platform(format!("Failed to get app identifier: {}", e)))
    }

    fn copy_album_media_to_file(
        &self,
        uri: &str,
        dest_path: &Path,
        kind: crate::traits::media_interaction::MediaKind,
    ) -> Result<(), PlatformError> {
        crate::traits::media_runtime::MediaRuntime::copy_album_media_to_file(
            self, uri, dest_path, kind,
        )
    }

    fn get_system_locale(&self) -> &str {
        &self.locale
    }

    fn show_lxapp(
        &self,
        appid: String,
        _title: String,
        path: String,
        _webtag: String,
        session_id: u64,
        _open_mode: LxAppOpenMode,
        _panel_id: String,
    ) -> Result<(), PlatformError> {
        let bridge_class: &JClass = super::get_cached_class(super::CachedClass::LxApp)
            .map_err(|e| PlatformError::Platform(e.to_string()))?;
        with_env(|env| -> Result<(), PlatformError> {
            let appid_jstring = env.new_string(&appid)?;
            let path_jstring = env.new_string(&path)?;

            env.call_static_method(
                bridge_class,
                jni_str!("open"),
                jni_sig!("(Ljava/lang/String;Ljava/lang/String;J)V"),
                &[
                    JValue::Object(&appid_jstring),
                    JValue::Object(&path_jstring),
                    JValue::Long(session_id as i64),
                ],
            )?;
            Ok(())
        })
        .map_err(|e| PlatformError::Platform(format!("Failed to show lxapp: {}", e)))
    }

    fn hide_lxapp(&self, appid: String, session_id: u64) -> Result<(), PlatformError> {
        let bridge_class: &JClass = super::get_cached_class(super::CachedClass::LxApp)
            .map_err(|e| PlatformError::Platform(e.to_string()))?;
        with_env(|env| -> Result<(), PlatformError> {
            let appid_jstring = env.new_string(&appid)?;
            env.call_static_method(
                bridge_class,
                jni_str!("close"),
                jni_sig!("(Ljava/lang/String;J)V"),
                &[
                    JValue::Object(&appid_jstring),
                    JValue::Long(session_id as i64),
                ],
            )?;
            Ok(())
        })
        .map_err(|e| PlatformError::Platform(format!("Failed to hide lxapp: {}", e)))
    }

    fn exit(&self) -> Result<(), PlatformError> {
        let host_class: &JClass = super::get_cached_class(super::CachedClass::Lingxia)
            .map_err(|e| PlatformError::Platform(e.to_string()))?;
        with_env(|env| -> Result<(), PlatformError> {
            let result =
                env.call_static_method(host_class, jni_str!("exitApp"), jni_sig!("()Z"), &[])?;
            if !result.z()? {
                return Err(PlatformError::Platform(
                    "exitApp returned false".to_string(),
                ));
            }
            Ok(())
        })
        .map_err(|e| PlatformError::Platform(format!("Failed to exit app: {}", e)))
    }

    fn navigate(
        &self,
        appid: String,
        path: String,
        _webtag: String,
        animation_type: crate::traits::app_runtime::AnimationType,
    ) -> Result<(), PlatformError> {
        let bridge_class: &JClass = super::get_cached_class(super::CachedClass::LxApp)
            .map_err(|e| PlatformError::Platform(e.to_string()))?;

        with_env(|env| -> Result<(), PlatformError> {
            let appid_jstring = env.new_string(&appid)?;
            let path_jstring = env.new_string(&path)?;
            let anim_type_int = animation_type as i32;

            let result = env.call_static_method(
                bridge_class,
                jni_str!("navigate"),
                jni_sig!("(Ljava/lang/String;Ljava/lang/String;I)Z"),
                &[
                    JValue::Object(&appid_jstring),
                    JValue::Object(&path_jstring),
                    JValue::Int(anim_type_int),
                ],
            )?;
            if !result.z()? {
                return Err(PlatformError::Platform(format!(
                    "Navigation returned false: appid={}, path={}, animation_type={:?}",
                    appid, path, animation_type
                )));
            }
            Ok(())
        })
        .map_err(|_| {
            PlatformError::Platform(format!(
                "Failed to navigate: appid={}, path={}, animation_type={:?}",
                appid, path, animation_type
            ))
        })
    }

    fn open_url(
        &self,
        req: crate::traits::app_runtime::OpenUrlRequest,
    ) -> Result<crate::traits::app_runtime::OpenUrlResult, PlatformError> {
        let host_class: &JClass = super::get_cached_class(super::CachedClass::Lingxia)
            .map_err(|e| PlatformError::Platform(e.to_string()))?;

        let target_str = match req.target {
            crate::traits::app_runtime::OpenUrlTarget::SelfTarget => "self",
            crate::traits::app_runtime::OpenUrlTarget::NewBrowserTab => "new_browser_tab",
            crate::traits::app_runtime::OpenUrlTarget::AsideBrowser => "aside",
            _ => "external",
        };

        with_env(
            |env| -> Result<crate::traits::app_runtime::OpenUrlResult, PlatformError> {
                let url_jstring = env.new_string(req.url)?;
                let target_jstring = env.new_string(target_str)?;
                let owner_appid_jstring = env.new_string(req.owner_appid)?;
                let result = env.call_static_method(
                host_class,
                jni_str!("launchWithUrl"),
                jni_sig!(
                    "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;J)Ljava/lang/String;"
                ),
                &[
                    JValue::Object(&url_jstring),
                    JValue::Object(&target_jstring),
                    JValue::Object(&owner_appid_jstring),
                    JValue::Long(req.owner_session_id as i64),
                ],
            )?;
                let tab_obj = result.l()?;
                if tab_obj.is_null() {
                    return Ok(crate::traits::app_runtime::OpenUrlResult { tab_id: None });
                }
                let tab_jstring = unsafe { JString::from_raw(env, tab_obj.into_raw() as _) };
                let tab_id = tab_jstring
                    .try_to_string(env)
                    .map_err(|e| PlatformError::Platform(e.to_string()))?;
                Ok(crate::traits::app_runtime::OpenUrlResult {
                    tab_id: (!tab_id.is_empty()).then_some(tab_id),
                })
            },
        )
        .map_err(|e| PlatformError::Platform(format!("Failed to open_url: {}", e)))
    }

    fn close_browser_tab(&self, tab_id: &str) -> Result<(), PlatformError> {
        let host_class: &JClass = super::get_cached_class(super::CachedClass::Lingxia)
            .map_err(|e| PlatformError::Platform(e.to_string()))?;
        with_env(|env| -> Result<(), PlatformError> {
            let tab_jstring = env.new_string(tab_id)?;
            let result = env.call_static_method(
                host_class,
                jni_str!("closeBrowserTab"),
                jni_sig!("(Ljava/lang/String;)Z"),
                &[JValue::Object(&tab_jstring)],
            )?;
            if result.z()? {
                Ok(())
            } else {
                Err(PlatformError::Platform(format!(
                    "Failed to close browser tab: {tab_id}"
                )))
            }
        })
        .map_err(|e| PlatformError::Platform(format!("Failed to close_browser_tab: {}", e)))
    }

    fn notification_permission(&self) -> Result<String, PlatformError> {
        notification_word_call(false)
    }

    fn notification_request_permission(&self) -> Result<String, PlatformError> {
        notification_word_call(true)
    }

    fn notification_show(
        &self,
        request: &crate::traits::app_runtime::LocalNotificationShow,
    ) -> Result<crate::traits::app_runtime::LocalNotificationStatus, PlatformError> {
        with_env(|env| -> Result<_, PlatformError> {
            let class: &JClass = super::get_cached_class(super::CachedClass::LxAppNotification)
                .map_err(|e| PlatformError::Platform(e.to_string()))?;
            let id = env.new_string(&request.id)?;
            let title = env.new_string(&request.title)?;
            let body = env.new_string(&request.body)?;
            let token = env.new_string(&request.activation_token)?;
            let result = env.call_static_method(
                class,
                jni_str!("show"),
                jni_sig!(
                    "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;JZ)Ljava/lang/String;"
                ),
                &[
                    JValue::Object(&id),
                    JValue::Object(&title),
                    JValue::Object(&body),
                    JValue::Object(&token),
                    JValue::Long(request.deliver_at_ms.unwrap_or(0) as i64),
                    JValue::Bool(request.silent),
                ],
            )?;
            let status = jstring_from_result(env, result)?;
            if status.is_empty() {
                return Err(PlatformError::Platform(notification_last_error(env, class)));
            }
            crate::traits::app_runtime::LocalNotificationStatus::from_native(&status)
                .ok_or_else(|| PlatformError::Platform(format!("unexpected show status: {status}")))
        })
        .map_err(|e| PlatformError::Platform(format!("Failed to show notification: {e}")))
    }

    fn notification_cancel(&self, id: &str) -> Result<(), PlatformError> {
        with_env(|env| -> Result<(), PlatformError> {
            let class: &JClass = super::get_cached_class(super::CachedClass::LxAppNotification)
                .map_err(|e| PlatformError::Platform(e.to_string()))?;
            let id = env.new_string(id)?;
            let result = env.call_static_method(
                class,
                jni_str!("cancel"),
                jni_sig!("(Ljava/lang/String;)Z"),
                &[JValue::Object(&id)],
            )?;
            if result.z()? {
                Ok(())
            } else {
                Err(PlatformError::Platform(notification_last_error(env, class)))
            }
        })
        .map_err(|e| PlatformError::Platform(format!("Failed to cancel notification: {e}")))
    }

    fn notification_cancel_all(&self) -> Result<(), PlatformError> {
        with_env(|env| -> Result<(), PlatformError> {
            let class: &JClass = super::get_cached_class(super::CachedClass::LxAppNotification)
                .map_err(|e| PlatformError::Platform(e.to_string()))?;
            let result =
                env.call_static_method(class, jni_str!("cancelAll"), jni_sig!("()Z"), &[])?;
            if result.z()? {
                Ok(())
            } else {
                Err(PlatformError::Platform(notification_last_error(env, class)))
            }
        })
        .map_err(|e| PlatformError::Platform(format!("Failed to cancel all notifications: {e}")))
    }

    fn activate_browser_tab(&self, tab_id: String) -> crate::traits::PlatformFuture {
        Box::pin(async move {
            let host_class: &JClass = super::get_cached_class(super::CachedClass::Lingxia)
                .map_err(|e| PlatformError::Platform(e.to_string()))?;
            with_env(|env| -> Result<(), PlatformError> {
                let tab_jstring = env.new_string(&tab_id)?;
                let result = env.call_static_method(
                    host_class,
                    jni_str!("activateBrowserTab"),
                    jni_sig!("(Ljava/lang/String;)Z"),
                    &[JValue::Object(&tab_jstring)],
                )?;
                if result.z()? {
                    Ok(())
                } else {
                    Err(PlatformError::Platform(format!(
                        "Failed to activate browser tab: {tab_id}"
                    )))
                }
            })
            .map_err(|e| PlatformError::Platform(format!("Failed to activate_browser_tab: {}", e)))
        })
    }
}

impl crate::traits::share::ShareService for Platform {
    async fn share(
        &self,
        request: crate::traits::share::ShareRequest,
    ) -> Result<crate::traits::share::ShareResult, PlatformError> {
        let files_json = serde_json::to_string(&request.files).map_err(|e| {
            PlatformError::Platform(format!("Failed to serialize share files: {e}"))
        })?;

        let payload =
            crate::rt::native_call(|callback_id| share_impl(&request, &files_json, callback_id))
                .await?;
        if payload.trim().is_empty() {
            return Ok(crate::traits::share::ShareResult { completed: None });
        }
        serde_json::from_str(&payload)
            .map_err(|e| PlatformError::Platform(format!("Failed to parse share result: {e}")))
    }
}

fn share_impl(
    request: &crate::traits::share::ShareRequest,
    files_json: &str,
    callback_id: u64,
) -> Result<(), PlatformError> {
    with_env(|env| -> Result<(), PlatformError> {
        let class: &JClass = super::get_cached_class(super::CachedClass::LxAppShare)
            .map_err(|e| PlatformError::Platform(e.to_string()))?;
        let title = env.new_string(request.title.as_deref().unwrap_or_default())?;
        let text = env.new_string(request.text.as_deref().unwrap_or_default())?;
        let url = env.new_string(request.url.as_deref().unwrap_or_default())?;
        let files = env.new_string(files_json)?;

        let result = env.call_static_method(
            class,
            jni_str!("share"),
            jni_sig!(
                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;J)Z"
            ),
            &[
                JValue::Object(&title),
                JValue::Object(&text),
                JValue::Object(&url),
                JValue::Object(&files),
                JValue::Long(callback_id as i64),
            ],
        )?;
        if env.exception_check() {
            env.exception_clear();
            return Err(PlatformError::Platform(
                "Android share JNI call threw an exception".to_string(),
            ));
        }
        if !result.z()? {
            return Err(PlatformError::Platform(
                "Android share returned false".to_string(),
            ));
        }
        Ok(())
    })
    .map_err(|e| PlatformError::Platform(format!("Failed to call Android share: {e}")))
}

fn jstring_from_result(
    env: &mut Env,
    result: impl JniStringResult,
) -> Result<String, PlatformError> {
    result.into_string(env)
}

trait JniStringResult {
    fn into_string(self, env: &mut Env) -> Result<String, PlatformError>;
}

impl JniStringResult for jni::objects::JValueOwned<'_> {
    fn into_string(self, env: &mut Env) -> Result<String, PlatformError> {
        let object = self
            .l()
            .map_err(|e| PlatformError::Platform(e.to_string()))?;
        if object.is_null() {
            return Ok(String::new());
        }
        let value = unsafe { JString::from_raw(env, object.into_raw() as _) };
        value
            .try_to_string(env)
            .map_err(|e| PlatformError::Platform(e.to_string()))
    }
}

/// `permission` / `requestPermission`: a status word, or empty with the reason
/// left in `takeLastError`.
fn notification_word_call(prompt: bool) -> Result<String, PlatformError> {
    with_env(|env| -> Result<String, PlatformError> {
        let class: &JClass = super::get_cached_class(super::CachedClass::LxAppNotification)
            .map_err(|e| PlatformError::Platform(e.to_string()))?;
        let result = if prompt {
            env.call_static_method(
                class,
                jni_str!("requestPermission"),
                jni_sig!("()Ljava/lang/String;"),
                &[],
            )?
        } else {
            env.call_static_method(
                class,
                jni_str!("permission"),
                jni_sig!("()Ljava/lang/String;"),
                &[],
            )?
        };
        let word = jstring_from_result(env, result)?;
        if word.is_empty() {
            return Err(PlatformError::Platform(notification_last_error(env, class)));
        }
        Ok(word)
    })
    .map_err(|e| PlatformError::Platform(format!("Failed to read notification permission: {e}")))
}

fn notification_last_error(env: &mut Env, class: &JClass) -> String {
    env.call_static_method(
        class,
        jni_str!("takeLastError"),
        jni_sig!("()Ljava/lang/String;"),
        &[],
    )
    .ok()
    .and_then(|result| jstring_from_result(env, result).ok())
    .filter(|message| !message.is_empty())
    .unwrap_or_else(|| "notification request failed".into())
}