package com.bluememe.utils;

import android.Manifest;
import android.annotation.TargetApi;
import android.app.Activity;
import android.app.KeyguardManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.hardware.biometrics.BiometricManager;
import android.hardware.biometrics.BiometricPrompt;
import android.hardware.fingerprint.FingerprintManager;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkRequest;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.net.wifi.WifiNetworkSpecifier;
import android.net.wifi.WifiNetworkSuggestion;
import android.os.Build;
import android.os.Bundle;
import android.os.CancellationSignal;
import android.text.TextUtils;
import android.util.Log;

import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.FirebaseApp;
import com.google.firebase.FirebaseOptions;
import com.google.firebase.messaging.FirebaseMessaging;

import org.apache.cordova.CallbackContext;
import org.apache.cordova.CordovaPlugin;
import org.apache.cordova.PermissionHelper;
import org.apache.cordova.PluginResult;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.Executor;

public class BluememeUtils extends CordovaPlugin {
    private static final String TAG = "BluememeUtils";
    private static final String PREFS = "bluememe_utils";
    private static final String KEY_FCM_TOKEN = "fcm_token";
    private static final String KEY_INITIAL_NOTIFICATION = "initial_notification";
    private static final String ACTION_SUFFIX = ".BLUEMEME_UTILS_EVENT";
    private static final String EXTRA_EVENT = "event";
    private static final String EXTRA_PAYLOAD = "bluememe_payload";
    private static final int REQ_WIFI_PERMISSION = 8101;
    private static final int REQ_NOTIFICATION_PERMISSION = 8102;

    private CallbackContext wifiPermissionCallback;
    private CallbackContext notificationPermissionCallback;
    private CallbackContext notificationCallback;
    private ConnectivityManager.NetworkCallback networkCallback;
    private BroadcastReceiver eventReceiver;

    @Override
    protected void pluginInitialize() {
        ensureFirebaseInitialized(false);
        registerEventReceiver();
        captureLaunchIntent(cordova.getActivity().getIntent());
    }

