#include <gtest/gtest.h>
#include "render/frame_drawer.hpp"
#include <opencv2/opencv.hpp>

using namespace pipeline;

class FrameDrawerTest : public ::testing::Test {
protected:
    void SetUp() override {
        // 创建测试配置
        config_.window_name = "Frame Drawer Test";
        config_.window_width = 800;
        config_.window_height = 600;
        config_.fullscreen = false;
        config_.test_mode = true;  // 启用测试模式
        
        // 创建测试图像
        test_frame_ = cv::Mat(480, 640, CV_8UC3, cv::Scalar(0, 0, 0));
        
        // 创建测试检测结果
        renderer::DetectionResult det;
        det.bbox = cv::Rect(100, 100, 200, 200);
        det.confidence = 0.95f;
        det.class_id = 1;
        det.label = "person";
        test_results_.push_back(det);
        
        // 创建测试性能指标
        metrics_.fps = 30.0f;
        metrics_.inference_time_ms = 33.3f;
        metrics_.gpu_usage_percent = 50.0f;
    }

    void TearDown() override {
        drawer_.cleanup();
    }

    renderer::RendererConfig config_;
    FrameDrawer drawer_;
    cv::Mat test_frame_;
    std::vector<renderer::DetectionResult> test_results_;
    PerformanceMetrics metrics_;
};

// 测试初始化
TEST_F(FrameDrawerTest, Initialization) {
    EXPECT_TRUE(drawer_.init(config_));
    // 重复初始化应该返回true
    EXPECT_TRUE(drawer_.init(config_));
}

// 测试未初始化时的处理
TEST_F(FrameDrawerTest, ProcessWithoutInit) {
    EXPECT_FALSE(drawer_.processFrame(test_frame_, test_results_, metrics_));
}

// 测试正常处理
TEST_F(FrameDrawerTest, NormalProcessing) {
    ASSERT_TRUE(drawer_.init(config_));
    EXPECT_TRUE(drawer_.processFrame(test_frame_, test_results_, metrics_));
}

// 测试空检测结果的处理
TEST_F(FrameDrawerTest, ProcessEmptyResults) {
    ASSERT_TRUE(drawer_.init(config_));
    std::vector<renderer::DetectionResult> empty_results;
    EXPECT_TRUE(drawer_.processFrame(test_frame_, empty_results, metrics_));
}

// 测试清理
TEST_F(FrameDrawerTest, Cleanup) {
    ASSERT_TRUE(drawer_.init(config_));
    drawer_.cleanup();
    // 清理后处理应该失败
    EXPECT_FALSE(drawer_.processFrame(test_frame_, test_results_, metrics_));
}

// 测试不同尺寸的图像
TEST_F(FrameDrawerTest, DifferentImageSizes) {
    ASSERT_TRUE(drawer_.init(config_));
    
    // 测试不同尺寸的图像
    std::vector<cv::Size> sizes = {
        cv::Size(320, 240),
        cv::Size(640, 480),
        cv::Size(1280, 720),
        cv::Size(1920, 1080)
    };
    
    for (const auto& size : sizes) {
        cv::Mat frame(size, CV_8UC3, cv::Scalar(0, 0, 0));
        EXPECT_TRUE(drawer_.processFrame(frame, test_results_, metrics_))
            << "Failed to process frame of size " << size.width << "x" << size.height;
    }
}

// 测试边界情况
TEST_F(FrameDrawerTest, EdgeCases) {
    ASSERT_TRUE(drawer_.init(config_));
    
    // 测试空图像
    cv::Mat empty_frame;
    EXPECT_FALSE(drawer_.processFrame(empty_frame, test_results_, metrics_));
    
    // 测试灰度图像
    cv::Mat gray_frame(480, 640, CV_8UC1, cv::Scalar(128));
    EXPECT_TRUE(drawer_.processFrame(gray_frame, test_results_, metrics_));
}

int main(int argc, char **argv) {
    testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}