#include <gtest/gtest.h>

#include <memory>
#include <vector>

#include "hw/atlas_defaults.h"
#include "hw/frame_buffer.h"
#include "hw/hw_factory.h"
#include "hw/jetson_defaults.h"
#include "hw/rk3588_defaults.h"

namespace rk3588 {
namespace {

TEST(HwFactoryTest, DefaultsReturnsRk3588Impls) {
    SimpleJson config(SimpleJson::Object{});

    auto infer = HwFactory::CreateInferBackend(config);
    auto image = HwFactory::CreateImageProcessor(config);
    auto decoder = HwFactory::CreateDecoder(config);
    auto encoder = HwFactory::CreateEncoder(config);

    EXPECT_NE(infer, nullptr);
    EXPECT_NE(image, nullptr);
    EXPECT_NE(decoder, nullptr);
    EXPECT_NE(encoder, nullptr);

    EXPECT_NE(std::dynamic_pointer_cast<Rk3588InferBackend>(infer), nullptr);
    EXPECT_NE(std::dynamic_pointer_cast<Rk3588ImageProcessor>(image), nullptr);
    EXPECT_NE(std::dynamic_pointer_cast<Rk3588Decoder>(decoder), nullptr);
    EXPECT_NE(std::dynamic_pointer_cast<Rk3588Encoder>(encoder), nullptr);
}

TEST(HwFactoryTest, SelectsBackendByConfig) {
    SimpleJson::Object cfg_obj;
    cfg_obj["platform"] = SimpleJson(std::string("atlas"));
    SimpleJson config(std::move(cfg_obj));

    auto infer = HwFactory::CreateInferBackend(config);
    auto image = HwFactory::CreateImageProcessor(config);
    auto decoder = HwFactory::CreateDecoder(config);
    auto encoder = HwFactory::CreateEncoder(config);

    EXPECT_NE(std::dynamic_pointer_cast<AtlasInferBackend>(infer), nullptr);
    EXPECT_NE(std::dynamic_pointer_cast<AtlasImageProcessor>(image), nullptr);
    EXPECT_NE(std::dynamic_pointer_cast<AtlasDecoder>(decoder), nullptr);
    EXPECT_NE(std::dynamic_pointer_cast<AtlasEncoder>(encoder), nullptr);
}

TEST(HwFactoryTest, PlatformImplsSmokeConstruct) {
    auto atlas_infer = std::make_shared<AtlasInferBackend>();
    auto atlas_image = std::make_shared<AtlasImageProcessor>();
    auto atlas_decoder = std::make_shared<AtlasDecoder>();
    auto atlas_encoder = std::make_shared<AtlasEncoder>();

    auto jetson_infer = std::make_shared<JetsonInferBackend>();
    auto jetson_image = std::make_shared<JetsonImageProcessor>();
    auto jetson_decoder = std::make_shared<JetsonDecoder>();
    auto jetson_encoder = std::make_shared<JetsonEncoder>();

    EXPECT_NE(atlas_infer, nullptr);
    EXPECT_NE(atlas_image, nullptr);
    EXPECT_NE(atlas_decoder, nullptr);
    EXPECT_NE(atlas_encoder, nullptr);

    EXPECT_NE(jetson_infer, nullptr);
    EXPECT_NE(jetson_image, nullptr);
    EXPECT_NE(jetson_decoder, nullptr);
    EXPECT_NE(jetson_encoder, nullptr);
}

TEST(FrameBufferTest, MetadataPreserved) {
    FrameBuffer::Plane plane0;
    plane0.data = reinterpret_cast<uint8_t*>(0x1000);
    plane0.stride = 1280;
    plane0.size = 921600;
    plane0.offset = 0;

    FrameBuffer::Plane plane1;
    plane1.data = reinterpret_cast<uint8_t*>(0x2000);
    plane1.stride = 640;
    plane1.size = 460800;
    plane1.offset = 921600;

    std::vector<FrameBuffer::Plane> planes{plane0, plane1};
    FrameBuffer buffer(42, planes);

    EXPECT_EQ(buffer.DmaFd(), 42);
    ASSERT_EQ(buffer.Planes().size(), 2u);
    EXPECT_EQ(buffer.Planes()[0].stride, 1280);
    EXPECT_EQ(buffer.Planes()[0].size, 921600);
    EXPECT_EQ(buffer.Planes()[0].offset, 0);
    EXPECT_EQ(buffer.Planes()[1].stride, 640);
    EXPECT_EQ(buffer.Planes()[1].size, 460800);
    EXPECT_EQ(buffer.Planes()[1].offset, 921600);
}

}  // namespace
}  // namespace rk3588