package com.example.mylauncher;

import android.content.Context;
import android.net.wifi.WifiManager;
import android.widget.Toast;
import android.util.Log;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import android.net.wifi.ScanResult;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;

public class WifiConnectionManager {
    private static final String TAG = "WifiConnectionManager";
    private final Context context;
    private final MainActivity activity;
    private final WifiManager wifiManager;

    public WifiConnectionManager(Context context, MainActivity activity) {
        this.context = context;
        this.activity = activity;
        this.wifiManager = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
    }

    public List<String> getKnownNetworks() {
        try {
            Log.d(TAG, "Getting list of known networks...");
            String result = executeCommandWithOutput("cmd wifi list-networks");
            Log.d(TAG, "Raw output from list-networks command: " + result);

            List<String> knownNetworks = new ArrayList<>();


            String[] lines = result.split("\n");
            for (String line : lines) {
                Log.d(TAG, "Processing line: '" + line + "'");

                if (!line.trim().isEmpty() && !line.contains("Network") && !line.contains("Error:")) {

                    String[] parts = line.trim().split("\\s+");
                    if (parts.length >= 2) {
                        String networkName = parts[1];
                        Log.d(TAG, "Found network name: " + networkName);
                        if (!knownNetworks.contains(networkName)) {
                            knownNetworks.add(networkName);
                        }
                    }
                }
            }

            Log.d(TAG, "Final list of known networks: " + knownNetworks);
            return knownNetworks;
        } catch (Exception e) {
            Log.e(TAG, "Error getting known networks", e);
            return new ArrayList<>();
        }
    }

    public void connectToWifi(final String ssid, boolean isKnown) {
        try {
            Log.d(TAG, "Starting WiFi connection process for: " + ssid + " (Known: " + isKnown + ")");

            String wifiState = executeCommandWithOutput("cmd wifi status");
            Log.d(TAG, "Current WiFi state: " + wifiState);

            executeCommand("svc wifi enable");
            Thread.sleep(2000);

            if (!isKnown) {
                boolean isSecured = false;
                for (ScanResult result : wifiManager.getScanResults()) {
                    if (result.SSID.equals(ssid)) {
                        isSecured = result.capabilities != null &&
                                  (result.capabilities.contains("WEP") ||
                                   result.capabilities.contains("PSK") ||
                                   result.capabilities.contains("EAP"));
                        Log.d(TAG, "Network " + ssid + " security: " + result.capabilities);
                        break;
                    }
                }

                if (isSecured) {
                    Log.d(TAG, "Network is secured, prompting for password");
                    activity.runOnUiThread(() -> {
                        activity.promptForPassword(ssid);
                    });
                    return;
                }
            }

            String result = executeCommandWithOutput(
                String.format("cmd wifi connect-network %s", ssid)
            );
            Log.d(TAG, "Connect result: " + result);

            Thread.sleep(2000);
            String finalState = executeCommandWithOutput("cmd wifi status");
            Log.d(TAG, "Final state: " + finalState);

            activity.runOnUiThread(() ->
                Toast.makeText(context, "Connection attempt completed for " + ssid,
                    Toast.LENGTH_SHORT).show()
            );

        } catch (Exception e) {
            Log.e(TAG, "Error in connectToWifi", e);
            activity.runOnUiThread(() -> {
                Toast.makeText(context, "Error: " + e.getMessage(), Toast.LENGTH_SHORT).show();
            });
        }
    }

    public void connectToNetwork(String ssid, String password) {
        try {
            Log.d(TAG, "Attempting to connect to secured network: " + ssid);

            String connectCommand = String.format("cmd wifi connect-network %s wpa2 %s", ssid, password);
            String result = executeCommandWithOutput(connectCommand);
            Log.d(TAG, "Connect command result: " + result);

            Thread.sleep(2000);
            String finalState = executeCommandWithOutput("cmd wifi status");
            Log.d(TAG, "Final state after secured connection: " + finalState);

            activity.runOnUiThread(() ->
                Toast.makeText(context, "Connection attempt completed for " + ssid,
                    Toast.LENGTH_SHORT).show()
            );

        } catch (Exception e) {
            Log.e(TAG, "Error in connectToNetwork", e);
            activity.runOnUiThread(() -> {
                Toast.makeText(context, "Error: " + e.getMessage(), Toast.LENGTH_SHORT).show();
            });
        }
    }

    private void executeCommand(String command) throws Exception {
        Process process = Runtime.getRuntime().exec("su");
        DataOutputStream os = new DataOutputStream(process.getOutputStream());
        os.writeBytes(command + "\n");
        os.writeBytes("exit\n");
        os.flush();
        process.waitFor();
    }

    private String executeCommandWithOutput(String command) throws Exception {
        Process process = Runtime.getRuntime().exec("su");
        DataOutputStream os = new DataOutputStream(process.getOutputStream());
        os.writeBytes(command + "\n");
        os.writeBytes("exit\n");
        os.flush();

        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        StringBuilder output = new StringBuilder();
        String line;
        while ((line = reader.readLine()) != null) {
            output.append(line).append("\n");
        }

        reader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
        while ((line = reader.readLine()) != null) {
            output.append("Error: ").append(line).append("\n");
        }

        process.waitFor();
        return output.toString();
    }
}