/**
 * @file test_sock_match.c
 * @brief Unit-тесты классификации сокетов и сопоставления адресов (sock_match).
 *
 * Тестирует только чистую логику sock_role_of / sock_target_class / sock_match
 * без сети и без UTUN_INSTANCE — с синтетическими struct sock_view и адресами.
 */
#include <stdio.h>
#include <string.h>
#include "../src/routing_layer/sock_match.h"
#include "../src/config_parser.h"
#include "../src/transport_layer/etcp_connections.h"
#include "../src/routing_layer/topo_node.h"

static int fails = 0;
static int checks = 0;

#define CHECK(cond, msg) do { checks++; if (!(cond)) { fails++; printf("FAIL: %s\n", msg); } } while (0)

static struct sock_view mk_view(uint8_t role, uint8_t has_inet, uint8_t has_priv, uint8_t is_eim, uint32_t pub4) {
    struct sock_view v; memset(&v, 0, sizeof(v));
    v.role = role; v.has_inet = has_inet; v.has_priv = has_priv; v.is_eim = is_eim; v.public_ip4 = pub4;
    return v;
}

static void test_role_of(void) {
    /* config -> role, при ntp_reachable=1 */
    CHECK(sock_role_of(CFG_SERVER_TYPE_PUBLIC,  NAT_TYPE_UNKNOWN, 1) == SOCK_ROLE_DIRECT, "public -> DIRECT");
    CHECK(sock_role_of(CFG_SERVER_TYPE_UNKNOWN, NAT_TYPE_UNKNOWN, 1) == SOCK_ROLE_DIRECT, "unknown -> DIRECT");
    CHECK(sock_role_of(CFG_SERVER_TYPE_NAT,     NAT_VERIFIED_EIM,   1) == SOCK_ROLE_DIRECT, "nat+EIM -> DIRECT");
    CHECK(sock_role_of(CFG_SERVER_TYPE_NAT,     NAT_VERIFIED_DIRECT,1) == SOCK_ROLE_DIRECT, "nat+DIRECT -> DIRECT");
    CHECK(sock_role_of(CFG_SERVER_TYPE_NAT,     NAT_VERIFIED_STRICT,1) == SOCK_ROLE_NAT,    "nat+STRICT -> NAT");
    CHECK(sock_role_of(CFG_SERVER_TYPE_NAT,     NAT_TYPE_UNKNOWN,   1) == SOCK_ROLE_NAT,    "nat+unknown -> NAT");
    CHECK(sock_role_of(CFG_SERVER_TYPE_PRIVATE, NAT_TYPE_UNKNOWN,   1) == SOCK_ROLE_NAT,    "private -> NAT");
    CHECK(sock_role_of(CFG_SERVER_TYPE_LOCAL,   NAT_TYPE_UNKNOWN,   1) == SOCK_ROLE_LOCAL,  "local -> LOCAL");
    /* NTP offline: все кроме LOCAL демотируются */
    CHECK(sock_role_of(CFG_SERVER_TYPE_PUBLIC,  NAT_TYPE_UNKNOWN, 0) == SOCK_ROLE_LOCAL, "offline public -> LOCAL");
    CHECK(sock_role_of(CFG_SERVER_TYPE_NAT,     NAT_VERIFIED_EIM, 0) == SOCK_ROLE_LOCAL, "offline nat+EIM -> LOCAL");
    CHECK(sock_role_of(CFG_SERVER_TYPE_PRIVATE, NAT_TYPE_UNKNOWN, 0) == SOCK_ROLE_LOCAL, "offline private -> LOCAL");
    CHECK(sock_role_of(CFG_SERVER_TYPE_LOCAL,   NAT_TYPE_UNKNOWN, 0) == SOCK_ROLE_LOCAL, "offline local -> LOCAL");
}

