#include "network/nm_connection.h"
#include "network/nm_types.h"
#include <gtest/gtest.h>
#include <stdexcept>
#include <string>

using namespace radiantwave::network;

// ─── Open Network Tests ────────────────────────────────────────────────

TEST(ConnectionBuilderTest, OpenNetworkNoSecurity) {
    auto settings = buildConnectionSettings("MyWiFi", "", SecurityType::Open);
    
    // Should have connection, wireless, ipv4, ipv6 sections
    EXPECT_EQ(settings.count("connection"), 1u);
    EXPECT_EQ(settings.count("802-11-wireless"), 1u);
    EXPECT_EQ(settings.count("ipv4"), 1u);
    EXPECT_EQ(settings.count("ipv6"), 1u);
    
    // Should NOT have security section
    EXPECT_EQ(settings.count("802-11-wireless-security"), 0u);
}

TEST(ConnectionBuilderTest, OpenNetworkConnectionId) {
    auto settings = buildConnectionSettings("MyWiFi", "", SecurityType::Open);
    auto& conn = settings["connection"];
    
    EXPECT_EQ(std::get<std::string>(conn["id"]), "MyWiFi");
    EXPECT_EQ(std::get<std::string>(conn["type"]), "802-11-wireless");
    EXPECT_EQ(std::get<bool>(conn["autoconnect"]), true);
}

TEST(ConnectionBuilderTest, OpenNetworkWirelessMode) {
    auto settings = buildConnectionSettings("MyWiFi", "", SecurityType::Open);
    auto& wireless = settings["802-11-wireless"];
    
    EXPECT_EQ(std::get<std::string>(wireless["mode"]), "infrastructure");
}

TEST(ConnectionBuilderTest, OpenNetworkIpSettings) {
    auto settings = buildConnectionSettings("MyWiFi", "", SecurityType::Open);
    
    EXPECT_EQ(std::get<std::string>(settings["ipv4"]["method"]), "auto");
    EXPECT_EQ(std::get<std::string>(settings["ipv6"]["method"]), "auto");
}

// ─── SSID Handling Tests ───────────────────────────────────────────────

TEST(ConnectionBuilderTest, SSIDIsByteArray) {
    auto settings = buildConnectionSettings("MyWiFi", "", SecurityType::Open);
    auto& wireless = settings["802-11-wireless"];
    
    auto ssid = std::get<std::vector<uint8_t>>(wireless["ssid"]);
    EXPECT_EQ(ssid.size(), 6u);
    EXPECT_EQ(std::string(ssid.begin(), ssid.end()), "MyWiFi");
}

TEST(ConnectionBuilderTest, SSIDWithSpaces) {
    auto settings = buildConnectionSettings("My WiFi Network", "", SecurityType::Open);
    auto& wireless = settings["802-11-wireless"];
    
    auto ssid = std::get<std::vector<uint8_t>>(wireless["ssid"]);
    EXPECT_EQ(std::string(ssid.begin(), ssid.end()), "My WiFi Network");
}

TEST(ConnectionBuilderTest, SSIDWithUnicode) {
    auto settings = buildConnectionSettings("Café WiFi", "", SecurityType::Open);
    auto& wireless = settings["802-11-wireless"];
    
    auto ssid = std::get<std::vector<uint8_t>>(wireless["ssid"]);
    std::string ssid_str(ssid.begin(), ssid.end());
    EXPECT_EQ(ssid_str, "Café WiFi");
}

TEST(ConnectionBuilderTest, SSIDWithJapanese) {
    auto settings = buildConnectionSettings("日本語ネットワーク", "", SecurityType::Open);
    auto& wireless = settings["802-11-wireless"];
    
    auto ssid = std::get<std::vector<uint8_t>>(wireless["ssid"]);
    std::string ssid_str(ssid.begin(), ssid.end());
    EXPECT_EQ(ssid_str, "日本語ネットワーク");
}

TEST(ConnectionBuilderTest, EmptySSIDFails) {
    EXPECT_THROW(
        buildConnectionSettings("", "", SecurityType::Open),
        std::invalid_argument
    );
}