    @Override
    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
        if ("saveWifi".equals(action)) {
            saveWifi(args.optJSONObject(0), callbackContext);
            return true;
        }
        if ("connectWifi".equals(action)) {
            connectWifi(args.optJSONObject(0), callbackContext);
            return true;
        }
        if ("disconnectWifi".equals(action)) {
            disconnectWifi(callbackContext);
            return true;
        }
        if ("removeWifi".equals(action)) {
            removeWifi(args.optJSONObject(0), callbackContext);
            return true;
        }
        if ("requestWifiPermission".equals(action)) {
            requestWifiPermission(callbackContext);
            return true;
        }
        if ("isBiometricAvailable".equals(action)) {
            isBiometricAvailable(callbackContext);
            return true;
        }
        if ("unlockWithBiometrics".equals(action)) {
            unlockWithBiometrics(args.optJSONObject(0), callbackContext);
            return true;
        }
        if ("requestPushPermission".equals(action)) {
            requestPushPermission(callbackContext);
            return true;
        }
        if ("getFirebaseToken".equals(action)) {
            getFirebaseToken(callbackContext);
            return true;
        }
        if ("subscribeToTopic".equals(action)) {
            subscribeToTopic(args.optString(0, ""), callbackContext);
            return true;
        }
        if ("unsubscribeFromTopic".equals(action)) {
            unsubscribeFromTopic(args.optString(0, ""), callbackContext);
            return true;
        }
        if ("getInitialNotification".equals(action)) {
            getInitialNotification(callbackContext);
            return true;
        }
        if ("startNotificationListener".equals(action)) {
            startNotificationListener(callbackContext);
            return true;
        }
        if ("stopNotificationListener".equals(action)) {
            notificationCallback = null;
            callbackContext.success();
            return true;
        }
        return false;
    }

    @Override
    public void onNewIntent(Intent intent) {
        captureLaunchIntent(intent);
    }

    @Override
    public void onDestroy() {
        unregisterEventReceiver();
        stopNetworkRequest();
        super.onDestroy();
    }

    @Override
    public void onRequestPermissionResult(int requestCode, String[] permissions, int[] grantResults) throws JSONException {
        if (requestCode == REQ_WIFI_PERMISSION) {
            CallbackContext callback = wifiPermissionCallback;
            wifiPermissionCallback = null;
            if (callback != null) {
                callback.success(permissionResult("wifi", allGranted(grantResults), missingWifiPermissions()));
            }
            return;
        }
        if (requestCode == REQ_NOTIFICATION_PERMISSION) {
            CallbackContext callback = notificationPermissionCallback;
            notificationPermissionCallback = null;
            if (callback != null) {
                callback.success(permissionResult("notification", allGranted(grantResults), new JSONArray()));
            }
        }
    }

    private void saveWifi(JSONObject options, CallbackContext callbackContext) {
        JSONObject normalized = normalizeWifiOptions(options);
        String validationError = validateWifiOptions(normalized);
        if (validationError != null) {
            sendError(callbackContext, "INVALID_WIFI_OPTIONS", validationError);
            return;
        }
        if (!hasWifiPermissions()) {
            sendError(callbackContext, "PERMISSION_REQUIRED", "Call requestWifiPermission before saving a WiFi network.");
            return;
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            saveWifiSuggestion(normalized, callbackContext);
        } else {
            saveLegacyWifi(normalized, callbackContext);
        }
    }

    private void connectWifi(JSONObject options, CallbackContext callbackContext) {
        JSONObject normalized = normalizeWifiOptions(options);
        String validationError = validateWifiOptions(normalized);
        if (validationError != null) {
            sendError(callbackContext, "INVALID_WIFI_OPTIONS", validationError);
            return;
        }
        if (!hasWifiPermissions()) {
            sendError(callbackContext, "PERMISSION_REQUIRED", "Call requestWifiPermission before connecting to a WiFi network.");
            return;
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            connectWithSpecifier(normalized, callbackContext);
        } else {
            connectLegacyWifi(normalized, callbackContext);
        }
    }

    private void removeWifi(JSONObject options, CallbackContext callbackContext) {
        JSONObject normalized = normalizeWifiOptions(options);
        String ssid = normalized.optString("ssid", "");
        if (TextUtils.isEmpty(ssid)) {
            sendError(callbackContext, "INVALID_WIFI_OPTIONS", "ssid is required.");
            return;
        }
        if (!hasWifiPermissions()) {
            sendError(callbackContext, "PERMISSION_REQUIRED", "Call requestWifiPermission before removing a WiFi network.");
            return;
        }

        WifiManager wifiManager = wifiManager();
        if (wifiManager == null) {
            sendError(callbackContext, "WIFI_UNAVAILABLE", "WiFi manager is not available.");
            return;
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            try {
                int status = wifiManager.removeNetworkSuggestions(Collections.singletonList(buildSuggestion(normalized)));
                JSONObject result = new JSONObject();
                result.put("ssid", ssid);
                result.put("platformMode", "suggestion");
                result.put("status", status);
                result.put("removed", status == WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS);
                callbackContext.success(result);
            } catch (Exception ex) {
                sendError(callbackContext, "WIFI_REMOVE_FAILED", ex.getMessage());
            }
            return;
        }

        int networkId = findLegacyNetworkId(wifiManager, ssid);
        if (networkId < 0) {
            try {
                JSONObject result = new JSONObject();
                result.put("ssid", ssid);
                result.put("removed", false);
                result.put("reason", "not_found");
                callbackContext.success(result);
            } catch (JSONException ex) {
                sendError(callbackContext, "JSON_ERROR", ex.getMessage());
            }
            return;
        }

        boolean removed = wifiManager.removeNetwork(networkId);
        wifiManager.saveConfiguration();
        try {
            JSONObject result = new JSONObject();
            result.put("ssid", ssid);
            result.put("networkId", networkId);
            result.put("removed", removed);
            callbackContext.success(result);
        } catch (JSONException ex) {
            sendError(callbackContext, "JSON_ERROR", ex.getMessage());
        }
    }

    private void disconnectWifi(CallbackContext callbackContext) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            stopNetworkRequest();
            try {
                JSONObject result = new JSONObject();
                result.put("disconnected", true);
                result.put("platformMode", "specifier");
                callbackContext.success(result);
            } catch (JSONException ex) {
                sendError(callbackContext, "JSON_ERROR", ex.getMessage());
            }
            return;
        }

        WifiManager wifiManager = wifiManager();
        if (wifiManager == null) {
            sendError(callbackContext, "WIFI_UNAVAILABLE", "WiFi manager is not available.");
            return;
        }
        boolean disconnected = wifiManager.disconnect();
        try {
            JSONObject result = new JSONObject();
            result.put("disconnected", disconnected);
            result.put("platformMode", "legacy");
            callbackContext.success(result);
        } catch (JSONException ex) {
            sendError(callbackContext, "JSON_ERROR", ex.getMessage());
        }
    }

    private void requestWifiPermission(CallbackContext callbackContext) {
        JSONArray missing = missingWifiPermissions();
        if (missing.length() == 0) {
            try {
                callbackContext.success(permissionResult("wifi", true, missing));
            } catch (JSONException ex) {
                sendError(callbackContext, "JSON_ERROR", ex.getMessage());
            }
            return;
        }
        wifiPermissionCallback = callbackContext;
        PermissionHelper.requestPermissions(this, REQ_WIFI_PERMISSION, jsonArrayToStringArray(missing));
    }

    private void isBiometricAvailable(CallbackContext callbackContext) {
        try {
            callbackContext.success(biometricAvailability());
        } catch (JSONException ex) {
            sendError(callbackContext, "JSON_ERROR", ex.getMessage());
        }
    }

    private void unlockWithBiometrics(JSONObject options, CallbackContext callbackContext) {
        try {
            JSONObject availability = biometricAvailability();
            if (!availability.optBoolean("available")) {
                sendError(callbackContext, availability.optString("code", "BIOMETRIC_UNAVAILABLE"), availability.optString("message", "Biometric authentication is unavailable."));
                return;
            }
        } catch (JSONException ex) {
            sendError(callbackContext, "JSON_ERROR", ex.getMessage());
            return;
        }

        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
            sendError(callbackContext, "UNSUPPORTED_ANDROID_VERSION", "Biometric unlock requires Android 9.0 or newer in this plugin.");
            return;
        }

        final JSONObject safeOptions = options == null ? new JSONObject() : options;
        cordova.getActivity().runOnUiThread(new Runnable() {
            @Override
            public void run() {
                showBiometricPrompt(safeOptions, callbackContext);
            }
        });
    }

    private void requestPushPermission(CallbackContext callbackContext) {
        if (Build.VERSION.SDK_INT < 33 || PermissionHelper.hasPermission(this, Manifest.permission.POST_NOTIFICATIONS)) {
            try {
                callbackContext.success(permissionResult("notification", true, new JSONArray()));
            } catch (JSONException ex) {
                sendError(callbackContext, "JSON_ERROR", ex.getMessage());
            }
            return;
        }
        notificationPermissionCallback = callbackContext;
        PermissionHelper.requestPermission(this, REQ_NOTIFICATION_PERMISSION, Manifest.permission.POST_NOTIFICATIONS);
    }

    private void getFirebaseToken(final CallbackContext callbackContext) {
        if (!ensureFirebaseInitialized(true)) {
            sendError(callbackContext, "FIREBASE_NOT_CONFIGURED", "Firebase is not configured. Add Google services files or pass Firebase plugin preferences.");
            return;
        }

        FirebaseMessaging.getInstance().getToken().addOnCompleteListener(new OnCompleteListener<String>() {
            @Override
            public void onComplete(Task<String> task) {
                if (!task.isSuccessful()) {
                    Exception exception = task.getException();
                    sendError(callbackContext, "FCM_TOKEN_FAILED", exception == null ? "Failed to get Firebase token." : exception.getMessage());
                    return;
                }
                String token = task.getResult();
                saveToken(cordova.getActivity(), token);
                try {
                    JSONObject result = new JSONObject();
                    result.put("token", token);
                    callbackContext.success(result);

                    JSONObject event = new JSONObject();
                    event.put("type", "token");
                    event.put("token", token);
                    sendEventToJs(event);
                } catch (JSONException ex) {
                    sendError(callbackContext, "JSON_ERROR", ex.getMessage());
                }
            }
        });
    }

    private void subscribeToTopic(String topic, final CallbackContext callbackContext) {
        if (TextUtils.isEmpty(topic)) {
            sendError(callbackContext, "INVALID_TOPIC", "topic is required.");
            return;
        }
        if (!ensureFirebaseInitialized(true)) {
            sendError(callbackContext, "FIREBASE_NOT_CONFIGURED", "Firebase is not configured.");
            return;
        }
        FirebaseMessaging.getInstance().subscribeToTopic(topic).addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(Task<Void> task) {
                completeFirebaseTask(task, callbackContext);
            }
        });
    }

    private void unsubscribeFromTopic(String topic, final CallbackContext callbackContext) {
        if (TextUtils.isEmpty(topic)) {
            sendError(callbackContext, "INVALID_TOPIC", "topic is required.");
            return;
        }
        if (!ensureFirebaseInitialized(true)) {
            sendError(callbackContext, "FIREBASE_NOT_CONFIGURED", "Firebase is not configured.");
            return;
        }
        FirebaseMessaging.getInstance().unsubscribeFromTopic(topic).addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(Task<Void> task) {
                completeFirebaseTask(task, callbackContext);
            }
        });
    }

    private void getInitialNotification(CallbackContext callbackContext) {
        SharedPreferences preferences = prefs(cordova.getActivity());
        String value = preferences.getString(KEY_INITIAL_NOTIFICATION, null);
        preferences.edit().remove(KEY_INITIAL_NOTIFICATION).apply();
        if (TextUtils.isEmpty(value)) {
            callbackContext.success((JSONObject) null);
            return;
        }
        try {
            callbackContext.success(new JSONObject(value));
        } catch (JSONException ex) {
            sendError(callbackContext, "JSON_ERROR", ex.getMessage());
        }
    }

    private void startNotificationListener(CallbackContext callbackContext) {
        notificationCallback = callbackContext;
        PluginResult result = new PluginResult(PluginResult.Status.NO_RESULT);
        result.setKeepCallback(true);
        callbackContext.sendPluginResult(result);

        String token = prefs(cordova.getActivity()).getString(KEY_FCM_TOKEN, null);
        if (!TextUtils.isEmpty(token)) {
            try {
                JSONObject event = new JSONObject();
                event.put("type", "token");
                event.put("token", token);
                sendEventToJs(event);
            } catch (JSONException ignored) {
                Log.w(TAG, "Failed to dispatch cached FCM token.");
            }
        }
    }

    @TargetApi(Build.VERSION_CODES.Q)
    private void saveWifiSuggestion(JSONObject options, CallbackContext callbackContext) {
        WifiManager wifiManager = wifiManager();
        if (wifiManager == null) {
            sendError(callbackContext, "WIFI_UNAVAILABLE", "WiFi manager is not available.");
            return;
        }

        try {
            WifiNetworkSuggestion suggestion = buildSuggestion(options);
            int status = wifiManager.addNetworkSuggestions(Collections.singletonList(suggestion));
            if (status != WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS
                    && status != WifiManager.STATUS_NETWORK_SUGGESTIONS_ERROR_ADD_DUPLICATE) {
                sendError(callbackContext, "WIFI_SAVE_FAILED", "addNetworkSuggestions returned status " + status + ".");
                return;
            }

            JSONObject result = new JSONObject();
            result.put("ssid", options.optString("ssid"));
            result.put("platformMode", "suggestion");
            result.put("saved", true);
            result.put("status", status);
            result.put("requiresUserApproval", true);
            callbackContext.success(result);
        } catch (Exception ex) {
            sendError(callbackContext, "WIFI_SAVE_FAILED", ex.getMessage());
        }
    }

    private void saveLegacyWifi(JSONObject options, CallbackContext callbackContext) {
        WifiManager wifiManager = wifiManager();
        if (wifiManager == null) {
            sendError(callbackContext, "WIFI_UNAVAILABLE", "WiFi manager is not available.");
            return;
        }

        int networkId = addOrUpdateLegacyNetwork(wifiManager, options);
        if (networkId < 0) {
            sendError(callbackContext, "WIFI_SAVE_FAILED", "Unable to add WiFi network configuration.");
            return;
        }
        wifiManager.saveConfiguration();

        try {
            JSONObject result = new JSONObject();
            result.put("ssid", options.optString("ssid"));
            result.put("platformMode", "legacy");
            result.put("networkId", networkId);
            result.put("saved", true);
            callbackContext.success(result);
        } catch (JSONException ex) {
            sendError(callbackContext, "JSON_ERROR", ex.getMessage());
        }
    }

    @TargetApi(Build.VERSION_CODES.Q)
    private void connectWithSpecifier(final JSONObject options, final CallbackContext callbackContext) {
        final ConnectivityManager connectivityManager = connectivityManager();
        if (connectivityManager == null) {
            sendError(callbackContext, "NETWORK_UNAVAILABLE", "Connectivity manager is not available.");
            return;
        }

        try {
            stopNetworkRequest();
            WifiNetworkSpecifier specifier = buildSpecifier(options);
            NetworkRequest request = new NetworkRequest.Builder()
                    .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
                    .setNetworkSpecifier(specifier)
                    .build();

            networkCallback = new ConnectivityManager.NetworkCallback() {
                @Override
                public void onAvailable(Network network) {
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                        connectivityManager.bindProcessToNetwork(network);
                    } else {
                        ConnectivityManager.setProcessDefaultNetwork(network);
                    }
                    try {
                        JSONObject result = new JSONObject();
                        result.put("ssid", options.optString("ssid"));
                        result.put("platformMode", "specifier");
                        result.put("connected", true);
                        result.put("temporaryConnection", true);
                        callbackContext.success(result);
                    } catch (JSONException ex) {
                        sendError(callbackContext, "JSON_ERROR", ex.getMessage());
                    }
                }

                @Override
                public void onUnavailable() {
                    sendError(callbackContext, "WIFI_CONNECT_FAILED", "Requested WiFi network is unavailable or the user rejected the connection.");
                }

                @Override
                public void onLost(Network network) {
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                        connectivityManager.bindProcessToNetwork(null);
                    } else {
                        ConnectivityManager.setProcessDefaultNetwork(null);
                    }
                }
            };

            connectivityManager.requestNetwork(request, networkCallback);
        } catch (Exception ex) {
            sendError(callbackContext, "WIFI_CONNECT_FAILED", ex.getMessage());
        }
    }

    private void connectLegacyWifi(JSONObject options, CallbackContext callbackContext) {
        WifiManager wifiManager = wifiManager();
        if (wifiManager == null) {
            sendError(callbackContext, "WIFI_UNAVAILABLE", "WiFi manager is not available.");
            return;
        }

        int networkId = addOrUpdateLegacyNetwork(wifiManager, options);
        if (networkId < 0) {
            sendError(callbackContext, "WIFI_CONNECT_FAILED", "Unable to add WiFi network configuration.");
            return;
        }

        boolean enabled = wifiManager.enableNetwork(networkId, true);
        boolean reconnecting = wifiManager.reconnect();

        try {
            JSONObject result = new JSONObject();
            result.put("ssid", options.optString("ssid"));
            result.put("platformMode", "legacy");
            result.put("networkId", networkId);
            result.put("enabled", enabled);
            result.put("reconnecting", reconnecting);
            callbackContext.success(result);
        } catch (JSONException ex) {
            sendError(callbackContext, "JSON_ERROR", ex.getMessage());
        }
    }

    private void stopNetworkRequest() {
        ConnectivityManager connectivityManager = connectivityManager();
        if (connectivityManager != null && networkCallback != null) {
            try {
                connectivityManager.unregisterNetworkCallback(networkCallback);
            } catch (RuntimeException ignored) {
                Log.d(TAG, "Network callback was already unregistered.");
            }
        }
        if (connectivityManager != null) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                connectivityManager.bindProcessToNetwork(null);
            } else {
                ConnectivityManager.setProcessDefaultNetwork(null);
            }
        }
        networkCallback = null;
    }

    @TargetApi(Build.VERSION_CODES.Q)
    private WifiNetworkSuggestion buildSuggestion(JSONObject options) {
        WifiNetworkSuggestion.Builder builder = new WifiNetworkSuggestion.Builder()
                .setSsid(options.optString("ssid"));
        if (options.optBoolean("hiddenSsid", false)) {
            builder.setIsHiddenSsid(true);
        }
        applySuggestionSecurity(builder, options);
        return builder.build();
    }

    @TargetApi(Build.VERSION_CODES.Q)
    private WifiNetworkSpecifier buildSpecifier(JSONObject options) {
        WifiNetworkSpecifier.Builder builder = new WifiNetworkSpecifier.Builder()
                .setSsid(options.optString("ssid"));
        if (options.optBoolean("hiddenSsid", false)) {
            builder.setIsHiddenSsid(true);
        }
        String bssid = options.optString("bssid", "");
        if (!TextUtils.isEmpty(bssid)) {
            builder.setBssid(android.net.MacAddress.fromString(bssid));
        }
        applySpecifierSecurity(builder, options);
        return builder.build();
    }

    @TargetApi(Build.VERSION_CODES.Q)
    private void applySuggestionSecurity(WifiNetworkSuggestion.Builder builder, JSONObject options) {
        String security = options.optString("security", "").toLowerCase(Locale.US);
        String password = options.optString("password", "");
        if (TextUtils.isEmpty(password) || "open".equals(security)) {
            return;
        }
        if ("wpa3".equals(security) && Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            builder.setWpa3Passphrase(password);
            return;
        }
        builder.setWpa2Passphrase(password);
    }

    @TargetApi(Build.VERSION_CODES.Q)
    private void applySpecifierSecurity(WifiNetworkSpecifier.Builder builder, JSONObject options) {
        String security = options.optString("security", "").toLowerCase(Locale.US);
        String password = options.optString("password", "");
        if (TextUtils.isEmpty(password) || "open".equals(security)) {
            return;
        }
        if ("wpa3".equals(security) && Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            builder.setWpa3Passphrase(password);
            return;
        }
        builder.setWpa2Passphrase(password);
    }

    private int addOrUpdateLegacyNetwork(WifiManager wifiManager, JSONObject options) {
        String ssid = options.optString("ssid");
        int existingNetworkId = findLegacyNetworkId(wifiManager, ssid);
        WifiConfiguration configuration = buildLegacyConfiguration(options);
        if (existingNetworkId >= 0) {
            configuration.networkId = existingNetworkId;
            int updated = wifiManager.updateNetwork(configuration);
            return updated >= 0 ? updated : existingNetworkId;
        }
        return wifiManager.addNetwork(configuration);
    }

    private WifiConfiguration buildLegacyConfiguration(JSONObject options) {
        String security = options.optString("security", "").toLowerCase(Locale.US);
        String password = options.optString("password", "");

        WifiConfiguration configuration = new WifiConfiguration();
        configuration.SSID = quote(options.optString("ssid"));
        configuration.hiddenSSID = options.optBoolean("hiddenSsid", false);
        configuration.status = WifiConfiguration.Status.ENABLED;

        if (TextUtils.isEmpty(password) || "open".equals(security)) {
            configuration.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            return configuration;
        }

        if ("wep".equals(security)) {
            configuration.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            configuration.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
            configuration.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
            configuration.wepKeys[0] = quote(password);
            configuration.wepTxKeyIndex = 0;
            return configuration;
        }

        configuration.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
        configuration.preSharedKey = quote(password);
        return configuration;
    }

    private int findLegacyNetworkId(WifiManager wifiManager, String ssid) {
        try {
            List<WifiConfiguration> networks = wifiManager.getConfiguredNetworks();
            if (networks == null) {
                return -1;
            }
            String quotedSsid = quote(ssid);
            for (WifiConfiguration network : networks) {
                if (quotedSsid.equals(network.SSID)) {
                    return network.networkId;
                }
            }
        } catch (SecurityException ex) {
            Log.w(TAG, "Missing permission to read configured networks.", ex);
        }
        return -1;
    }

    private JSONObject normalizeWifiOptions(JSONObject options) {
        JSONObject normalized = options == null ? new JSONObject() : options;
        try {
            if (!normalized.has("security")) {
                normalized.put("security", TextUtils.isEmpty(normalized.optString("password", "")) ? "open" : "wpa2");
            }
        } catch (JSONException ignored) {
            Log.w(TAG, "Unable to normalize WiFi options.");
        }
        return normalized;
    }

    private String validateWifiOptions(JSONObject options) {
        if (TextUtils.isEmpty(options.optString("ssid", ""))) {
            return "ssid is required.";
        }
        String security = options.optString("security", "open").toLowerCase(Locale.US);
        if (!"open".equals(security) && TextUtils.isEmpty(options.optString("password", ""))) {
            return "password is required for secured WiFi networks.";
        }
        return null;
    }

    private boolean hasWifiPermissions() {
        return missingWifiPermissions().length() == 0;
    }

    private JSONArray missingWifiPermissions() {
        JSONArray permissions = new JSONArray();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU
                && !PermissionHelper.hasPermission(this, Manifest.permission.NEARBY_WIFI_DEVICES)) {
            permissions.put(Manifest.permission.NEARBY_WIFI_DEVICES);
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
                && !PermissionHelper.hasPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)) {
            permissions.put(Manifest.permission.ACCESS_FINE_LOCATION);
        }
        return permissions;
    }

    private JSONObject biometricAvailability() throws JSONException {
        JSONObject result = new JSONObject();
        result.put("available", false);
        result.put("biometryType", "none");

        Context context = cordova.getActivity();
        KeyguardManager keyguardManager = (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
        if (keyguardManager == null || !keyguardManager.isKeyguardSecure()) {
            result.put("code", "NOT_ENROLLED");
            result.put("message", "No secure lock screen or biometric credential is enrolled.");
            return result;
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            BiometricManager biometricManager = (BiometricManager) context.getSystemService(BiometricManager.class);
            int code = biometricManager == null
                    ? BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE
                    : biometricManager.canAuthenticate(BiometricManager.Authenticators.BIOMETRIC_WEAK);
            result.put("platformCode", code);
            if (code == BiometricManager.BIOMETRIC_SUCCESS) {
                result.put("available", true);
                result.put("biometryType", detectAndroidBiometryType(context));
                result.put("code", "OK");
                result.put("message", "Biometric authentication is available.");
            } else {
                result.put("code", "BIOMETRIC_UNAVAILABLE");
                result.put("message", "Biometric authentication is unavailable. Android code: " + code);
            }
            return result;
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            BiometricManager biometricManager = (BiometricManager) context.getSystemService(BiometricManager.class);
            int code = biometricManager == null
                    ? BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE
                    : biometricManager.canAuthenticate();
            result.put("platformCode", code);
            if (code == BiometricManager.BIOMETRIC_SUCCESS) {
                result.put("available", true);
                result.put("biometryType", detectAndroidBiometryType(context));
                result.put("code", "OK");
                result.put("message", "Biometric authentication is available.");
            } else {
                result.put("code", "BIOMETRIC_UNAVAILABLE");
                result.put("message", "Biometric authentication is unavailable. Android code: " + code);
            }
            return result;
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
            if (!hasBiometricFeature(context)) {
                result.put("code", "BIOMETRIC_UNAVAILABLE");
                result.put("message", "No biometric hardware is available.");
                return result;
            }
            result.put("available", true);
            result.put("biometryType", detectAndroidBiometryType(context));
            result.put("code", "OK");
            result.put("message", "Biometric authentication is available.");
            return result;
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            FingerprintManager fingerprintManager = (FingerprintManager) context.getSystemService(Context.FINGERPRINT_SERVICE);
            if (fingerprintManager != null && fingerprintManager.isHardwareDetected() && fingerprintManager.hasEnrolledFingerprints()) {
                result.put("available", true);
                result.put("biometryType", "fingerprint");
                result.put("code", "OK");
                result.put("message", "Fingerprint authentication is available.");
            } else {
                result.put("code", "BIOMETRIC_UNAVAILABLE");
                result.put("message", "Fingerprint authentication is unavailable.");
            }
            return result;
        }

        result.put("code", "UNSUPPORTED_ANDROID_VERSION");
        result.put("message", "Biometric authentication is not supported on this Android version.");
        return result;
    }

    private boolean hasBiometricFeature(Context context) {
        PackageManager packageManager = context.getPackageManager();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q
                && (packageManager.hasSystemFeature(PackageManager.FEATURE_FACE)
                || packageManager.hasSystemFeature(PackageManager.FEATURE_IRIS))) {
            return true;
        }
        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
                && packageManager.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT);
    }

    @TargetApi(Build.VERSION_CODES.P)
    private void showBiometricPrompt(JSONObject options, final CallbackContext callbackContext) {
        Activity activity = cordova.getActivity();
        Executor executor = activity.getMainExecutor();
        String title = options.optString("title", "Unlock");
        String subtitle = options.optString("subtitle", "");
        String description = options.optString("description", "");
        String negativeButton = options.optString("cancelText", "Cancel");
        boolean allowDeviceCredential = options.optBoolean("allowDeviceCredential", true);

        BiometricPrompt.Builder builder = new BiometricPrompt.Builder(activity).setTitle(title);
        if (!TextUtils.isEmpty(subtitle)) {
            builder.setSubtitle(subtitle);
        }
        if (!TextUtils.isEmpty(description)) {
            builder.setDescription(description);
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && allowDeviceCredential) {
            builder.setDeviceCredentialAllowed(true);
        } else {
            builder.setNegativeButton(negativeButton, executor, new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    sendError(callbackContext, "AUTHENTICATION_CANCELLED", "User cancelled biometric authentication.");
                }
            });
        }

        BiometricPrompt prompt = builder.build();
        CancellationSignal cancellationSignal = new CancellationSignal();
        prompt.authenticate(cancellationSignal, executor, new BiometricPrompt.AuthenticationCallback() {
            @Override
            public void onAuthenticationSucceeded(BiometricPrompt.AuthenticationResult authenticationResult) {
                try {
                    JSONObject result = new JSONObject();
                    result.put("unlocked", true);
                    result.put("biometryType", detectAndroidBiometryType(cordova.getActivity()));
                    callbackContext.success(result);

                    JSONObject event = new JSONObject(result.toString());
                    event.put("type", "unlock");
                    sendEventToJs(event);
                } catch (JSONException ex) {
                    sendError(callbackContext, "JSON_ERROR", ex.getMessage());
                }
            }

            @Override
            public void onAuthenticationError(int errorCode, CharSequence errString) {
                sendError(callbackContext, "AUTHENTICATION_ERROR", String.valueOf(errString));
            }

            @Override
            public void onAuthenticationFailed() {
                Log.d(TAG, "Biometric authentication attempt failed.");
            }
        });
    }

    private String detectAndroidBiometryType(Context context) {
        PackageManager packageManager = context.getPackageManager();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            if (packageManager.hasSystemFeature(PackageManager.FEATURE_FACE)) {
                return "face";
            }
            if (packageManager.hasSystemFeature(PackageManager.FEATURE_IRIS)) {
                return "iris";
            }
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
                && packageManager.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)) {
            return "fingerprint";
        }
        return "biometric";
    }

    private void completeFirebaseTask(Task<?> task, CallbackContext callbackContext) {
        if (!task.isSuccessful()) {
            Exception exception = task.getException();
            sendError(callbackContext, "FIREBASE_TASK_FAILED", exception == null ? "Firebase task failed." : exception.getMessage());
            return;
        }
        callbackContext.success();
    }

    private boolean ensureFirebaseInitialized(boolean logMissingConfig) {
        Context context = cordova.getActivity().getApplicationContext();
        if (!FirebaseApp.getApps(context).isEmpty()) {
            return true;
        }

        try {
            ApplicationInfo appInfo = context.getPackageManager().getApplicationInfo(context.getPackageName(), PackageManager.GET_META_DATA);
            Bundle metaData = appInfo.metaData;
            String appId = metadataString(metaData, "bluememe.firebase.app_id");
            String apiKey = metadataString(metaData, "bluememe.firebase.api_key");
            String projectId = metadataString(metaData, "bluememe.firebase.project_id");
            String senderId = metadataString(metaData, "bluememe.firebase.sender_id");
            String storageBucket = metadataString(metaData, "bluememe.firebase.storage_bucket");

            if (TextUtils.isEmpty(appId) || TextUtils.isEmpty(apiKey) || TextUtils.isEmpty(senderId)) {
                if (logMissingConfig) {
                    Log.w(TAG, "Firebase options are missing.");
                }
                return false;
            }

            FirebaseOptions.Builder builder = new FirebaseOptions.Builder()
                    .setApplicationId(appId)
                    .setApiKey(apiKey)
                    .setGcmSenderId(senderId);
            if (!TextUtils.isEmpty(projectId)) {
                builder.setProjectId(projectId);
            }
            if (!TextUtils.isEmpty(storageBucket)) {
                builder.setStorageBucket(storageBucket);
            }
            FirebaseApp.initializeApp(context, builder.build());
            return true;
        } catch (Exception ex) {
            Log.w(TAG, "Unable to initialize Firebase.", ex);
            return false;
        }
    }

    private void registerEventReceiver() {
        if (eventReceiver != null) {
            return;
        }
        final Context context = cordova.getActivity().getApplicationContext();
        eventReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context receiverContext, Intent intent) {
                String eventJson = intent.getStringExtra(EXTRA_EVENT);
                if (TextUtils.isEmpty(eventJson)) {
                    return;
                }
                try {
                    sendEventToJs(new JSONObject(eventJson));
                } catch (JSONException ex) {
                    Log.w(TAG, "Invalid event payload.", ex);
                }
            }
        };
        IntentFilter filter = new IntentFilter(eventAction(context));
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            context.registerReceiver(eventReceiver, filter, Context.RECEIVER_NOT_EXPORTED);
        } else {
            context.registerReceiver(eventReceiver, filter);
        }
    }

    private void unregisterEventReceiver() {
        if (eventReceiver == null) {
            return;
        }
        try {
            cordova.getActivity().getApplicationContext().unregisterReceiver(eventReceiver);
        } catch (RuntimeException ignored) {
            Log.d(TAG, "Event receiver was already unregistered.");
        }
        eventReceiver = null;
    }

    private void captureLaunchIntent(Intent intent) {
        JSONObject notification = notificationFromIntent(intent);
        if (notification == null) {
            return;
        }
        saveInitialNotification(cordova.getActivity(), notification);
        try {
            JSONObject event = new JSONObject();
            event.put("type", "notificationOpened");
            event.put("notification", notification);
            sendEventToJs(event);
        } catch (JSONException ex) {
            Log.w(TAG, "Unable to dispatch launch notification.", ex);
        }
    }

    private JSONObject notificationFromIntent(Intent intent) {
        if (intent == null || intent.getExtras() == null) {
            return null;
        }
        Bundle extras = intent.getExtras();
        String payload = extras.getString(EXTRA_PAYLOAD);
        if (!TextUtils.isEmpty(payload)) {
            try {
                return new JSONObject(payload);
            } catch (JSONException ex) {
                Log.w(TAG, "Invalid notification payload extra.", ex);
            }
        }

        boolean looksLikeFcm = extras.containsKey("google.message_id") || extras.containsKey("gcm.message_id");
        if (!looksLikeFcm) {
            return null;
        }
        return bundleToJson(extras);
    }

    private void sendEventToJs(JSONObject event) {
        if (notificationCallback == null) {
            return;
        }
        PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, event);
        pluginResult.setKeepCallback(true);
        notificationCallback.sendPluginResult(pluginResult);
    }

    private WifiManager wifiManager() {
        return (WifiManager) cordova.getActivity().getApplicationContext().getSystemService(Context.WIFI_SERVICE);
    }

    private ConnectivityManager connectivityManager() {
        return (ConnectivityManager) cordova.getActivity().getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
    }

    private static JSONObject permissionResult(String type, boolean granted, JSONArray missing) throws JSONException {
        JSONObject result = new JSONObject();
        result.put("type", type);
        result.put("granted", granted);
        result.put("missing", missing);
        return result;
    }

    private boolean allGranted(int[] grantResults) {
        if (grantResults == null || grantResults.length == 0) {
            return false;
        }
        for (int grantResult : grantResults) {
            if (grantResult != PackageManager.PERMISSION_GRANTED) {
                return false;
            }
        }
        return true;
    }

    private static String[] jsonArrayToStringArray(JSONArray array) {
        List<String> values = new ArrayList<>();
        for (int i = 0; i < array.length(); i++) {
            String value = array.optString(i, null);
            if (!TextUtils.isEmpty(value)) {
                values.add(value);
            }
        }
        return values.toArray(new String[0]);
    }

    private static String quote(String value) {
        if (value == null) {
            return "\"\"";
        }
        if (value.startsWith("\"") && value.endsWith("\"")) {
            return value;
        }
        return "\"" + value + "\"";
    }

    private static String metadataString(Bundle bundle, String key) {
        if (bundle == null || !bundle.containsKey(key)) {
            return "";
        }
        Object value = bundle.get(key);
        return value == null ? "" : String.valueOf(value);
    }

    static String eventAction(Context context) {
        return context.getPackageName() + ACTION_SUFFIX;
    }

    static void publishEvent(Context context, JSONObject event) {
        Intent intent = new Intent(eventAction(context));
        intent.setPackage(context.getPackageName());
        intent.putExtra(EXTRA_EVENT, event.toString());
        context.sendBroadcast(intent);
    }

    static void saveToken(Context context, String token) {
        if (TextUtils.isEmpty(token)) {
            return;
        }
        prefs(context).edit().putString(KEY_FCM_TOKEN, token).apply();
    }

    static void saveInitialNotification(Context context, JSONObject notification) {
        if (notification == null) {
            return;
        }
        prefs(context).edit().putString(KEY_INITIAL_NOTIFICATION, notification.toString()).apply();
    }

    static SharedPreferences prefs(Context context) {
        return context.getApplicationContext().getSharedPreferences(PREFS, Context.MODE_PRIVATE);
    }

    static JSONObject bundleToJson(Bundle bundle) {
        JSONObject json = new JSONObject();
        if (bundle == null) {
            return json;
        }
        for (String key : bundle.keySet()) {
            try {
                Object value = bundle.get(key);
                if (value instanceof Bundle) {
                    json.put(key, bundleToJson((Bundle) value));
                } else {
                    json.put(key, value == null ? JSONObject.NULL : String.valueOf(value));
                }
            } catch (JSONException ex) {
                Log.w(TAG, "Unable to add bundle value for key " + key + ".", ex);
            }
        }
        return json;
    }

    private void sendError(CallbackContext callbackContext, String code, String message) {
        try {
            JSONObject error = new JSONObject();
            error.put("code", code);
            error.put("message", message == null ? "" : message);
            callbackContext.error(error);
        } catch (JSONException ex) {
            callbackContext.error(code + ": " + message);
        }
    }
}