static void test_target_class(void) {
    CHECK(sock_target_class(TOPO_ADDR_INTERFACE, CFG_SERVER_TYPE_PUBLIC, NAT_TYPE_UNKNOWN) == SOCK_TC_PUB, "public INTERFACE -> PUB");
    CHECK(sock_target_class(TOPO_ADDR_INTERFACE, CFG_SERVER_TYPE_UNKNOWN, NAT_TYPE_UNKNOWN) == SOCK_TC_PUB, "unknown -> PUB");
    CHECK(sock_target_class(TOPO_ADDR_INTERFACE, CFG_SERVER_TYPE_LOCAL, NAT_TYPE_UNKNOWN) == SOCK_TC_PRIV, "local -> PRIV");
    CHECK(sock_target_class(TOPO_ADDR_INTERFACE, CFG_SERVER_TYPE_PRIVATE, NAT_TYPE_UNKNOWN) == SOCK_TC_PRIV, "private -> PRIV");
    CHECK(sock_target_class(TOPO_ADDR_NAT, CFG_SERVER_TYPE_NAT, NAT_VERIFIED_EIM) == SOCK_TC_PUB, "nat+EIM NAT-addr -> PUB");
    CHECK(sock_target_class(TOPO_ADDR_INTERFACE, CFG_SERVER_TYPE_NAT, NAT_VERIFIED_EIM) == SOCK_TC_PRIV, "nat+EIM INTERFACE -> PRIV");
    CHECK(sock_target_class(TOPO_ADDR_NAT, CFG_SERVER_TYPE_NAT, NAT_VERIFIED_DIRECT) == SOCK_TC_PUB, "nat+DIRECT NAT-addr -> PUB");
    CHECK(sock_target_class(TOPO_ADDR_NAT, CFG_SERVER_TYPE_NAT, NAT_VERIFIED_STRICT) == SOCK_TC_UNREACH, "nat+STRICT NAT-addr -> UNREACH");
    CHECK(sock_target_class(TOPO_ADDR_INTERFACE, CFG_SERVER_TYPE_NAT, NAT_VERIFIED_STRICT) == SOCK_TC_PRIV, "nat+STRICT INTERFACE -> PRIV");
    CHECK(sock_target_class(TOPO_ADDR_NAT, CFG_SERVER_TYPE_NAT, NAT_TYPE_UNKNOWN) == SOCK_TC_UNREACH, "nat+unknown NAT-addr -> UNREACH");
    CHECK(sock_target_class(TOPO_ADDR_INTERFACE, CFG_SERVER_TYPE_NAT, NAT_TYPE_UNKNOWN) == SOCK_TC_PRIV, "nat+unknown INTERFACE -> PRIV");
}

static void test_match(void) {
    uint32_t pub = 0x01020304u;   /* произвольный "публичный" IP */
    struct sock_view direct   = mk_view(SOCK_ROLE_DIRECT, 1, 0, 0, pub);
    struct sock_view natout   = mk_view(SOCK_ROLE_NAT,    1, 1, 0, 0);
    struct sock_view local    = mk_view(SOCK_ROLE_LOCAL,  0, 1, 0, 0);

    /* наш DIRECT (публичный) */
    CHECK(sock_match(&direct, TOPO_ADDR_NAT, CFG_SERVER_TYPE_PUBLIC, NAT_TYPE_UNKNOWN, pub) == 1, "DIRECT->PUB ok");
    CHECK(sock_match(&direct, TOPO_ADDR_INTERFACE, CFG_SERVER_TYPE_LOCAL, NAT_TYPE_UNKNOWN, 0) == 0, "DIRECT->PRIV нет приватного интерфейса");
    /* наш NAT (outbound-only) */
    CHECK(sock_match(&natout, TOPO_ADDR_NAT, CFG_SERVER_TYPE_PUBLIC, NAT_TYPE_UNKNOWN, pub) == 1, "NAT->PUB ok");
    CHECK(sock_match(&natout, TOPO_ADDR_INTERFACE, CFG_SERVER_TYPE_NAT, NAT_VERIFIED_STRICT, 0) == 1, "NAT->PRIV (есть приватный)");
    /* наш LOCAL (без интернета) */
    CHECK(sock_match(&local, TOPO_ADDR_NAT, CFG_SERVER_TYPE_PUBLIC, NAT_TYPE_UNKNOWN, pub) == 0, "LOCAL->PUB нет интернета");
    CHECK(sock_match(&local, TOPO_ADDR_INTERFACE, CFG_SERVER_TYPE_LOCAL, NAT_TYPE_UNKNOWN, 0) == 1, "LOCAL->PRIV ок (LAN)");
    /* UNREACH цель */
    CHECK(sock_match(&direct, TOPO_ADDR_NAT, CFG_SERVER_TYPE_NAT, NAT_VERIFIED_STRICT, pub) == 0, "строгий NAT-адрес недостижим");
    /* hairpin: оба EIM, одинаковый публичный IP */
    struct sock_view eim = mk_view(SOCK_ROLE_DIRECT, 1, 1, 1, pub);
    CHECK(sock_match(&eim, TOPO_ADDR_NAT, CFG_SERVER_TYPE_NAT, NAT_VERIFIED_EIM, pub) == 0, "hairpin (одинаковый публичный IP)");
    CHECK(sock_match(&eim, TOPO_ADDR_NAT, CFG_SERVER_TYPE_NAT, NAT_VERIFIED_EIM, 0x05060708u) == 1, "EIM разные публичные IP -> ok");
}

int main(void) {
    test_role_of();
    test_target_class();
    test_match();
    if (fails) { printf("RESULT: %d/%d failed\n", fails, checks); return 1; }
    printf("RESULT: all %d checks passed\n", checks);
    return 0;
}