// 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 <lib/diagnostics/reader/cpp/archive_reader.h>

#include <optional>

#include <rapidjson/document.h>
#include <zxtest/zxtest.h>

#include "lib/inspect/cpp/hierarchy.h"

namespace {

using diagnostics::reader::InspectData;

TEST(InspectDataTest, ComponentNameExtraction) {
  {
    std::vector<diagnostics::reader::InspectData> data;
    rapidjson::Document doc;
    doc.Parse(R"({"moniker": "root/hub/my_component"})");
    diagnostics::reader::EmplaceInspect(std::move(doc), &data);
    InspectData &datum = data[0];
    EXPECT_EQ("root/hub/my_component", datum.moniker());
  }
  {
    std::vector<diagnostics::reader::InspectData> data;
    rapidjson::Document doc;
    doc.Parse(R"({"moniker": "abcd"})");
    diagnostics::reader::EmplaceInspect(std::move(doc), &data);
    InspectData &datum = data[0];
    EXPECT_EQ("abcd", datum.moniker());
  }
  {
    // Can't find path, empty return.
    std::vector<diagnostics::reader::InspectData> data;
    rapidjson::Document doc;
    doc.Parse(R"({"not_moniker": "abcd"})");
    diagnostics::reader::EmplaceInspect(std::move(doc), &data);
    InspectData &datum = data[0];
    EXPECT_EQ("", datum.moniker());
  }
}

TEST(InspectDataTest, ContentExtraction) {
  {
    std::vector<diagnostics::reader::InspectData> data;
    rapidjson::Document doc;
    doc.Parse(R"({"payload": {"value": "hello", "count": 10}})");
    diagnostics::reader::EmplaceInspect(std::move(doc), &data);
    InspectData &datum = data[0];
    EXPECT_EQ(rapidjson::Value("hello"), datum.GetByPath({"value"}));
    EXPECT_EQ(rapidjson::Value(10), datum.GetByPath({"count"}));
    EXPECT_EQ(rapidjson::Value(), datum.GetByPath({"value", "1234"}));
  }
  {
    std::vector<diagnostics::reader::InspectData> data;
    rapidjson::Document doc;
    doc.Parse(R"({"payload": {"name/with/slashes": "hello"}})");
    diagnostics::reader::EmplaceInspect(std::move(doc), &data);
    InspectData &datum = data[0];
    EXPECT_EQ(rapidjson::Value("hello"), datum.GetByPath({"name/with/slashes"}));
  }
  {
    // Content is missing, return nullptr.
    std::vector<diagnostics::reader::InspectData> data;
    rapidjson::Document doc;
    doc.Parse(R"({"moniker": "root/hub/my_component"})");
    diagnostics::reader::EmplaceInspect(std::move(doc), &data);
    InspectData &datum = data[0];
    EXPECT_EQ(rapidjson::Value(), datum.GetByPath({"value"}));
  }
}

TEST(InspectDataTest, ArrayValueCtor) {
  {
    std::vector<diagnostics::reader::InspectData> data;
    rapidjson::Document doc;
    doc.Parse(R"([
      {"payload": {"value": "hello", "count": 10}},
      {"payload": {"value": "world", "count": 40}}
    ])");

    diagnostics::reader::EmplaceInspect(std::move(doc), &data);
    InspectData &first = data[0];
    InspectData &second = data[1];

    EXPECT_EQ(rapidjson::Value("hello"), first.GetByPath({"value"}));
    EXPECT_EQ(rapidjson::Value(10), first.GetByPath({"count"}));
    EXPECT_EQ(rapidjson::Value(), first.GetByPath({"value", "1234"}));

    EXPECT_EQ(rapidjson::Value("world"), second.GetByPath({"value"}));
    EXPECT_EQ(rapidjson::Value(40), second.GetByPath({"count"}));
    EXPECT_EQ(rapidjson::Value(), second.GetByPath({"value", "1234"}));
  }
}

TEST(InspectDataTest, EmptyArray) {
  std::vector<diagnostics::reader::InspectData> data;
  rapidjson::Document doc;
  doc.Parse(R"({"payload": { "root": { "test_array": []}}})");
  diagnostics::reader::EmplaceInspect(std::move(doc), &data);
  EXPECT_EQ(true, data[0].payload().has_value());
  EXPECT_EQ("root", data[0].payload().value()->name());

  auto *values =
      data[0].payload().value()->node().get_property<inspect::IntArrayValue>("test_array");
  ASSERT_NOT_NULL(values);
  ASSERT_EQ(0ul, values->value().size());
}

