// SPDX-License-Identifier: GPL-2.0
#include <stdio.h>
#include <string.h>

#include <ynl.h>

#include <net/if.h>

#include <kselftest_harness.h>

#include "netdev-user.h"
#include "rt-link-user.h"

static void netdev_print_device(struct __test_metadata *_metadata,
                                struct netdev_dev_get_rsp *d, unsigned int op)
{
        char ifname[IF_NAMESIZE];
        const char *name;

        EXPECT_TRUE((bool)d->_present.ifindex);
        if (!d->_present.ifindex)
                return;

        name = if_indextoname(d->ifindex, ifname);
        EXPECT_TRUE((bool)name);
        if (name)
                ksft_print_msg("%8s[%d]\t", name, d->ifindex);
        else
                ksft_print_msg("[%d]\t", d->ifindex);

        EXPECT_TRUE((bool)d->_present.xdp_features);
        if (!d->_present.xdp_features)
                return;

        printf("xdp-features (%llx):", d->xdp_features);
        for (int i = 0; d->xdp_features >= 1U << i; i++) {
                if (d->xdp_features & (1U << i))
                        printf(" %s", netdev_xdp_act_str(1 << i));
        }

        printf(" xdp-rx-metadata-features (%llx):",
               d->xdp_rx_metadata_features);
        for (int i = 0; d->xdp_rx_metadata_features >= 1U << i; i++) {
                if (d->xdp_rx_metadata_features & (1U << i))
                        printf(" %s",
                               netdev_xdp_rx_metadata_str(1 << i));
        }

        printf(" xsk-features (%llx):", d->xsk_features);
        for (int i = 0; d->xsk_features >= 1U << i; i++) {
                if (d->xsk_features & (1U << i))
                        printf(" %s", netdev_xsk_flags_str(1 << i));
        }

        printf(" xdp-zc-max-segs=%u", d->xdp_zc_max_segs);

        name = netdev_op_str(op);
        if (name)
                printf(" (ntf: %s)", name);
        printf("\n");
}

static int veth_create(struct ynl_sock *ys_link)
{
        struct rt_link_getlink_ntf *ntf_gl;
        struct rt_link_newlink_req *req;
        struct ynl_ntf_base_type *ntf;
        int ret;

        req = rt_link_newlink_req_alloc();
        if (!req)
                return -1;

        rt_link_newlink_req_set_nlflags(req, NLM_F_CREATE | NLM_F_ECHO);
        rt_link_newlink_req_set_linkinfo_kind(req, "veth");

        ret = rt_link_newlink(ys_link, req);
        rt_link_newlink_req_free(req);
        if (ret)
                return -1;

        if (!ynl_has_ntf(ys_link))
                return 0;

        ntf = ynl_ntf_dequeue(ys_link);
        if (!ntf || ntf->cmd != RTM_NEWLINK) {
                ynl_ntf_free(ntf);
                return 0;
        }
        ntf_gl = (void *)ntf;
        ret = ntf_gl->obj._hdr.ifi_index;
        ynl_ntf_free(ntf);

        return ret;
}

static void veth_delete(struct __test_metadata *_metadata,
                        struct ynl_sock *ys_link, int ifindex)
{
        struct rt_link_dellink_req *req;

        req = rt_link_dellink_req_alloc();
        ASSERT_NE(NULL, req);

        req->_hdr.ifi_index = ifindex;
        EXPECT_EQ(0, rt_link_dellink(ys_link, req));
        rt_link_dellink_req_free(req);
}

FIXTURE(netdev)
{
        struct ynl_sock *ys;
        struct ynl_sock *ys_link;
};

FIXTURE_SETUP(netdev)
{
        struct ynl_error yerr;

        self->ys = ynl_sock_create(&ynl_netdev_family, &yerr);
        ASSERT_NE(NULL, self->ys) {
                TH_LOG("Failed to create YNL netdev socket: %s", yerr.msg);
        }
}

FIXTURE_TEARDOWN(netdev)
{
        if (self->ys_link)
                ynl_sock_destroy(self->ys_link);
        ynl_sock_destroy(self->ys);
}

TEST_F(netdev, dump)
{
        struct netdev_dev_get_list *devs;

        devs = netdev_dev_get_dump(self->ys);
        ASSERT_NE(NULL, devs) {
                TH_LOG("dump failed: %s", self->ys->err.msg);
        }

        if (ynl_dump_empty(devs)) {
                netdev_dev_get_list_free(devs);
                SKIP(return, "no entries in dump");
        }

        ynl_dump_foreach(devs, d)
                netdev_print_device(_metadata, d, 0);

        netdev_dev_get_list_free(devs);
}

TEST_F(netdev, get)
{
        struct netdev_dev_get_list *devs;
        struct netdev_dev_get_req *req;
        struct netdev_dev_get_rsp *dev;
        int ifindex = 0;

        devs = netdev_dev_get_dump(self->ys);
        ASSERT_NE(NULL, devs) {
                TH_LOG("dump failed: %s", self->ys->err.msg);
        }

        ynl_dump_foreach(devs, d) {
                if (d->_present.ifindex) {
                        ifindex = d->ifindex;
                        break;
                }
        }
        netdev_dev_get_list_free(devs);

        if (!ifindex)
                SKIP(return, "no device to query");

        req = netdev_dev_get_req_alloc();
        ASSERT_NE(NULL, req);
        netdev_dev_get_req_set_ifindex(req, ifindex);

        dev = netdev_dev_get(self->ys, req);
        netdev_dev_get_req_free(req);
        ASSERT_NE(NULL, dev) {
                TH_LOG("dev_get failed: %s", self->ys->err.msg);
        }

        netdev_print_device(_metadata, dev, 0);
        netdev_dev_get_rsp_free(dev);
}

TEST_F(netdev, ntf_check)
{
        struct ynl_ntf_base_type *ntf;
        int veth_ifindex;
        bool received;
        int ret;

        ret = ynl_subscribe(self->ys, "mgmt");
        ASSERT_EQ(0, ret) {
                TH_LOG("subscribe failed: %s", self->ys->err.msg);
        }

        self->ys_link = ynl_sock_create(&ynl_rt_link_family, NULL);
        ASSERT_NE(NULL, self->ys_link)
                TH_LOG("failed to create rt-link socket");

        veth_ifindex = veth_create(self->ys_link);
        ASSERT_GT(veth_ifindex, 0)
                TH_LOG("failed to create veth");

        ynl_ntf_check(self->ys);

        ntf = ynl_ntf_dequeue(self->ys);
        received = ntf;
        if (ntf) {
                netdev_print_device(_metadata,
                                    (struct netdev_dev_get_rsp *)&ntf->data,
                                    ntf->cmd);
                ynl_ntf_free(ntf);
        }

        /* Drain any remaining notifications */
        while ((ntf = ynl_ntf_dequeue(self->ys)))
                ynl_ntf_free(ntf);

        veth_delete(_metadata, self->ys_link, veth_ifindex);

        ASSERT_TRUE(received)
                TH_LOG("no notification received");
}

TEST_HARNESS_MAIN