TEST(ConnectionBuilderTest, SSIDTooLongFails) {
    // SSIDs max 32 bytes
    std::string long_ssid(33, 'A');
    EXPECT_THROW(
        buildConnectionSettings(long_ssid, "", SecurityType::Open),
        std::invalid_argument
    );
}

TEST(ConnectionBuilderTest, SSIDWithNullByteFails) {
    EXPECT_THROW(
        buildConnectionSettings(std::string("My\0WiFi", 7), "", SecurityType::Open),
        std::invalid_argument
    );
}

// ─── WPA2 Tests ────────────────────────────────────────────────────────

TEST(ConnectionBuilderTest, WPA2HasSecuritySection) {
    auto settings = buildConnectionSettings("SecureNet", "password123", SecurityType::WPA2);
    EXPECT_EQ(settings.count("802-11-wireless-security"), 1u);
}

TEST(ConnectionBuilderTest, WPA2KeyMgmt) {
    auto settings = buildConnectionSettings("SecureNet", "password123", SecurityType::WPA2);
    auto& sec = settings["802-11-wireless-security"];
    
    EXPECT_EQ(std::get<std::string>(sec["key-mgmt"]), "wpa-psk");
    EXPECT_EQ(std::get<std::string>(sec["auth-alg"]), "open");
}

TEST(ConnectionBuilderTest, WPA2Password) {
    auto settings = buildConnectionSettings("SecureNet", "password123", SecurityType::WPA2);
    auto& sec = settings["802-11-wireless-security"];
    
    EXPECT_EQ(std::get<std::string>(sec["psk"]), "password123");
}

TEST(ConnectionBuilderTest, WPA2EmptyPasswordFails) {
    EXPECT_THROW(
        buildConnectionSettings("SecureNet", "", SecurityType::WPA2),
        std::invalid_argument
    );
}

TEST(ConnectionBuilderTest, WPA2ShortPasswordFails) {
    EXPECT_THROW(
        buildConnectionSettings("SecureNet", "short", SecurityType::WPA2),
        std::invalid_argument
    );
}

TEST(ConnectionBuilderTest, WPA2LongPasswordFails) {
    // Max 63 characters
    std::string long_pass(64, 'a');
    EXPECT_THROW(
        buildConnectionSettings("SecureNet", long_pass, SecurityType::WPA2),
        std::invalid_argument
    );
}

TEST(ConnectionBuilderTest, WPA2MaxPassword) {
    std::string max_pass(63, 'a');
    EXPECT_NO_THROW(
        buildConnectionSettings("SecureNet", max_pass, SecurityType::WPA2)
    );
}

// ─── WPA3 Tests ────────────────────────────────────────────────────────

TEST(ConnectionBuilderTest, WPA3KeyMgmt) {
    auto settings = buildConnectionSettings("SecureNet3", "password123", SecurityType::WPA3);
    auto& sec = settings["802-11-wireless-security"];
    
    EXPECT_EQ(std::get<std::string>(sec["key-mgmt"]), "sae");
}

TEST(ConnectionBuilderTest, WPA3Password) {
    auto settings = buildConnectionSettings("SecureNet3", "password123", SecurityType::WPA3);
    auto& sec = settings["802-11-wireless-security"];
    
    EXPECT_EQ(std::get<std::string>(sec["psk"]), "password123");
}

TEST(ConnectionBuilderTest, WPA3EmptyPasswordFails) {
    EXPECT_THROW(
        buildConnectionSettings("SecureNet3", "", SecurityType::WPA3),
        std::invalid_argument
    );
}

// ─── WEP Tests ─────────────────────────────────────────────────────────

TEST(ConnectionBuilderTest, WEPKeyMgmt) {
    auto settings = buildConnectionSettings("OldNet", "weppass", SecurityType::WEP);
    auto& sec = settings["802-11-wireless-security"];
    
    EXPECT_EQ(std::get<std::string>(sec["key-mgmt"]), "none");
}

TEST(ConnectionBuilderTest, WEPPassword) {
    auto settings = buildConnectionSettings("OldNet", "weppass", SecurityType::WEP);
    auto& sec = settings["802-11-wireless-security"];
    
    EXPECT_EQ(std::get<std::string>(sec["wep-key0"]), "weppass");
}

