#include <array>
#include <string>
#include <gtest/gtest.h>
#include "data_types.hpp"

using namespace std::string_literals;
using namespace phosphor::dbus::monitoring;

using Property =
    TupleOfRefs <
    const std::string,
    const std::string,
    const std::string >;

using GroupOfProperties = std::vector<Property>;

#include "propertygentest.hpp"
const std::array<std::string, 3> expectedMeta =
{
    "PROPERTY1"s,
    "PROPERTY2"s,
    "PROPERTY3"s,
};

const std::array<std::string, 4> expectedInterfaces =
{
    "xyz.openbmc_project.Test.Iface3"s,
    "xyz.openbmc_project.Test.Iface2"s,
    "xyz.openbmc_project.Test.Iface6"s,
    "xyz.openbmc_project.Test.Iface1"s,
};

const std::array<std::string, 4> expectedProperties =
{
    "Foo"s,
    "Value"s,
    "Bar"s,
    "Baz"s,
};

const std::array<GroupOfProperties, 4> expectedGroups =
{
    {
        {
            Property{ interfaces[0], properties[0], meta[0] },
            Property{ interfaces[1], properties[1], meta[1] },
        },
        {
            Property{ interfaces[0], properties[2], meta[0] },
            Property{ interfaces[1], properties[0], meta[1] },
        },
        {
            Property{ interfaces[2], properties[0], meta[0] },
            Property{ interfaces[3], properties[1], meta[1] },
        },
        {
            Property{ interfaces[0], properties[2], meta[0] },
            Property{ interfaces[1], properties[1], meta[1] },
            Property{ interfaces[2], properties[3], meta[2] },
        },
    }
};

const std::array<std::string, 4> expectedTypes =
{
    "uint32_t"s,
    "int32_t"s,
    "std::string"s,
    "int32_t"s,
};

TEST(PropertyGenTest, MetaSameSize)
{
    ASSERT_EQ(sizeof(expectedMeta), sizeof(meta));
}

TEST(PropertyGenTest, IfacesSameSize)
{
    ASSERT_EQ(sizeof(expectedInterfaces), sizeof(interfaces));
}

TEST(PropertyGenTest, PropertiesSameSize)
{
    ASSERT_EQ(sizeof(expectedProperties), sizeof(properties));
}

TEST(PropertyGenTest, GroupsSameSize)
{
    ASSERT_EQ(sizeof(expectedGroups), sizeof(groups));
}

TEST(PropertyGenTest, TypesSameSize)
{
    ASSERT_EQ(sizeof(expectedTypes), sizeof(types));
}

TEST(PropertyGenTest, MetaSameContent)
{
    size_t i;
    for (i = 0; i < expectedMeta.size(); ++i)
    {
        ASSERT_EQ(meta[i],
                  expectedMeta[i]);
    }
}

TEST(PropertyGenTest, IfacesSameContent)
{
    size_t i;
    for (i = 0; i < expectedInterfaces.size(); ++i)
    {
        ASSERT_EQ(interfaces[i],
                  expectedInterfaces[i]);
    }
}

TEST(PropertyGenTest, PropertiesSameContent)
{
    size_t i;
    for (i = 0; i < expectedProperties.size(); ++i)
    {
        ASSERT_EQ(expectedProperties[i], properties[i]);
    }
}

TEST(PropertyGenTest, GroupsSameContent)
{
    size_t i;
    for (i = 0; i < expectedGroups.size(); ++i)
    {
        size_t j;
        for (j = 0; j < expectedGroups[i].size(); ++j)
        {
            const auto& expectedIface = std::get<0>(expectedGroups[i][j]).get();
            const auto& actualIface = std::get<0>(groups[i][j]).get();
            ASSERT_EQ(expectedIface, actualIface);

            const auto& expectedProperty = std::get<1>(expectedGroups[i][j]).get();
            const auto& actualProperty = std::get<1>(groups[i][j]).get();
            ASSERT_EQ(expectedProperty, actualProperty);

            const auto& expectedMeta = std::get<1>(expectedGroups[i][j]).get();
            const auto& actualMeta = std::get<1>(groups[i][j]).get();
            ASSERT_EQ(expectedMeta, actualMeta);
        }
    }
}

TEST(PropertyGenTest, TypesSameContent)
{
    size_t i;
    for (i = 0; i < expectedTypes.size(); ++i)
    {
        ASSERT_EQ(expectedTypes[i], types[i]);
    }
}