TEST(InspectDataTest, ParseJSON) {
  {
    std::vector<diagnostics::reader::InspectData> data;
    rapidjson::Document doc;
    doc.Parse(R"({})");
    diagnostics::reader::EmplaceInspect(std::move(doc), &data);
    EXPECT_EQ("", data[0].moniker());
    EXPECT_EQ(0, data[0].version());
    EXPECT_EQ(std::nullopt, data[0].metadata().filename);
    EXPECT_EQ(std::nullopt, data[0].metadata().name);
    EXPECT_EQ(std::nullopt, data[0].metadata().component_url);
    EXPECT_EQ(0, data[0].metadata().timestamp);
    EXPECT_EQ(std::nullopt, data[0].metadata().errors);
    EXPECT_EQ(std::nullopt, data[0].payload());
  }
  {
    std::vector<diagnostics::reader::InspectData> data;
    rapidjson::Document doc;
    doc.Parse(R"({"metadata":
      {
        "filename": "fuchsia.inspect.Tree",
        "timestamp": 39085389926
      },
      "moniker": "bootstrap/archivist",
      "version": 1})");
    diagnostics::reader::EmplaceInspect(std::move(doc), &data);
    EXPECT_EQ("bootstrap/archivist", data[0].moniker());
    EXPECT_EQ(1, data[0].version());
    EXPECT_EQ("fuchsia.inspect.Tree", data[0].metadata().filename);
    EXPECT_EQ(std::nullopt, data[0].metadata().name);
    EXPECT_EQ(std::nullopt, data[0].metadata().component_url);
    EXPECT_EQ(39085389926, data[0].metadata().timestamp);
    EXPECT_EQ(std::nullopt, data[0].metadata().errors);
    EXPECT_EQ(std::nullopt, data[0].payload());
  }
  {
    std::vector<diagnostics::reader::InspectData> data;
    rapidjson::Document doc;
    doc.Parse(R"({"metadata":
      {
        "name": "MyInspectTree",
        "timestamp": 39085389926
      },
      "moniker": "bootstrap/archivist",
      "version": 1})");
    diagnostics::reader::EmplaceInspect(std::move(doc), &data);
    EXPECT_EQ("bootstrap/archivist", data[0].moniker());
    EXPECT_EQ(1, data[0].version());
    EXPECT_EQ(std::nullopt, data[0].metadata().filename);
    EXPECT_EQ("MyInspectTree", data[0].metadata().name);
    EXPECT_EQ(std::nullopt, data[0].metadata().component_url);
    EXPECT_EQ(39085389926, data[0].metadata().timestamp);
    EXPECT_EQ(std::nullopt, data[0].metadata().errors);
    EXPECT_EQ(std::nullopt, data[0].payload());
  }
  {
    std::vector<diagnostics::reader::InspectData> data;
    rapidjson::Document doc;
    doc.Parse(R"({"metadata":
      {
        "filename": "fuchsia.inspect.Tree",
        "component_url": "fuchsia-pkg://fuchsia.com/archivist#meta/archivist.cm",
        "timestamp": 39085389926,
        "errors": [{ "message": "e1"},{ "message": "e2"},{ "message": "e3"}]
      },
      "payload": {
        "root": {
          "all_archive_accessor_node": {
            "archive_accessor_connections_opened": 2,
            "archive_accessor_connections_closed": 0,
            "batch_iterator_connection1": {
              "batch_iterator_get_next_requests": 1,
              "batch_iterator_get_next_responses": 0
            }
          },
          "event_stats": {
            "test_array": [1, 2, 3, 4, 5, 6, 7, 8 ],
            "sources": {
              "v2": {},
              "v1": {}
            }
          },
          "fuchsia.inspect.Health": {
            "start_timestamp_nanos": 3358357188,
            "status": "OK"
          },
          "test": 5000,
          "test1": true
        }
      },
      "moniker": "bootstrap/archivist",
      "version": 1})");
    diagnostics::reader::EmplaceInspect(std::move(doc), &data);
    EXPECT_EQ("bootstrap/archivist", data[0].moniker());
    EXPECT_EQ(1, data[0].version());
    EXPECT_EQ("fuchsia.inspect.Tree", data[0].metadata().filename);
    EXPECT_EQ(std::nullopt, data[0].metadata().name);
    EXPECT_EQ("fuchsia-pkg://fuchsia.com/archivist#meta/archivist.cm",
              data[0].metadata().component_url);
    EXPECT_EQ(39085389926, data[0].metadata().timestamp);
    EXPECT_EQ(3, data[0].metadata().errors->size());
    EXPECT_EQ("e1", data[0].metadata().errors->at(0).message);
    EXPECT_EQ("e2", data[0].metadata().errors->at(1).message);
    EXPECT_EQ("e3", data[0].metadata().errors->at(2).message);
    EXPECT_EQ(true, data[0].payload().has_value());
    EXPECT_EQ("root", data[0].payload().value()->name());
    auto root = data[0].payload().value();
    auto &rootNode = data[0].payload().value()->node();
    const auto accessor = root->GetByPath({"all_archive_accessor_node"});
    ASSERT_NOT_NULL(accessor);
    ASSERT_NOT_NULL(accessor->node().get_property<inspect::IntPropertyValue>(
        "archive_accessor_connections_opened"));
    EXPECT_EQ(2, accessor->node()
                     .get_property<inspect::IntPropertyValue>("archive_accessor_connections_opened")
                     ->value());
    ASSERT_NOT_NULL(accessor->node().get_property<inspect::IntPropertyValue>(
        "archive_accessor_connections_closed"));
    EXPECT_EQ(0, accessor->node()
                     .get_property<inspect::IntPropertyValue>("archive_accessor_connections_closed")
                     ->value());
    auto batchInteratorConnection = accessor->GetByPath({"batch_iterator_connection1"});
    ASSERT_NOT_NULL(batchInteratorConnection);
    ASSERT_NOT_NULL(batchInteratorConnection->node().get_property<inspect::IntPropertyValue>(
        "batch_iterator_get_next_requests"));
    EXPECT_EQ(1, batchInteratorConnection->node()
                     .get_property<inspect::IntPropertyValue>("batch_iterator_get_next_requests")
                     ->value());
    ASSERT_NOT_NULL(batchInteratorConnection->node().get_property<inspect::IntPropertyValue>(
        "batch_iterator_get_next_responses"));
    EXPECT_EQ(0, batchInteratorConnection->node()
                     .get_property<inspect::IntPropertyValue>("batch_iterator_get_next_responses")
                     ->value());
    const auto &health = root->GetByPath({"fuchsia.inspect.Health"});
    ASSERT_NOT_NULL(health);
    EXPECT_EQ(
        3358357188,
        health->node().get_property<inspect::IntPropertyValue>("start_timestamp_nanos")->value());
    EXPECT_EQ("OK", health->node().get_property<inspect::StringPropertyValue>("status")->value());
    const auto &event_stats = root->GetByPath({"event_stats"});
    ASSERT_NOT_NULL(event_stats);
    ASSERT_NOT_NULL(event_stats->node().get_property<inspect::IntArrayValue>("test_array"));
    EXPECT_EQ(1,
              event_stats->node().get_property<inspect::IntArrayValue>("test_array")->value()[0]);
    EXPECT_EQ(2,
              event_stats->node().get_property<inspect::IntArrayValue>("test_array")->value()[1]);
    EXPECT_EQ(3,
              event_stats->node().get_property<inspect::IntArrayValue>("test_array")->value()[2]);
    EXPECT_EQ(4,
              event_stats->node().get_property<inspect::IntArrayValue>("test_array")->value()[3]);
    EXPECT_EQ(5,
              event_stats->node().get_property<inspect::IntArrayValue>("test_array")->value()[4]);
    EXPECT_EQ(6,
              event_stats->node().get_property<inspect::IntArrayValue>("test_array")->value()[5]);
    EXPECT_EQ(7,
              event_stats->node().get_property<inspect::IntArrayValue>("test_array")->value()[6]);
    EXPECT_EQ(8,
              event_stats->node().get_property<inspect::IntArrayValue>("test_array")->value()[7]);

    const auto &v1 = event_stats->GetByPath({"sources", "v1"});
    ASSERT_NOT_NULL(v1);
    const auto &v2 = event_stats->GetByPath({"sources", "v2"});
    ASSERT_NOT_NULL(v2);
    EXPECT_EQ(2, rootNode.properties().size());
    ASSERT_NOT_NULL(rootNode.get_property<inspect::IntPropertyValue>("test"));
    EXPECT_EQ(5000, rootNode.get_property<inspect::IntPropertyValue>("test")->value());
    ASSERT_NOT_NULL(rootNode.get_property<inspect::BoolPropertyValue>("test1"));
    EXPECT_EQ(true, rootNode.get_property<inspect::BoolPropertyValue>("test1")->value());
  }
}

}  // namespace