TEST(ConnectionBuilderTest, WEPKeyType) {
    auto settings = buildConnectionSettings("OldNet", "weppass", SecurityType::WEP);
    auto& sec = settings["802-11-wireless-security"];
    
    EXPECT_EQ(std::get<uint32_t>(sec["wep-key-type"]), 1u);
}

TEST(ConnectionBuilderTest, WEPEmptyPasswordFails) {
    EXPECT_THROW(
        buildConnectionSettings("OldNet", "", SecurityType::WEP),
        std::invalid_argument
    );
}

// ─── Special Character Tests ───────────────────────────────────────────

TEST(ConnectionBuilderTest, PasswordWithSingleQuote) {
    auto settings = buildConnectionSettings("Net", "p@ss'w0rd", SecurityType::WPA2);
    auto& sec = settings["802-11-wireless-security"];
    
    EXPECT_EQ(std::get<std::string>(sec["psk"]), "p@ss'w0rd");
}

TEST(ConnectionBuilderTest, PasswordWithDoubleQuote) {
    auto settings = buildConnectionSettings("Net", R"(p@ss"w0rd)", SecurityType::WPA2);
    auto& sec = settings["802-11-wireless-security"];
    
    EXPECT_EQ(std::get<std::string>(sec["psk"]), R"(p@ss"w0rd)");
}

TEST(ConnectionBuilderTest, PasswordWithAt) {
    auto settings = buildConnectionSettings("Net", "user@domain.com", SecurityType::WPA2);
    auto& sec = settings["802-11-wireless-security"];
    
    EXPECT_EQ(std::get<std::string>(sec["psk"]), "user@domain.com");
}

TEST(ConnectionBuilderTest, PasswordWithSpecialChars) {
    std::string special = "!@#$%^&*()_+-=[]{}|;':\",./<>?`~";
    auto settings = buildConnectionSettings("Net", special, SecurityType::WPA2);
    auto& sec = settings["802-11-wireless-security"];
    
    EXPECT_EQ(std::get<std::string>(sec["psk"]), special);
}

TEST(ConnectionBuilderTest, PasswordWithSpaces) {
    auto settings = buildConnectionSettings("Net", "password with spaces", SecurityType::WPA2);
    auto& sec = settings["802-11-wireless-security"];
    
    EXPECT_EQ(std::get<std::string>(sec["psk"]), "password with spaces");
}

TEST(ConnectionBuilderTest, PasswordWithUnicode) {
    auto settings = buildConnectionSettings("Net", "pässwörd", SecurityType::WPA2);
    auto& sec = settings["802-11-wireless-security"];
    
    EXPECT_EQ(std::get<std::string>(sec["psk"]), "pässwörd");
}

TEST(ConnectionBuilderTest, PasswordWithEmoji) {
    auto settings = buildConnectionSettings("Net", "🔐🔑password", SecurityType::WPA2);
    auto& sec = settings["802-11-wireless-security"];
    
    EXPECT_EQ(std::get<std::string>(sec["psk"]), "🔐🔑password");
}

// ─── Security Detection Tests ──────────────────────────────────────────

TEST(SecurityDetectionTest, OpenNetwork) {
    EXPECT_EQ(detectSecurityType(0, 0, 0), SecurityType::Open);
}

TEST(SecurityDetectionTest, WEPWithPrivacy) {
    EXPECT_EQ(detectSecurityType(0x01, 0, 0), SecurityType::WEP);
}

TEST(SecurityDetectionTest, WPAWithWpaFlags) {
    EXPECT_EQ(detectSecurityType(0, 0x01, 0), SecurityType::WPA);
}

TEST(SecurityDetectionTest, WPA2WithRsnPsk) {
    EXPECT_EQ(detectSecurityType(0, 0, 0x100), SecurityType::WPA2);
}

TEST(SecurityDetectionTest, WPA3WithSae) {
    EXPECT_EQ(detectSecurityType(0, 0, 0x400), SecurityType::WPA3);
}

TEST(SecurityDetectionTest, WPA3TakesPrecedenceOverWPA2) {
    // SAE (0x400) should be detected before PSK (0x100)
    EXPECT_EQ(detectSecurityType(0, 0, 0x500), SecurityType::WPA3);
}

