#!/usr/bin/env python3
"""
算法性能验证脚本
验证任务分解和分配算法的性能基准
"""

import json
import sys
import argparse
from pathlib import Path
from typing import Dict, Any, List
import logging

# 添加项目根目录到路径
project_root = Path(__file__).parent.parent
sys.path.insert(0, str(project_root))

logger = logging.getLogger(__name__)

# 性能基准阈值
PERFORMANCE_THRESHOLDS = {
    "task_decomposition": {
        "max_response_time_ms": 2000,  # 最大响应时间2秒
        "min_confidence_score": 0.6,   # 最小置信度0.6
        "max_task_count": 15,          # 最大任务数15个
        "min_template_match_rate": 0.3 # 最小模板匹配率0.3
    },
    "task_assignment": {
        "max_response_time_ms": 1000,  # 最大响应时间1秒
        "min_confidence_score": 0.4,   # 最小置信度0.4
        "min_candidate_count": 1,      # 最少1个候选人
        "max_candidate_count": 10      # 最多10个候选人
    },
    "workload_calculation": {
        "max_response_time_ms": 500,   # 最大响应时间0.5秒
        "min_accuracy": 0.8,           # 最小准确率0.8
        "max_variance": 0.3            # 最大方差0.3
    }
}

class AlgorithmPerformanceValidator:
    """算法性能验证器"""

    def __init__(self, benchmark_file: str):
        self.benchmark_file = benchmark_file
        self.benchmark_data = self._load_benchmark_data()
        self.validation_results = {}

    def _load_benchmark_data(self) -> Dict[str, Any]:
        """加载基准测试数据"""
        try:
            with open(self.benchmark_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        except Exception as e:
            logger.error(f"加载基准测试数据失败: {e}")
            sys.exit(1)

    def validate_task_decomposition(self) -> Dict[str, Any]:
        """验证任务分解算法性能"""
        logger.info("验证任务分解算法性能...")

        decomposition_tests = [
            test for test in self.benchmark_data.get("benchmarks", [])
            if "decompose" in test.get("name", "").lower()
        ]

        if not decomposition_tests:
            return {"status": "error", "message": "未找到任务分解测试数据"}

        results = {
            "status": "pass",
            "tests": [],
            "summary": {}
        }

        thresholds = PERFORMANCE_THRESHOLDS["task_decomposition"]
        total_tests = len(decomposition_tests)
        passed_tests = 0

        for test in decomposition_tests:
            test_result = self._validate_single_decomposition_test(test, thresholds)
            results["tests"].append(test_result)

            if test_result["status"] == "pass":
                passed_tests += 1

        # 计算汇总信息
        results["summary"] = {
            "total_tests": total_tests,
            "passed_tests": passed_tests,
            "pass_rate": passed_tests / total_tests if total_tests > 0 else 0,
            "avg_response_time": self._calculate_average(decomposition_tests, "stats", "mean"),
            "min_response_time": self._calculate_min(decomposition_tests, "stats", "min"),
            "max_response_time": self._calculate_max(decomposition_tests, "stats", "max")
        }

        # 判断整体状态
        if passed_tests < total_tests:
            results["status"] = "fail"
            results["message"] = f"{total_tests - passed_tests} 个测试未通过"

        return results

    def _validate_single_decomposition_test(self, test: Dict, thresholds: Dict) -> Dict:
        """验证单个任务分解测试"""
        test_name = test.get("name", "unknown")
        stats = test.get("stats", {})
        data = test.get("data", {})

        issues = []

        # 检查响应时间
        mean_time = stats.get("mean", 0) * 1000  # 转换为毫秒
        if mean_time > thresholds["max_response_time_ms"]:
            issues.append(f"响应时间 {mean_time:.2f}ms 超过阈值 {thresholds['max_response_time_ms']}ms")

        # 检查置信度（如果有）
        if "confidence_score" in data:
            confidence = data["confidence_score"]
            if confidence < thresholds["min_confidence_score"]:
                issues.append(f"置信度 {confidence:.2f} 低于阈值 {thresholds['min_confidence_score']}")

        # 检查任务数量（如果有）
        if "task_count" in data:
            task_count = data["task_count"]
            if task_count > thresholds["max_task_count"]:
                issues.append(f"任务数量 {task_count} 超过阈值 {thresholds['max_task_count']}")

        # 检查模板匹配率（如果有）
        if "template_match_score" in data:
            match_score = data["template_match_score"]
            if match_score < thresholds["min_template_match_rate"]:
                issues.append(f"模板匹配率 {match_score:.2f} 低于阈值 {thresholds['min_template_match_rate']}")

        return {
            "name": test_name,
            "status": "fail" if issues else "pass",
            "issues": issues,
            "stats": stats,
            "data": data
        }

    def validate_task_assignment(self) -> Dict[str, Any]:
        """验证任务分配算法性能"""
        logger.info("验证任务分配算法性能...")

        assignment_tests = [
            test for test in self.benchmark_data.get("benchmarks", [])
            if "assignment" in test.get("name", "").lower()
        ]

        if not assignment_tests:
            return {"status": "error", "message": "未找到任务分配测试数据"}

        results = {
            "status": "pass",
            "tests": [],
            "summary": {}
        }

        thresholds = PERFORMANCE_THRESHOLDS["task_assignment"]
        total_tests = len(assignment_tests)
        passed_tests = 0

        for test in assignment_tests:
            test_result = self._validate_single_assignment_test(test, thresholds)
            results["tests"].append(test_result)

            if test_result["status"] == "pass":
                passed_tests += 1

        # 计算汇总信息
        results["summary"] = {
            "total_tests": total_tests,
            "passed_tests": passed_tests,
            "pass_rate": passed_tests / total_tests if total_tests > 0 else 0,
            "avg_response_time": self._calculate_average(assignment_tests, "stats", "mean"),
            "avg_confidence_score": self._calculate_average_data_field(assignment_tests, "confidence_score")
        }

        # 判断整体状态
        if passed_tests < total_tests:
            results["status"] = "fail"
            results["message"] = f"{total_tests - passed_tests} 个测试未通过"

        return results

    def _validate_single_assignment_test(self, test: Dict, thresholds: Dict) -> Dict:
        """验证单个任务分配测试"""
        test_name = test.get("name", "unknown")
        stats = test.get("stats", {})
        data = test.get("data", {})

        issues = []

        # 检查响应时间
        mean_time = stats.get("mean", 0) * 1000  # 转换为毫秒
        if mean_time > thresholds["max_response_time_ms"]:
            issues.append(f"响应时间 {mean_time:.2f}ms 超过阈值 {thresholds['max_response_time_ms']}ms")

        # 检查置信度
        if "confidence_score" in data:
            confidence = data["confidence_score"]
            if confidence < thresholds["min_confidence_score"]:
                issues.append(f"置信度 {confidence:.2f} 低于阈值 {thresholds['min_confidence_score']}")

        # 检查候选人数量
        if "candidate_count" in data:
            candidate_count = data["candidate_count"]
            if candidate_count < thresholds["min_candidate_count"]:
                issues.append(f"候选人数量 {candidate_count} 少于最小值 {thresholds['min_candidate_count']}")
            elif candidate_count > thresholds["max_candidate_count"]:
                issues.append(f"候选人数量 {candidate_count} 超过最大值 {thresholds['max_candidate_count']}")

        return {
            "name": test_name,
            "status": "fail" if issues else "pass",
            "issues": issues,
            "stats": stats,
            "data": data
        }

    def validate_workload_calculation(self) -> Dict[str, Any]:
        """验证工作负载计算性能"""
        logger.info("验证工作负载计算性能...")

        workload_tests = [
            test for test in self.benchmark_data.get("benchmarks", [])
            if "workload" in test.get("name", "").lower()
        ]

        if not workload_tests:
            return {"status": "error", "message": "未找到工作负载计算测试数据"}

        results = {
            "status": "pass",
            "tests": [],
            "summary": {}
        }

        thresholds = PERFORMANCE_THRESHOLDS["workload_calculation"]
        total_tests = len(workload_tests)
        passed_tests = 0

        for test in workload_tests:
            test_result = self._validate_single_workload_test(test, thresholds)
            results["tests"].append(test_result)

            if test_result["status"] == "pass":
                passed_tests += 1

        # 计算汇总信息
        results["summary"] = {
            "total_tests": total_tests,
            "passed_tests": passed_tests,
            "pass_rate": passed_tests / total_tests if total_tests > 0 else 0,
            "avg_response_time": self._calculate_average(workload_tests, "stats", "mean")
        }

        # 判断整体状态
        if passed_tests < total_tests:
            results["status"] = "fail"
            results["message"] = f"{total_tests - passed_tests} 个测试未通过"

        return results

    def _validate_single_workload_test(self, test: Dict, thresholds: Dict) -> Dict:
        """验证单个工作负载计算测试"""
        test_name = test.get("name", "unknown")
        stats = test.get("stats", {})
        data = test.get("data", {})

        issues = []

        # 检查响应时间
        mean_time = stats.get("mean", 0) * 1000  # 转换为毫秒
        if mean_time > thresholds["max_response_time_ms"]:
            issues.append(f"响应时间 {mean_time:.2f}ms 超过阈值 {thresholds['max_response_time_ms']}ms")

        # 检查准确率（如果有）
        if "accuracy" in data:
            accuracy = data["accuracy"]
            if accuracy < thresholds["min_accuracy"]:
                issues.append(f"准确率 {accuracy:.2f} 低于阈值 {thresholds['min_accuracy']}")

        # 检查方差（如果有）
        if "variance" in data:
            variance = data["variance"]
            if variance > thresholds["max_variance"]:
                issues.append(f"方差 {variance:.2f} 超过阈值 {thresholds['max_variance']}")

        return {
            "name": test_name,
            "status": "fail" if issues else "pass",
            "issues": issues,
            "stats": stats,
            "data": data
        }

    def _calculate_average(self, tests: List[Dict], stats_key: str, value_key: str) -> float:
        """计算平均值"""
        values = []
        for test in tests:
            if stats_key in test and value_key in test[stats_key]:
                values.append(test[stats_key][value_key])
        return sum(values) / len(values) if values else 0

    def _calculate_min(self, tests: List[Dict], stats_key: str, value_key: str) -> float:
        """计算最小值"""
        values = []
        for test in tests:
            if stats_key in test and value_key in test[stats_key]:
                values.append(test[stats_key][value_key])
        return min(values) if values else 0

    def _calculate_max(self, tests: List[Dict], stats_key: str, value_key: str) -> float:
        """计算最大值"""
        values = []
        for test in tests:
            if stats_key in test and value_key in test[stats_key]:
                values.append(test[stats_key][value_key])
        return max(values) if values else 0

    def _calculate_average_data_field(self, tests: List[Dict], field_name: str) -> float:
        """计算数据字段的平均值"""
        values = []
        for test in tests:
            if "data" in test and field_name in test["data"]:
                values.append(test["data"][field_name])
        return sum(values) / len(values) if values else 0

    def run_validation(self) -> Dict[str, Any]:
        """运行完整的性能验证"""
        logger.info("开始算法性能验证...")

        validation_results = {
            "overall_status": "pass",
            "timestamp": json.dumps(self.benchmark_data.get("datetime")),
            "algorithms": {}
        }

        # 验证任务分解算法
        decomposition_result = self.validate_task_decomposition()
        validation_results["algorithms"]["task_decomposition"] = decomposition_result

        # 验证任务分配算法
        assignment_result = self.validate_task_assignment()
        validation_results["algorithms"]["task_assignment"] = assignment_result

        # 验证工作负载计算
        workload_result = self.validate_workload_calculation()
        validation_results["algorithms"]["workload_calculation"] = workload_result

        # 计算整体状态
        failed_algorithms = [
            name for name, result in validation_results["algorithms"].items()
            if result.get("status") == "fail"
        ]

        if failed_algorithms:
            validation_results["overall_status"] = "fail"
            validation_results["failed_algorithms"] = failed_algorithms
            validation_results["message"] = f"以下算法性能验证失败: {', '.join(failed_algorithms)}"
        else:
            validation_results["message"] = "所有算法性能验证通过"

        return validation_results

    def print_results(self, results: Dict[str, Any]):
        """打印验证结果"""
        print("=" * 80)
        print("算法性能验证结果")
        print("=" * 80)

        print(f"整体状态: {results['overall_status'].upper()}")
        print(f"时间: {results['timestamp']}")
        print(f"消息: {results['message']}")
        print()

        for algorithm_name, algorithm_result in results["algorithms"].items():
            print(f"算法: {algorithm_name}")
            print("-" * 40)

            if algorithm_result.get("status") == "error":
                print(f"  错误: {algorithm_result['message']}")
                continue

            summary = algorithm_result.get("summary", {})
            print(f"  状态: {algorithm_result['status'].upper()}")
            print(f"  测试数量: {summary.get('total_tests', 0)}")
            print(f"  通过数量: {summary.get('passed_tests', 0)}")
            print(f"  通过率: {summary.get('pass_rate', 0):.2%}")

            if "avg_response_time" in summary:
                print(f"  平均响应时间: {summary['avg_response_time']*1000:.2f}ms")

            if "avg_confidence_score" in summary:
                print(f"  平均置信度: {summary['avg_confidence_score']:.2f}")

            # 显示失败的测试
            failed_tests = [
                test for test in algorithm_result.get("tests", [])
                if test.get("status") == "fail"
            ]

            if failed_tests:
                print("  失败的测试:")
                for test in failed_tests[:3]:  # 只显示前3个失败的测试
                    print(f"    - {test['name']}: {', '.join(test['issues'])}")
                if len(failed_tests) > 3:
                    print(f"    ... 还有 {len(failed_tests) - 3} 个失败的测试")

            print()

def main():
    """主函数"""
    parser = argparse.ArgumentParser(description='算法性能验证脚本')
    parser.add_argument('benchmark_file', help='基准测试结果JSON文件')
    parser.add_argument('--output', '-o', help='输出结果文件')
    parser.add_argument('--verbose', '-v', action='store_true', help='详细输出')

    args = parser.parse_args()

    # 配置日志
    log_level = logging.DEBUG if args.verbose else logging.INFO
    logging.basicConfig(level=log_level, format='%(levelname)s: %(message)s')

    # 验证基准测试文件是否存在
    if not Path(args.benchmark_file).exists():
        logger.error(f"基准测试文件不存在: {args.benchmark_file}")
        sys.exit(1)

    # 运行验证
    validator = AlgorithmPerformanceValidator(args.benchmark_file)
    results = validator.run_validation()

    # 打印结果
    validator.print_results(results)

    # 保存结果
    if args.output:
        with open(args.output, 'w', encoding='utf-8') as f:
            json.dump(results, f, ensure_ascii=False, indent=2)
        logger.info(f"验证结果已保存到: {args.output}")

    # 根据验证结果设置退出码
    sys.exit(0 if results["overall_status"] == "pass" else 1)

if __name__ == "__main__":
    main()