"""
简单C/C++测试用例集合

本模块提供了一系列渐进式复杂度的C/C++测试用例，用于验证LLM生成管道的
不同方面。每个测试用例包含源代码、预期的元数据特征、验证目标和质量标准。
"""

from typing import List, Dict, Any
from ..test_llm_generation import TestCase


# 基础算术函数测试用例
BASIC_ARITHMETIC_CASES = [
    TestCase(
        name="add_two_numbers",
        description="基本的两个整数相加函数",
        source_code="""
int add(int a, int b) {
    return a + b;
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 0
        },
        verification_goals=[
            'functional_correctness',
            'integer_overflow',
            'return_value'
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            'return == a + b'
        ],
        complexity_level="basic",
        tags=['arithmetic', 'basic', 'function']
    ),

    TestCase(
        name="calculate_average",
        description="计算两个整数的平均值",
        source_code="""
int average(int a, int b) {
    return (a + b) / 2;
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 0
        },
        verification_goals=[
            'functional_correctness',
            'integer_overflow',
            'division_safety'
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            'return == (a + b) / 2'
        ],
        complexity_level="basic",
        tags=['arithmetic', 'division', 'function']
    ),

    TestCase(
        name="simple_multiply",
        description="基本的整数乘法函数",
        source_code="""
int multiply(int a, int b) {
    return a * b;
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 0
        },
        verification_goals=[
            'functional_correctness',
            'integer_overflow',
            'return_value'
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            'return == a * b'
        ],
        complexity_level="basic",
        tags=['arithmetic', 'multiplication', 'function']
    )
]

# 指针操作测试用例
POINTER_OPERATION_CASES = [
    TestCase(
        name="simple_pointer_swap",
        description="使用指针交换两个整数值",
        source_code="""
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 0  # 只计算全局变量，不计算局部变量
        },
        verification_goals=[
            'memory_safety',
            'pointer_validity',
            'functional_correctness'
        ],
        hints=[
            "确保指针参数有效",
            "检查空指针情况",
            "验证交换逻辑正确性"
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            '\\valid(a)',
            '\\valid(b)'
        ],
        complexity_level="intermediate",
        tags=['pointer', 'swap', 'memory']
    ),

    TestCase(
        name="pointer_arithmetic",
        description="基本的指针算术操作",
        source_code="""
int sum_array(int *array, int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += array[i];
    }
    return sum;
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 0
        },
        verification_goals=[
            'memory_safety',
            'array_bounds',
            'pointer_validity',
            'functional_correctness'
        ],
        hints=[
            "验证数组边界",
            "检查指针有效性",
            "确保size为正数"
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            '\\valid_read(array + (0..size-1))',
            'size > 0'
        ],
        complexity_level="intermediate",
        tags=['pointer', 'array', 'arithmetic', 'loop']
    )
]

# 数组操作测试用例
ARRAY_OPERATION_CASES = [
    TestCase(
        name="array_initialization",
        description="数组初始化函数",
        source_code="""
void init_array(int *array, int size, int value) {
    for (int i = 0; i < size; i++) {
        array[i] = value;
    }
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 0
        },
        verification_goals=[
            'memory_safety',
            'array_bounds',
            'pointer_validity',
            'functional_correctness'
        ],
        hints=[
            "验证数组边界",
            "检查指针有效性",
            "确保size为非负数"
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            '\\valid(array + (0..size-1))',
            'size >= 0'
        ],
        complexity_level="intermediate",
        tags=['array', 'initialization', 'loop', 'pointer']
    ),

    TestCase(
        name="array_copy",
        description="数组拷贝函数",
        source_code="""
void copy_array(int *dest, int *src, int size) {
    for (int i = 0; i < size; i++) {
        dest[i] = src[i];
    }
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 0
        },
        verification_goals=[
            'memory_safety',
            'array_bounds',
            'pointer_validity',
            'no_aliasing'
        ],
        hints=[
            "验证源和目标数组边界",
            "检查指针有效性",
            "确保内存不重叠"
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            '\\valid_read(src + (0..size-1))',
            '\\valid(dest + (0..size-1))'
        ],
        complexity_level="intermediate",
        tags=['array', 'copy', 'memory', 'pointer']
    )
]

# 字符串操作测试用例
STRING_OPERATION_CASES = [
    TestCase(
        name="string_length",
        description="计算字符串长度的函数",
        source_code="""
#include <stddef.h>

size_t string_length(const char *str) {
    size_t len = 0;
    while (str[len] != '\\0') {
        len++;
    }
    return len;
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 0
        },
        verification_goals=[
            'memory_safety',
            'pointer_validity',
            'null_termination',
            'functional_correctness'
        ],
        hints=[
            "验证字符串以null结尾",
            "检查指针有效性",
            "防止缓冲区溢出"
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            '\\valid_read(str)',
            'str != \\\\0'
        ],
        complexity_level="intermediate",
        tags=['string', 'length', 'pointer', 'null_termination']
    ),

    TestCase(
        name="string_copy",
        description="安全的字符串拷贝函数",
        source_code="""
#include <stddef.h>

size_t string_copy(char *dest, const char *src, size_t dest_size) {
    size_t i;
    for (i = 0; i < dest_size - 1 && src[i] != '\\0'; i++) {
        dest[i] = src[i];
    }
    dest[i] = '\\0';
    return i;
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 0
        },
        verification_goals=[
            'memory_safety',
            'buffer_overflow',
            'pointer_validity',
            'null_termination',
            'functional_correctness'
        ],
        hints=[
            "验证目标缓冲区大小",
            "确保字符串正确终止",
            "防止缓冲区溢出"
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            '\\valid_read(src)',
            '\\valid(dest + (0..dest_size-1))',
            'dest_size > 0'
        ],
        complexity_level="advanced",
        tags=['string', 'copy', 'buffer_safety', 'pointer']
    )
]

# 内存分配测试用例
MEMORY_ALLOCATION_CASES = [
    TestCase(
        name="dynamic_array_create",
        description="动态数组创建函数",
        source_code="""
#include <stdlib.h>

int* create_array(int size) {
    if (size <= 0) {
        return NULL;
    }

    int *array = (int*)malloc(size * sizeof(int));
    if (array == NULL) {
        return NULL;
    }

    for (int i = 0; i < size; i++) {
        array[i] = 0;
    }

    return array;
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 0
        },
        verification_goals=[
            'memory_safety',
            'memory_leak',
            'allocation_success',
            'functional_correctness'
        ],
        hints=[
            "验证内存分配成功",
            "检查size参数有效性",
            "处理内存分配失败情况"
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            'size > 0',
            'return != \\\\0 ==> \\valid(return + (0..size-1))'
        ],
        complexity_level="advanced",
        tags=['memory', 'allocation', 'dynamic', 'error_handling']
    )
]

