import os
import sys
from unittest.mock import MagicMock, mock_open, patch

import pytest
from flask import Flask

sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
from routes.wifi import parse_airodump_csv, wifi_bp


@pytest.fixture
def mock_app_module(mocker):
    """Mock the app_module imported inside routes.wifi."""
    mock = mocker.patch("routes.wifi.app_module")
    mock.wifi_lock = MagicMock()
    mock.wifi_process = None
    mock.wifi_monitor_interface = None
    mock.wifi_queue = MagicMock()
    mock.wifi_networks = {}
    mock_app_module.wifi_clients = {}
    return mock


@pytest.fixture
def app():
    app = Flask(__name__)
    app.register_blueprint(wifi_bp)
    return app


@pytest.fixture
def client(app):
    return app.test_client()


def test_parse_airodump_csv(mocker):
    """Test parsing logic for airodump CSV format."""
    csv_content = (
        "BSSID, First time seen, Last time seen, channel, Speed, Privacy, Cipher, Authentication, Power, # beacons, # IV, LAN IP, ID-length, ESSID, Key\n"
        "AA:BB:CC:DD:EE:FF, 2023-01-01, 2023-01-01, 6, 54, WPA2, CCMP, PSK, -50, 10, 5, 0.0.0.0, 7, MyWiFi, \n"
        "\n"
        "Station MAC, First time seen, Last time seen, Power, # packets, BSSID, Probes\n"
        "11:22:33:44:55:66, 2023-01-01, 2023-01-01, -60, 20, AA:BB:CC:DD:EE:FF, MyWiFi\n"
    )

    with patch("builtins.open", mock_open(read_data=csv_content)):
        mocker.patch("routes.wifi.get_manufacturer", return_value="Apple")
        networks, clients = parse_airodump_csv("dummy.csv")

        assert "AA:BB:CC:DD:EE:FF" in networks
        assert networks["AA:BB:CC:DD:EE:FF"]["essid"] == "MyWiFi"
        assert "11:22:33:44:55:66" in clients
        assert clients["11:22:33:44:55:66"]["vendor"] == "Apple"


### --- ROUTE TESTS --- ###


def test_get_interfaces(client, mocker):
    """Test the /interfaces endpoint."""
    mocker.patch("routes.wifi.detect_wifi_interfaces", return_value=[{"name": "wlan0", "type": "managed"}])
    mocker.patch("routes.wifi.check_tool", return_value=True)

    response = client.get("/wifi/interfaces")
    data = response.get_json()

    assert response.status_code == 200
    assert len(data["interfaces"]) == 1
    assert data["tools"]["airmon"] is True


def test_toggle_monitor_start_success(client, mocker):
    """Test enabling monitor mode via airmon-ng."""
    mocker.patch("routes.wifi.validate_network_interface", return_value="wlan0")
    mocker.patch("routes.wifi.check_tool", return_value=True)
    mock_run = mocker.patch("routes.wifi.subprocess.run")
    mock_run.return_value = MagicMock(stdout="enabled on [phy0]wlan0mon", stderr="", returncode=0)

    with patch("os.path.exists", return_value=True):
        response = client.post("/wifi/monitor", json={"action": "start", "interface": "wlan0"})

        assert response.status_code == 200
        assert response.get_json()["status"] == "success"
        assert response.get_json()["monitor_interface"] == "wlan0mon"


def test_start_scan_already_running(client, mock_app_module):
    """Test that we can't start a scan if one is already active."""
    mock_app_module.wifi_process = MagicMock()

    response = client.post("/wifi/scan/start", json={"interface": "wlan0mon"})
    data = response.get_json()
    assert data["status"] == "error"
    assert "already running" in data["message"]


def test_start_scan_execution(client, mock_app_module, mocker):
    """Test the full command construction of airodump-ng."""
    mock_app_module.wifi_process = None
    mocker.patch("os.path.exists", return_value=True)
    mocker.patch("routes.wifi.get_tool_path", return_value="/usr/bin/airodump-ng")

    mock_popen = mocker.patch("routes.wifi.subprocess.Popen")
    mock_proc = MagicMock()
    mock_proc.poll.return_value = None
    mock_popen.return_value = mock_proc

    payload = {"interface": "wlan0mon", "channel": 6, "band": "g"}
    response = client.post("/wifi/scan/start", json=payload)

    assert response.status_code == 200
    assert response.get_json()["status"] == "started"

    args, _ = mock_popen.call_args
    cmd = args[0]
    assert "-c" in cmd and "6" in cmd
    assert "wlan0mon" in cmd


