package com.reactnativevstarcam;

import android.content.Context;
import android.content.pm.PackageManager;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.util.Log;

import androidx.annotation.NonNull;
import androidx.core.app.ActivityCompat;

import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;
import com.facebook.react.bridge.WritableArray;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.module.annotations.ReactModule;

import java.util.List;

@ReactModule(name = "WifiModule")
public class WifiModule extends ReactContextBaseJavaModule {
    static {
        Log.d("WifiModule", "WifiModule class loaded by JVM");
    }
    public static final String MODULE_NAME = "WifiModule";
    private static final String TAG = "WifiModule";

    private final ReactApplicationContext reactContext;

    public WifiModule(ReactApplicationContext reactContext) {
        super(reactContext);
        this.reactContext = reactContext;
    }

    @NonNull
    @Override
    public String getName() {
        return MODULE_NAME;
    }

    @ReactMethod
    public void getCurrentSSID(Promise promise) {
        try {
            WifiManager wifiManager = (WifiManager) reactContext.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
            if (wifiManager == null) {
                promise.resolve(null);
                return;
            }

            WifiInfo info = wifiManager.getConnectionInfo();
            if (info == null) {
                promise.resolve(null);
                return;
            }

            String ssid = info.getSSID();
            // Android returns SSID with quotes, e.g. "MyNetwork", remove them
            if (ssid != null && ssid.length() > 1 && ssid.startsWith("\"") && ssid.endsWith("\"")) {
                ssid = ssid.substring(1, ssid.length() - 1);
            }

            // Handle "unknown ssid" case
            if ("<unknown ssid>".equals(ssid)) {
                promise.resolve(null);
            } else {
                promise.resolve(ssid);
            }
        } catch (Exception e) {
            Log.e(TAG, "Failed to get SSID", e);
            promise.resolve(null);
        }
    }

    @ReactMethod
    public void getCurrentBSSID(Promise promise) {
        try {
            WifiManager wifiManager = (WifiManager) reactContext.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
            if (wifiManager == null) {
                promise.resolve(null);
                return;
            }

            WifiInfo info = wifiManager.getConnectionInfo();
            if (info == null) {
                promise.resolve(null);
                return;
            }

            String bssid = info.getBSSID();
            // BSSID is usually a MAC address like 00:00:00:00:00:00
            // The O-KAM format expects it without colons, e.g., "aec9ea203129"
            if (bssid != null) {
                bssid = bssid.replace(":", "").toLowerCase();
            }

            promise.resolve(bssid);
        } catch (Exception e) {
            Log.e(TAG, "Failed to get BSSID", e);
            promise.resolve(null);
        }
    }

    @ReactMethod
    public void getWifiList(Promise promise) {
        try {
            WifiManager wifiManager = (WifiManager) reactContext.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
            if (wifiManager == null) {
                promise.reject("WIFI_ERROR", "WifiManager not available");
                return;
            }

            // Check location permission (required for scanning)
            if (ActivityCompat.checkSelfPermission(reactContext, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
                promise.reject("PERMISSION_ERROR", "Location permission not granted");
                return;
            }

            // Start scan (deprecated in newer Android but often still works or triggers last known results)
            boolean success = wifiManager.startScan();
            if (!success) {
                Log.w(TAG, "WifiManager.startScan() returned false - limits may apply");
                // Attempt to get results anyway as they might be cached
            }

            List<ScanResult> results = wifiManager.getScanResults();
            WritableArray jsonArray = Arguments.createArray();

            for (ScanResult result : results) {
                // Filter out empty SSIDs
                if (result.SSID != null && !result.SSID.isEmpty()) {
                    WritableMap map = Arguments.createMap();
                    map.putString("SSID", result.SSID);
                    map.putString("BSSID", result.BSSID);
                    map.putInt("level", result.level); // Signal strength
                    map.putInt("frequency", result.frequency);
                    // Simple logic to guess capabilities partial string
                    map.putString("capabilities", result.capabilities);
                    
                    jsonArray.pushMap(map);
                }
            }
            
            promise.resolve(jsonArray);

        } catch (Exception e) {
            Log.e(TAG, "Failed to scan Wifi", e);
            promise.reject("SCAN_ERROR", e.getMessage());
        }
    }
}