// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "tokens.h"

#include <zxtest/zxtest.h>

namespace netdump::test {

class TokensTester : public Tokenizer {
 public:
  void LiteralTest() {
    TokenPtr token = literal("testestest");
    TokenPtr other = literal("testestest");

    EXPECT_EQ("testestest", token->get_term());
    EXPECT_EQ("testestest", other->get_term());

    EXPECT_FALSE(token == other);
  }

  void KeywordTest() {
    TokenPtr before = literal("KEYWORD");
    TokenPtr token = keyword("KEYWORD", 'k');
    TokenPtr other = keyword("KEYWORD", 'k');
    TokenPtr after = literal("KEYWORD");

    EXPECT_EQ("KEYWORD", token->get_term());
    EXPECT_EQ('k', token->get_tag<char>());

    // Check the behavior expected of a keyword token, and that the `literal` function has not
    // registered anything before or after a `keyword` call.
    EXPECT_TRUE(token == other);    // Keyword token remains the same.
    EXPECT_FALSE(token == before);  // `literal` did not register new keyword.
    EXPECT_TRUE(token == after);    // `literal` did not overwrite keyword registration.

    if (ZX_DEBUG_ASSERT_IMPLEMENTED) {
      ASSERT_DEATH([this]() { keyword("KEYWORD", 'w'); });  // Redefining `tag` not allowed.
    }
  }

  void SynonymTest() {
    TokenPtr token = keyword("HELLO", "CIAO");
    TokenPtr keyword_syn = keyword("CIAO");
    TokenPtr literal_syn = literal("CIAO");
    TokenPtr add_syn = keyword("CIAO", "NIHAO");
    TokenPtr syn = keyword("NIHAO");

    EXPECT_EQ("HELLO", token->get_term());
    EXPECT_TRUE(token == keyword_syn);
    EXPECT_TRUE(token == add_syn);
    EXPECT_TRUE(token == syn);
  }

  static void CheckTokenVectorString(std::vector<TokenPtr> expected_tokens,
                                     std::vector<TokenPtr> got_tokens) {
    EXPECT_EQ(expected_tokens.size(), got_tokens.size());
    auto exp = expected_tokens.begin();
    for (const TokenPtr& token : got_tokens) {
      EXPECT_EQ((*exp)->get_term(), token->get_term());
      ++exp;
    }
  }

  void BasicTokenizeTest() {
    TokenPtr kwa = keyword("kwa");
    TokenPtr kwb = keyword("kwb");
    TokenPtr kwc = keyword("kwc", "kwd");
    TokenPtr lita = literal("lita");
    TokenPtr litb = literal("litb");
    std::string input = "kwa kwb\tkwa    kwc\t\tlita\nkwb\t\nkwd\n\nlitb";
    std::vector<TokenPtr> tokens = tokenize(input);
    std::vector<TokenPtr> expected_tokens = {kwa, kwb, kwa, kwc, lita, kwb, kwc, litb};

    std::vector<TokenPtr> empty = tokenize("");
    EXPECT_TRUE(empty.empty());

    CheckTokenVectorString(expected_tokens, tokens);
    // Literal tokens should have unique identities.
    EXPECT_NE(tokens[4], lita);
    EXPECT_NE(tokens[7], litb);
  }

  void TokenizeRealKeywordsTest() {
    std::string input = "( ether src ) and ( ip6 or ip4 ) and ( tcp dst port )";
    std::vector<TokenPtr> tokens = tokenize(input);
    std::vector<TokenPtr> expected_tokens = {L_PARENS, ETHER, SRC,  R_PARENS, AND, L_PARENS,
                                             IP6,      OR,    IP,   R_PARENS, AND, L_PARENS,
                                             TCP,      DST,   PORT, R_PARENS};
    EXPECT_EQ(expected_tokens, tokens);
  }

  void TokenizeKeywordsLiteralsStringTest() {
    TokenPtr xxx = literal("xxx");
    TokenPtr twentythree = literal("23");
    std::string input = "( ether src xxx ) and ( ip6 or ip4 ) and ( tcp dst port 23 )";
    std::vector<TokenPtr> tokens = tokenize(input);
    std::vector<TokenPtr> expected_tokens = {L_PARENS, ETHER, SRC, xxx,  R_PARENS,    AND,
                                             L_PARENS, IP6,   OR,  IP,   R_PARENS,    AND,
                                             L_PARENS, TCP,   DST, PORT, twentythree, R_PARENS};
    CheckTokenVectorString(expected_tokens, tokens);
  }