# FreeRTOS特定测试用例
FREERTOS_CASES = [
    TestCase(
        name="freertos_task_function",
        description="FreeRTOS任务函数示例",
        source_code="""
#include "FreeRTOS.h"
#include "task.h"

void vTaskFunction(void *pvParameters) {
    int *param_value = (int*)pvParameters;

    for (;;) {
        if (param_value != NULL) {
            (*param_value)++;
        }

        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 0
        },
        verification_goals=[
            'memory_safety',
            'pointer_validity',
            'task_safety',
            'concurrency'
        ],
        hints=[
            "验证任务参数有效性",
            "检查指针访问安全性",
            "考虑并发访问问题"
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            '\\valid_read(pvParameters)'
        ],
        complexity_level="advanced",
        tags=['freertos', 'task', 'concurrency', 'pointer']
    ),

    TestCase(
        name="freertos_queue_operations",
        description="FreeRTOS队列操作函数",
        source_code="""
#include "FreeRTOS.h"
#include "queue.h"

BaseType_t send_to_queue(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait) {
    if (xQueue == NULL || pvItemToQueue == NULL) {
        return pdFAIL;
    }

    return xQueueSend(xQueue, pvItemToQueue, xTicksToWait);
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 0
        },
        verification_goals=[
            'memory_safety',
            'pointer_validity',
            'queue_operation',
            'error_handling'
        ],
        hints=[
            "验证队列句柄有效性",
            "检查数据项指针有效性",
            "处理错误返回情况"
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            'xQueue != \\\\0',
            'pvItemToQueue != \\\\0'
        ],
        complexity_level="advanced",
        tags=['freertos', 'queue', 'pointer', 'error_handling']
    )
]

# 错误处理测试用例
ERROR_HANDLING_CASES = [
    TestCase(
        name="safe_division",
        description="安全的除法函数，包含错误处理",
        source_code="""
#include <stdbool.h>

bool safe_divide(int a, int b, int *result) {
    if (b == 0 || result == NULL) {
        return false;
    }

    *result = a / b;
    return true;
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 0
        },
        verification_goals=[
            'memory_safety',
            'pointer_validity',
            'division_by_zero',
            'error_handling',
            'functional_correctness'
        ],
        hints=[
            "检查除数不为零",
            "验证结果指针有效性",
            "正确处理错误情况"
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            '\\valid(result)',
            'b != 0'
        ],
        complexity_level="intermediate",
        tags=['error_handling', 'division', 'pointer', 'safety']
    )
]

# 边界条件测试用例
BOUNDARY_CONDITION_CASES = [
    TestCase(
        name="max_value_handler",
        description="处理最大值边界条件的函数",
        source_code="""
#include <limits.h>

int safe_add(int a, int b, bool *overflow) {
    if (overflow == NULL) {
        return 0;
    }

    if (a > 0 && b > INT_MAX - a) {
        *overflow = true;
        return 0;
    }
    if (a < 0 && b < INT_MIN - a) {
        *overflow = true;
        return 0;
    }

    *overflow = false;
    return a + b;
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 0
        },
        verification_goals=[
            'integer_overflow',
            'pointer_validity',
            'boundary_conditions',
            'error_handling',
            'functional_correctness'
        ],
        hints=[
            "检查整数溢出条件",
            "验证溢出标志指针",
            "处理正负数边界情况"
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            '\\valid(overflow)'
        ],
        complexity_level="advanced",
        tags=['boundary', 'overflow', 'safety', 'pointer']
    )
]

