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

using namespace pipeline;

class RendererTest : public ::testing::Test {
protected:
    void SetUp() override {
        // 创建测试配置
        config_.window_name = "Test Window";
        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 {
        renderer_.cleanup();
    }

    // 辅助函数：检查渲染结果
    bool checkRenderedFrame(const cv::Mat& frame) {
        if (frame.empty()) {
            return false;
        }
        // 检查图像类型（应该始终是3通道）
        if (frame.type() != CV_8UC3) {
            return false;
        }
        // 检查图像是否有效
        if (frame.cols <= 0 || frame.rows <= 0) {
            return false;
        }
        return true;
    }

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

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

// 测试未初始化时的渲染
TEST_F(RendererTest, RenderWithoutInit) {
    EXPECT_FALSE(renderer_.render(test_frame_, test_results_, metrics_));
}

// 测试正常渲染
TEST_F(RendererTest, NormalRendering) {
    ASSERT_TRUE(renderer_.init(config_));
    EXPECT_TRUE(renderer_.render(test_frame_, test_results_, metrics_));
    EXPECT_TRUE(checkRenderedFrame(renderer_.getLastFrame()));
}

// 测试空检测结果的渲染
TEST_F(RendererTest, RenderEmptyResults) {
    ASSERT_TRUE(renderer_.init(config_));
    std::vector<renderer::DetectionResult> empty_results;
    EXPECT_TRUE(renderer_.render(test_frame_, empty_results, metrics_));
}

// 测试清理
TEST_F(RendererTest, Cleanup) {
    ASSERT_TRUE(renderer_.init(config_));
    renderer_.cleanup();
    // 清理后渲染应该失败
    EXPECT_FALSE(renderer_.render(test_frame_, test_results_, metrics_));
}

// 测试不同尺寸的图像
TEST_F(RendererTest, DifferentImageSizes) {
    ASSERT_TRUE(renderer_.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(renderer_.render(frame, test_results_, metrics_))
            << "Failed to render frame of size " << size.width << "x" << size.height;
    }
}

// 测试性能指标显示
TEST_F(RendererTest, MetricsDisplay) {
    ASSERT_TRUE(renderer_.init(config_));
    
    // 测试不同的性能指标值
    std::vector<PerformanceMetrics> test_metrics = {
        {30.0f, 33.3f, 50.0f},
        {60.0f, 16.7f, 75.0f},
        {120.0f, 8.3f, 90.0f}
    };
    
    for (const auto& metrics : test_metrics) {
        EXPECT_TRUE(renderer_.render(test_frame_, test_results_, metrics))
            << "Failed to render with metrics: FPS=" << metrics.fps
            << ", Inference=" << metrics.inference_time_ms
            << "ms, GPU=" << metrics.gpu_usage_percent << "%";
    }
}

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

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