TEST(SecurityDetectionTest, WPA2TakesPrecedenceOverWPA) {
    // RSN PSK should be detected before WPA flags
    EXPECT_EQ(detectSecurityType(0, 0x01, 0x100), SecurityType::WPA2);
}

// ─── SSID Utility Tests ────────────────────────────────────────────────

TEST(SsidTest, SsidToBytesRoundTrip) {
    std::string ssid = "MyWiFi";
    auto bytes = ssidToBytes(ssid);
    auto result = bytesToSsid(bytes);
    
    EXPECT_EQ(result, ssid);
}

TEST(SsidTest, SsidToBytesUnicode) {
    std::string ssid = "Café";
    auto bytes = ssidToBytes(ssid);
    auto result = bytesToSsid(bytes);
    
    EXPECT_EQ(result, ssid);
}

TEST(SsidTest, IsValidSsidNormal) {
    EXPECT_TRUE(isValidSsid("MyWiFi"));
    EXPECT_TRUE(isValidSsid("A"));
    EXPECT_TRUE(isValidSsid(std::string(32, 'A')));
}

TEST(SsidTest, IsValidSsidEmpty) {
    EXPECT_FALSE(isValidSsid(""));
}

TEST(SsidTest, IsValidSsidTooLong) {
    EXPECT_FALSE(isValidSsid(std::string(33, 'A')));
}

TEST(SsidTest, IsValidSsidWithNull) {
    EXPECT_FALSE(isValidSsid(std::string("My\0WiFi", 7)));
}

// ─── Helper Function Tests ─────────────────────────────────────────────

TEST(HelperTest, RequiresPassword) {
    EXPECT_FALSE(requiresPassword(SecurityType::Open));
    EXPECT_TRUE(requiresPassword(SecurityType::WEP));
    EXPECT_TRUE(requiresPassword(SecurityType::WPA));
    EXPECT_TRUE(requiresPassword(SecurityType::WPA2));
    EXPECT_TRUE(requiresPassword(SecurityType::WPA3));
}

TEST(HelperTest, SecurityTypeToString) {
    EXPECT_STREQ(securityTypeToString(SecurityType::Open), "Open");
    EXPECT_STREQ(securityTypeToString(SecurityType::WEP), "WEP");
    EXPECT_STREQ(securityTypeToString(SecurityType::WPA), "WPA");
    EXPECT_STREQ(securityTypeToString(SecurityType::WPA2), "WPA2");
    EXPECT_STREQ(securityTypeToString(SecurityType::WPA3), "WPA3");
}

TEST(HelperTest, ConnectionStateToString) {
    EXPECT_STREQ(connectionStateToString(ConnectionState::Disconnected), "Disconnected");
    EXPECT_STREQ(connectionStateToString(ConnectionState::Activated), "Connected");
    EXPECT_STREQ(connectionStateToString(ConnectionState::Failed), "Failed");
    EXPECT_STREQ(connectionStateToString(ConnectionState::NeedAuth), "Authentication Required");
}

// ─── UUID Generation Tests ─────────────────────────────────────────────

TEST(UuidTest, UUIDFormat) {
    auto settings = buildConnectionSettings("Net", "", SecurityType::Open);
    auto uuid = std::get<std::string>(settings["connection"]["uuid"]);
    
    // UUID format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
    EXPECT_EQ(uuid.size(), 36u);
    EXPECT_EQ(uuid[8], '-');
    EXPECT_EQ(uuid[13], '-');
    EXPECT_EQ(uuid[18], '-');
    EXPECT_EQ(uuid[23], '-');
    EXPECT_EQ(uuid[14], '4');  // Version 4
}

TEST(UuidTest, UniqueUUIDs) {
    auto settings1 = buildConnectionSettings("Net1", "", SecurityType::Open);
    auto settings2 = buildConnectionSettings("Net2", "", SecurityType::Open);
    
    auto uuid1 = std::get<std::string>(settings1["connection"]["uuid"]);
    auto uuid2 = std::get<std::string>(settings2["connection"]["uuid"]);
    
    EXPECT_NE(uuid1, uuid2);
}