# 复杂数据结构测试用例
COMPLEX_STRUCTURE_CASES = [
    TestCase(
        name="linked_list_node",
        description="链表节点操作函数",
        source_code="""
typedef struct Node {
    int data;
    struct Node *next;
} Node;

Node* create_node(int value) {
    Node *new_node = (Node*)malloc(sizeof(Node));
    if (new_node == NULL) {
        return NULL;
    }

    new_node->data = value;
    new_node->next = NULL;
    return new_node;
}
""",
        expected_metadata={
            'functions_count': 1,
            'variables_count': 1  # Node结构体定义
        },
        verification_goals=[
            'memory_safety',
            'allocation_success',
            'data_structure_integrity',
            'pointer_initialization'
        ],
        hints=[
            "验证内存分配",
            "确保指针正确初始化",
            "检查结构体字段设置"
        ],
        expected_spec_patterns=[
            '\\requires',
            '\\ensures',
            'return != \\\\0 ==> \\valid(return)'
        ],
        complexity_level="advanced",
        tags=['linked_list', 'struct', 'memory', 'pointer']
    )
]

# 测试用例集合
ALL_TEST_CASES = (
    BASIC_ARITHMETIC_CASES +
    POINTER_OPERATION_CASES +
    ARRAY_OPERATION_CASES +
    STRING_OPERATION_CASES +
    MEMORY_ALLOCATION_CASES +
    FREERTOS_CASES +
    ERROR_HANDLING_CASES +
    BOUNDARY_CONDITION_CASES +
    COMPLEX_STRUCTURE_CASES
)

# 按复杂度分组的测试用例
TEST_CASES_BY_COMPLEXITY = {
    'basic': [case for case in ALL_TEST_CASES if case.complexity_level == 'basic'],
    'intermediate': [case for case in ALL_TEST_CASES if case.complexity_level == 'intermediate'],
    'advanced': [case for case in ALL_TEST_CASES if case.complexity_level == 'advanced']
}

# 按类别分组的测试用例
TEST_CASES_BY_CATEGORY = {
    'arithmetic': [case for case in ALL_TEST_CASES if 'arithmetic' in case.tags],
    'pointer': [case for case in ALL_TEST_CASES if 'pointer' in case.tags],
    'array': [case for case in ALL_TEST_CASES if 'array' in case.tags],
    'string': [case for case in ALL_TEST_CASES if 'string' in case.tags],
    'memory': [case for case in ALL_TEST_CASES if 'memory' in case.tags],
    'freertos': [case for case in ALL_TEST_CASES if 'freertos' in case.tags],
    'error_handling': [case for case in ALL_TEST_CASES if 'error_handling' in case.tags],
    'safety': [case for case in ALL_TEST_CASES if 'safety' in case.tags]
}

# 获取特定子集的测试用例
def get_test_cases_by_complexity(complexity_level: str) -> List[TestCase]:
    """根据复杂度级别获取测试用例"""
    return TEST_CASES_BY_COMPLEXITY.get(complexity_level, [])

def get_test_cases_by_category(category: str) -> List[TestCase]:
    """根据类别获取测试用例"""
    return TEST_CASES_BY_CATEGORY.get(category, [])

def get_test_cases_by_tags(tags: List[str]) -> List[TestCase]:
    """根据标签获取测试用例"""
    return [case for case in ALL_TEST_CASES if any(tag in case.tags for tag in tags)]

def get_basic_test_suite() -> List[TestCase]:
    """获取基础测试套件（用于快速验证）"""
    return TEST_CASES_BY_COMPLEXITY['basic'][:3]  # 前3个基础用例

def get_comprehensive_test_suite() -> List[TestCase]:
    """获取全面测试套件"""
    return ALL_TEST_CASES

def get_performance_test_suite() -> List[TestCase]:
    """获取性能测试套件（中等复杂度）"""
    return TEST_CASES_BY_COMPLEXITY['intermediate']