  void VisitorTest() {
    TokenPtr token = literal("testestest");
    TokenPtr port_token = port("20-30");
    bool token_fail = false;
    bool port_token_fail = false;
    std::string literal_str = "";
    uint16_t beg_port = 0;
    uint16_t end_port = 0;

    auto token_visitor =
        FunctionalTokenVisitor([&literal_str](TokenPtr t) { literal_str = t->get_term(); },
                               [&token_fail](PortTokenPtr /*t*/) { token_fail = true; });

    auto port_token_visitor =
        FunctionalTokenVisitor([&port_token_fail](TokenPtr /*t*/) { port_token_fail = true; },
                               [&beg_port, &end_port](PortTokenPtr t) {
                                 beg_port = t->begin();
                                 end_port = t->end();
                               });

    token->accept(&token_visitor);
    port_token->accept(&port_token_visitor);

    EXPECT_EQ("testestest", literal_str);
    EXPECT_EQ(20, beg_port);
    EXPECT_EQ(30, end_port);
    EXPECT_FALSE(token_fail);
    EXPECT_FALSE(port_token_fail);
  }

  static inline FunctionalTokenVisitor PortTokenVisitor(bool* fail, uint16_t* beg_port,
                                                        uint16_t* end_port) {
    FunctionalTokenVisitor visitor(
        // Sets some failure `bool` to true when the visitor finds a non-port token.
        [fail](TokenPtr /*t*/) { *fail = true; },
        // Sets the port range when the visitor finds a port token.
        [beg_port, end_port](PortTokenPtr t) {
          *beg_port = t->begin();
          *end_port = t->end();
        });
    return visitor;
  }

  void NamedPortTest() {
    TokenPtr token = named_port("FancyPort", "FANCY", 10, 1000, 42);
    TokenPtr syn = named_port("FANCY", "FANCIER", 20, 2000);
    TokenPtr add_syn = named_port("FANCIER", 30, 3000);
    bool fail = false;
    uint16_t beg_port = 0;
    uint16_t end_port = 0;
    FunctionalTokenVisitor visitor = PortTokenVisitor(&fail, &beg_port, &end_port);
    token->accept(&visitor);

    EXPECT_EQ("FancyPort", token->get_term());
    EXPECT_EQ(42, token->get_tag<uint8_t>());
    EXPECT_EQ(10, beg_port);
    EXPECT_EQ(1000, end_port);
    EXPECT_FALSE(fail);
    EXPECT_TRUE(token == syn);
    EXPECT_TRUE(token == add_syn);
  }

  static inline std::string CheckPort(const TokenPtr& token, bool* fail, uint16_t* beg_port,
                                      uint16_t* end_port) {
    *fail = false;
    *beg_port = 0;
    *end_port = 0;
    FunctionalTokenVisitor visitor = PortTokenVisitor(fail, beg_port, end_port);
    token->accept(&visitor);
    return token->get_term();
  }

  using PortRanges = std::vector<std::optional<PortRange>>;
  static void CheckPortVector(std::vector<TokenPtr> tokens, std::vector<std::string> terms,
                              PortRanges ranges) {
    EXPECT_EQ(tokens.size(), terms.size());
    EXPECT_EQ(tokens.size(), ranges.size());
    auto term = terms.begin();
    auto range = ranges.begin();
    bool fail = false;
    uint16_t beg_port = 0;
    uint16_t end_port = 0;
    for (const TokenPtr& token : tokens) {
      CheckPort(token, &fail, &beg_port, &end_port);
      if (*range == std::nullopt) {
        EXPECT_TRUE(fail);
      } else {
        EXPECT_FALSE(fail);
        EXPECT_EQ((*range)->first, beg_port);
        EXPECT_EQ((*range)->second, end_port);
      }
      EXPECT_EQ(*term, token->get_term());
      ++term;
      ++range;
    }
  }

  void PortTest() {
    std::vector<TokenPtr> tokens = {named_port("MYPORT", 1, 1),
                                    port("MYPORT"),
                                    port("42"),
                                    port("25-35"),
                                    port("YOURPORT"),
                                    port("42,51"),
                                    port("-42"),
                                    port("1--42"),
                                    port("100-50"),
                                    port("55-66000"),
                                    port("1-ftpxfer"),
                                    port("ftpxfer-ftpctl")};
    std::vector<std::string> terms = {"MYPORT",   "MYPORT",   "42",        "25-35",
                                      "YOURPORT", "42,51",    "-42",       "1--42",
                                      "100-50",   "55-66000", "1-ftpxfer", "ftpxfer-ftpctl"};
    PortRanges ranges = {std::optional(PortRange(1, 1)),
                         std::optional(PortRange(1, 1)),
                         std::optional(PortRange(42, 42)),
                         std::optional(PortRange(25, 35)),
                         std::nullopt,
                         std::nullopt,
                         std::nullopt,
                         std::nullopt,
                         std::nullopt,
                         std::nullopt,
                         std::nullopt,
                         std::nullopt};
    CheckPortVector(tokens, terms, ranges);
  }