def test_stop_scan(client, mock_app_module):
    """Test terminating the scanning process."""
    mock_proc = MagicMock()
    mock_app_module.wifi_process = mock_proc

    response = client.post("/wifi/scan/stop")

    assert response.status_code == 200
    assert response.get_json()["status"] == "stopped"
    mock_proc.terminate.assert_called_once()


def test_send_deauth_success(client, mock_app_module, mocker):
    """Verify deauth command construction and execution."""
    mocker.patch("routes.wifi.check_tool", return_value=True)
    mocker.patch("routes.wifi.get_tool_path", return_value="/usr/bin/aireplay-ng")
    mock_run = mocker.patch("routes.wifi.subprocess.run")
    mock_run.return_value = MagicMock(returncode=0)

    payload = {"bssid": "AA:BB:CC:DD:EE:FF", "count": 10, "interface": "wlan0mon"}
    response = client.post("/wifi/deauth", json=payload)

    assert response.status_code == 200
    args, _ = mock_run.call_args
    cmd = args[0]
    assert "--deauth" in cmd
    assert "10" in cmd
    assert "AA:BB:CC:DD:EE:FF" in cmd


### --- HANDSHAKE TESTS --- ###


def test_capture_handshake_start(client, mock_app_module, mocker):
    """Test starting airodump-ng for handshake capture."""
    mock_app_module.wifi_process = None
    mocker.patch("routes.wifi.get_tool_path", return_value="/usr/bin/airodump-ng")
    mock_popen = mocker.patch("routes.wifi.subprocess.Popen")

    payload = {"bssid": "AA:BB:CC:DD:EE:FF", "channel": "6", "interface": "wlan0mon"}
    response = client.post("/wifi/handshake/capture", json=payload)

    assert response.status_code == 200
    assert "capture_file" in response.get_json()
    assert mock_popen.called


def test_check_handshake_status_found(client, mocker):
    """Verify detection of 'KEY FOUND' in aircrack output."""
    mocker.patch("os.path.exists", return_value=True)
    mocker.patch("os.path.getsize", return_value=1024)
    mocker.patch("routes.wifi.get_tool_path", return_value="aircrack-ng")

    mock_run = mocker.patch("routes.wifi.subprocess.run")
    mock_run.return_value = MagicMock(stdout="WPA (1 handshake)", stderr="", returncode=0)

    payload = {"file": "/tmp/intercept_handshake_test.cap", "bssid": "AA:BB:CC:DD:EE:FF"}
    response = client.post("/wifi/handshake/status", json=payload)

    assert response.get_json()["handshake_found"] is True


### --- PMKID TESTS --- ###


def test_capture_pmkid_path_traversal_prevention(client):
    """Ensure the status check rejects invalid paths."""
    payload = {"file": "/etc/passwd"}  # Malicious path
    response = client.post("/wifi/pmkid/status", json=payload)

    assert response.status_code == 400
    assert response.get_json()["status"] == "error"
    assert "Invalid capture file path" in response.get_json()["message"]


### --- CRACKING TESTS --- ###


def test_crack_handshake_success(client, mocker):
    """Test successful password extraction using Regex."""
    mocker.patch("os.path.exists", return_value=True)
    mocker.patch("routes.wifi.get_tool_path", return_value="aircrack-ng")

    mock_run = mocker.patch("routes.wifi.subprocess.run")
    # Simulate the actual aircrack-ng success output
    mock_run.return_value = MagicMock(stdout="KEY FOUND! [ secret123 ]", stderr="", returncode=0)

    payload = {
        "capture_file": "/tmp/intercept_handshake_test.cap",
        "wordlist": "/home/user/passwords.txt",
        "bssid": "AA:BB:CC:DD:EE:FF",
    }
    response = client.post("/wifi/handshake/crack", json=payload)

    data = response.get_json()
    assert data["status"] == "success"
    assert data["password"] == "secret123"


### --- DATA FETCHING TESTS --- ###


def test_get_wifi_networks(client, mock_app_module):
    """Test that the networks endpoint correctly formats internal data."""
    mock_app_module.wifi_networks = {"AA:BB:CC:DD:EE:FF": {"essid": "Home-WiFi", "bssid": "AA:BB:CC:DD:EE:FF"}}
    mock_app_module.wifi_handshakes = ["AA:BB:CC:DD:EE:FF"]

    response = client.get("/wifi/networks")
    data = response.get_json()

    assert len(data["networks"]) == 1
    assert data["networks"][0]["essid"] == "Home-WiFi"
    assert "AA:BB:CC:DD:EE:FF" in data["handshakes"]