#include "tt_mdns.h"

#include <Tactility/network/Mdns.h>
#include <cstring>
#include <algorithm>

extern "C" {

bool tt_mdns_is_available() {
    return tt::network::mdns::isAvailable();
}

bool tt_mdns_browse(const char* serviceType, const char* proto, uint32_t timeoutMs, size_t maxResults, TtMdnsBrowseResult* outResult) {
    if (outResult == nullptr) return false;
    if (serviceType == nullptr || proto == nullptr) return false;

    memset(outResult, 0, sizeof(TtMdnsBrowseResult));

    uint32_t effectiveTimeout = timeoutMs == 0 ? 3000 : timeoutMs;
    size_t effectiveMax = maxResults == 0 ? 20 : maxResults;
    effectiveMax = std::min<size_t>(effectiveMax, TT_MDNS_MAX_RESULTS);

    std::vector<tt::network::mdns::Service> services;
    if (!tt::network::mdns::browse(serviceType, proto, effectiveTimeout, effectiveMax, services)) {
        return false;
    }

    size_t toCopy = std::min(services.size(), static_cast<size_t>(TT_MDNS_MAX_RESULTS));
    for (size_t i = 0; i < toCopy; i++) {
        const auto& src = services[i];
        auto& dst = outResult->services[i];

        strncpy(dst.instanceName, src.instanceName.c_str(), TT_MDNS_INSTANCE_LEN - 1);
        strncpy(dst.serviceType, src.serviceType.c_str(), TT_MDNS_SERVICE_TYPE_LEN - 1);
        strncpy(dst.proto, src.proto.c_str(), TT_MDNS_PROTO_LEN - 1);
        strncpy(dst.hostname, src.hostname.c_str(), TT_MDNS_HOSTNAME_LEN - 1);
        dst.port = src.port;
        dst.ttl = src.ttl;
        strncpy(dst.primaryAddress, src.primaryAddress.c_str(), TT_MDNS_IP_LEN - 1);

        size_t addrCount = std::min(src.addresses.size(), static_cast<size_t>(TT_MDNS_MAX_ADDRESSES));
        dst.addressCount = static_cast<uint8_t>(addrCount);
        for (size_t a = 0; a < addrCount; a++) {
            strncpy(dst.addresses[a], src.addresses[a].c_str(), TT_MDNS_IP_LEN - 1);
        }

        size_t txtCount = std::min(src.txtRecords.size(), static_cast<size_t>(TT_MDNS_MAX_TXT_RECORDS));
        dst.txtCount = static_cast<uint8_t>(txtCount);
        size_t idx = 0;
        for (const auto& kv : src.txtRecords) {
            if (idx >= txtCount) break;
            strncpy(dst.txtRecords[idx].key, kv.first.c_str(), TT_MDNS_TXT_KEY_LEN - 1);
            strncpy(dst.txtRecords[idx].value, kv.second.c_str(), TT_MDNS_TXT_VALUE_LEN - 1);
            idx++;
        }
    }

    outResult->count = static_cast<uint8_t>(toCopy);
    return true;
}

bool tt_mdns_resolve_hostname(const char* hostname, uint32_t timeoutMs, char* outIp) {
    if (hostname == nullptr || outIp == nullptr) return false;
    memset(outIp, 0, TT_MDNS_IP_LEN);

    uint32_t effectiveTimeout = timeoutMs == 0 ? 2000 : timeoutMs;
    std::string ip;
    if (!tt::network::mdns::resolveHostname(hostname, effectiveTimeout, ip)) {
        return false;
    }

    strncpy(outIp, ip.c_str(), TT_MDNS_IP_LEN - 1);
    return true;
}

} // extern "C"