  void PortTokenizationTest() {
    TokenPtr named1 = named_port("MYPORT", 1, 1);
    TokenPtr named2 = named_port("THISPORT", "THATPORT", 2, 2);
    std::string input = "6!15!10-20!MYPORT!YOURPORT!30-10!  !!37!THATPORT";
    // In actual use we will probably use ',' as the delimiter.
    // Here we test that '!' works too.
    std::vector<TokenPtr> tokens = mult_ports('!', input);
    std::vector<std::string> terms = {"6",  "15", "10-20", "MYPORT",  "YOURPORT", "30-10",
                                      "  ", "",   "37",    "THISPORT"};  // Careful with synonyms!
    PortRanges ranges = {std::optional(PortRange(6, 6)),
                         std::optional(PortRange(15, 15)),
                         std::optional(PortRange(10, 20)),
                         std::optional(PortRange(1, 1)),
                         std::nullopt,
                         std::nullopt,
                         std::nullopt,
                         std::nullopt,
                         std::optional(PortRange(37, 37)),
                         std::optional(PortRange(2, 2))};

    std::vector<TokenPtr> empty = mult_ports('!', "");
    EXPECT_TRUE(empty.empty());

    CheckPortVector(tokens, terms, ranges);
  }

  void RealNamedPortsTokenizationTest() {
    std::string input = "75,21,10-20,ssh,http,dbglog,ftpxfer,ftpctl,badname,,SSH";
    std::vector<TokenPtr> tokens = mult_ports(',', input);
    std::vector<std::string> terms = {"75",      "21",     "10-20",   "ssh", "http", "dbglog",
                                      "ftpxfer", "ftpctl", "badname", "",    "SSH"};
    PortRanges ranges = {std::optional(PortRange(75, 75)),
                         std::optional(PortRange(21, 21)),
                         std::optional(PortRange(10, 20)),
                         std::optional(PortRange(22, 22)),
                         std::optional(PortRange(80, 80)),
                         std::optional(PortRange(DEBUGLOG_PORT, DEBUGLOG_PORT)),
                         std::optional(PortRange(20, 20)),
                         std::optional(PortRange(21, 21)),
                         std::nullopt,
                         std::nullopt,
                         std::nullopt};

    std::vector<TokenPtr> empty = mult_ports(',', "");
    EXPECT_TRUE(empty.empty());

    CheckPortVector(tokens, terms, ranges);
  }

  void OneOfTest() {
    TokenPtr t1 = keyword("KEYWORD");
    TokenPtr t2 = literal("KEYWORD");
    TokenPtr t3 = literal("foo");
    TokenPtr t4 = literal("foo");
    TokenPtr t5 = literal("bar");
    TokenPtr t6 = port("50");
    TokenPtr t7 = named_port("SOMEPORT", 50, 50);
    TokenPtr t8 = port("SOMEPORT");

    EXPECT_TRUE(t1->one_of(t3, t4, t5, t6, t1));
    EXPECT_TRUE(t2->one_of(t3, t4, t5, t6, t1));
    EXPECT_FALSE(t3->one_of(t4, t5, t6, t1));
    EXPECT_TRUE(t4->one_of(t1, t2, t4, t5, t6));
    EXPECT_TRUE(t5->one_of(t5));
    EXPECT_FALSE(t6->one_of(port("50"), t7, t8));
    EXPECT_TRUE(t7->one_of(t8));
    EXPECT_TRUE(t8->one_of(t1, t5, t7));
  }
};

}  // namespace netdump::test

#define NETDUMP_TEST(fn) \
  TEST(NetdumpTokensTest, fn) { netdump::test::TokensTester().fn(); }
NETDUMP_TEST(LiteralTest)
NETDUMP_TEST(KeywordTest)
NETDUMP_TEST(SynonymTest)
NETDUMP_TEST(BasicTokenizeTest)
NETDUMP_TEST(TokenizeRealKeywordsTest)
NETDUMP_TEST(TokenizeKeywordsLiteralsStringTest)
NETDUMP_TEST(VisitorTest)
NETDUMP_TEST(NamedPortTest)
NETDUMP_TEST(PortTest)
NETDUMP_TEST(PortTokenizationTest)
NETDUMP_TEST(RealNamedPortsTokenizationTest)
NETDUMP_TEST(OneOfTest)
#undef NETDUMP_TEST