package certification

import (
	"context"
	"fmt"

	"tyapi-server/internal/application/certification/dto/commands"
	"tyapi-server/internal/application/certification/dto/queries"
	"tyapi-server/internal/application/certification/dto/responses"
	"tyapi-server/internal/domains/certification/entities"
	"tyapi-server/internal/domains/certification/enums"
	"tyapi-server/internal/domains/certification/repositories"
	"tyapi-server/internal/domains/certification/services"
	"tyapi-server/internal/domains/certification/services/state_machine"

	"go.uber.org/zap"
)

// CertificationApplicationServiceImpl 认证应用服务实现
// 负责用例协调，DTO转换，是应用层的核心组件
type CertificationApplicationServiceImpl struct {
	// 领域服务依赖
	aggregateService     services.CertificationAggregateService
	workflowOrchestrator services.CertificationWorkflowOrchestrator

	// 仓储依赖
	queryRepository repositories.CertificationQueryRepository

	// 基础设施依赖
	callbackHandler *state_machine.EsignCallbackHandler
	logger          *zap.Logger
}

// NewCertificationApplicationService 创建认证应用服务
func NewCertificationApplicationService(
	aggregateService services.CertificationAggregateService,
	workflowOrchestrator services.CertificationWorkflowOrchestrator,
	queryRepository repositories.CertificationQueryRepository,
	callbackHandler *state_machine.EsignCallbackHandler,
	logger *zap.Logger,
) CertificationApplicationService {
	return &CertificationApplicationServiceImpl{
		aggregateService:     aggregateService,
		workflowOrchestrator: workflowOrchestrator,
		queryRepository:      queryRepository,
		callbackHandler:      callbackHandler,
		logger:               logger,
	}
}

// ================ 用户操作用例 ================

// CreateCertification 创建认证申请
func (s *CertificationApplicationServiceImpl) CreateCertification(
	ctx context.Context,
	cmd *commands.CreateCertificationCommand,
) (*responses.CertificationResponse, error) {
	s.logger.Info("开始创建认证申请", zap.String("user_id", cmd.UserID))

	// 1. 调用聚合服务创建认证
	cert, err := s.aggregateService.CreateCertification(ctx, cmd.UserID)
	if err != nil {
		s.logger.Error("创建认证申请失败", zap.Error(err), zap.String("user_id", cmd.UserID))
		return nil, fmt.Errorf("创建认证申请失败: %w", err)
	}

	// 2. 转换为响应DTO
	response := s.convertToResponse(cert)

	s.logger.Info("认证申请创建成功",
		zap.String("user_id", cmd.UserID),
		zap.String("certification_id", cert.ID))

	return response, nil
}

// SubmitEnterpriseInfo 提交企业信息
func (s *CertificationApplicationServiceImpl) SubmitEnterpriseInfo(
	ctx context.Context,
	cmd *commands.SubmitEnterpriseInfoCommand,
) (*responses.CertificationResponse, error) {
	s.logger.Info("开始提交企业信息",
		zap.String("certification_id", cmd.CertificationID),
		zap.String("user_id", cmd.UserID))

	// 1. 构建工作流命令
	workflowCmd := &services.SubmitEnterpriseInfoCommand{
		CertificationID: cmd.CertificationID,
		UserID:          cmd.UserID,
		EnterpriseInfo:  cmd.EnterpriseInfo,
	}

	// 2. 执行工作流
	workflowResult, err := s.workflowOrchestrator.SubmitEnterpriseInfo(ctx, workflowCmd)
	if err != nil {
		s.logger.Error("提交企业信息失败", zap.Error(err))
		return nil, fmt.Errorf("提交企业信息失败: %w", err)
	}

	// 3. 加载最新的认证信息
	cert, err := s.aggregateService.LoadCertification(ctx, cmd.CertificationID)
	if err != nil {
		s.logger.Error("加载认证信息失败", zap.Error(err))
		return nil, fmt.Errorf("加载认证信息失败: %w", err)
	}

	// 4. 转换为响应DTO
	response := s.convertToResponse(cert)

	// 5. 添加工作流结果信息
	if workflowResult.Data != nil {
		response.Metadata = workflowResult.Data
	}

	s.logger.Info("企业信息提交成功", zap.String("certification_id", cmd.CertificationID))
	return response, nil
}

// ApplyContract 申请合同签署
func (s *CertificationApplicationServiceImpl) ApplyContract(
	ctx context.Context,
	cmd *commands.ApplyContractCommand,
) (*responses.ContractSignUrlResponse, error) {
	s.logger.Info("开始申请合同签署",
		zap.String("certification_id", cmd.CertificationID),
		zap.String("user_id", cmd.UserID))

	// 1. 构建工作流命令
	workflowCmd := &services.ApplyContractCommand{
		CertificationID: cmd.CertificationID,
		UserID:          cmd.UserID,
	}

	// 2. 执行工作流
	workflowResult, err := s.workflowOrchestrator.ApplyContract(ctx, workflowCmd)
	if err != nil {
		s.logger.Error("申请合同签署失败", zap.Error(err))
		return nil, fmt.Errorf("申请合同签署失败: %w", err)
	}

	// 3. 从工作流结果提取签署URL信息
	signURL, _ := workflowResult.Data["contract_sign_url"].(string)
	contractURL, _ := workflowResult.Data["contract_url"].(string)
	nextAction, _ := workflowResult.Data["next_action"].(string)

	// 4. 构建响应
	response := responses.NewContractSignUrlResponse(
		cmd.CertificationID,
		signURL,
		contractURL,
		nextAction,
		workflowResult.Message,
	)

	s.logger.Info("合同申请成功", zap.String("certification_id", cmd.CertificationID))
	return response, nil
}

// RetryOperation 重试失败操作
func (s *CertificationApplicationServiceImpl) RetryOperation(
	ctx context.Context,
	cmd *commands.RetryOperationCommand,
) (*responses.CertificationResponse, error) {
	s.logger.Info("开始重试操作",
		zap.String("certification_id", cmd.CertificationID),
		zap.String("operation", cmd.Operation))

	// 1. 执行重试工作流
	workflowResult, err := s.workflowOrchestrator.RetryOperation(ctx, cmd.CertificationID, cmd.Operation)
	if err != nil {
		s.logger.Error("重试操作失败", zap.Error(err))
		return nil, fmt.Errorf("重试操作失败: %w", err)
	}

	// 2. 加载最新的认证信息
	cert, err := s.aggregateService.LoadCertification(ctx, cmd.CertificationID)
	if err != nil {
		s.logger.Error("加载认证信息失败", zap.Error(err))
		return nil, fmt.Errorf("加载认证信息失败: %w", err)
	}

	// 3. 转换为响应DTO
	response := s.convertToResponse(cert)

	// 4. 添加重试结果信息
	if workflowResult.Data != nil {
		response.Metadata = workflowResult.Data
	}

	s.logger.Info("重试操作成功", zap.String("certification_id", cmd.CertificationID))
	return response, nil
}

// ================ 查询用例 ================

// GetCertification 获取认证详情
func (s *CertificationApplicationServiceImpl) GetCertification(
	ctx context.Context,
	query *queries.GetCertificationQuery,
) (*responses.CertificationResponse, error) {
	s.logger.Debug("获取认证详情", zap.String("certification_id", query.CertificationID))

	// 1. 从查询仓储获取认证信息
	cert, err := s.queryRepository.GetByID(ctx, query.CertificationID)
	if err != nil {
		s.logger.Error("获取认证信息失败", zap.Error(err))
		return nil, fmt.Errorf("认证信息不存在: %w", err)
	}

	// 2. 权限验证（如果提供了用户ID）
	if query.UserID != "" && cert.UserID != query.UserID {
		return nil, fmt.Errorf("无权限访问此认证信息")
	}

	// 3. 转换为响应DTO
	response := s.convertToResponse(cert)

	return response, nil
}

// GetUserCertifications 获取用户认证列表
func (s *CertificationApplicationServiceImpl) GetUserCertifications(
	ctx context.Context,
	query *queries.GetUserCertificationsQuery,
) (*responses.CertificationListResponse, error) {
	s.logger.Debug("获取用户认证列表", zap.String("user_id", query.UserID))

	// 1. 转换为通用列表查询对象
	domainQuery := &queries.ListCertificationsQuery{
		Page:     query.Page,
		PageSize: query.PageSize,
		UserID:   query.UserID,
		Status:   query.Status,
	}

	// 根据包含选项设置状态过滤
	if !query.IncludeCompleted && !query.IncludeFailed {
		// 只显示进行中的认证
		domainQuery.Statuses = []enums.CertificationStatus{
			enums.StatusPending,
			enums.StatusInfoSubmitted,
			enums.StatusEnterpriseVerified,
			enums.StatusContractApplied,
		}
	}

	// 转换为领域查询对象
	listQuery := domainQuery.ToDomainQuery()

	// 2. 执行查询
	certs, total, err := s.queryRepository.List(ctx, listQuery)
	if err != nil {
		s.logger.Error("查询用户认证列表失败", zap.Error(err))
		return nil, fmt.Errorf("查询用户认证列表失败: %w", err)
	}

	// 3. 转换为响应DTO
	items := make([]*responses.CertificationResponse, len(certs))
	for i, cert := range certs {
		items[i] = s.convertToResponse(cert)
	}

	// 4. 构建列表响应
	response := responses.NewCertificationListResponse(items, total, query.Page, query.PageSize)

	return response, nil
}

// ListCertifications 获取认证列表（管理员）
func (s *CertificationApplicationServiceImpl) ListCertifications(
	ctx context.Context,
	query *queries.ListCertificationsQuery,
) (*responses.CertificationListResponse, error) {
	s.logger.Debug("获取认证列表（管理员）")

	// 1. 转换为领域查询对象
	domainQuery := query.ToDomainQuery()

	// 2. 执行查询
	certs, total, err := s.queryRepository.List(ctx, domainQuery)
	if err != nil {
		s.logger.Error("查询认证列表失败", zap.Error(err))
		return nil, fmt.Errorf("查询认证列表失败: %w", err)
	}

	// 3. 转换为响应DTO
	items := make([]*responses.CertificationResponse, len(certs))
	for i, cert := range certs {
		items[i] = s.convertToResponse(cert)
	}

	// 4. 构建列表响应
	response := responses.NewCertificationListResponse(items, total, query.Page, query.PageSize)

	return response, nil
}

// SearchCertifications 搜索认证
func (s *CertificationApplicationServiceImpl) SearchCertifications(
	ctx context.Context,
	query *queries.SearchCertificationsQuery,
) (*responses.CertificationListResponse, error) {
	s.logger.Debug("搜索认证", zap.String("keyword", query.Keyword))

	// 1. 转换为领域查询对象
	domainQuery := query.ToDomainQuery()

	// 2. 根据搜索字段选择不同的搜索方法
	var certs []*entities.Certification
	var total int64
	var err error

	if len(domainQuery.SearchFields) == 1 {
		switch domainQuery.SearchFields[0] {
		case "company_name":
			certs, err = s.queryRepository.SearchByCompanyName(ctx, domainQuery.Keyword, domainQuery.GetLimit())
			total = int64(len(certs)) // 简化实现，实际应该有单独的计数方法
		case "legal_person_name":
			certs, err = s.queryRepository.SearchByLegalPerson(ctx, domainQuery.Keyword, domainQuery.GetLimit())
			total = int64(len(certs))
		default:
			// 通用搜索，这里简化为按公司名搜索
			certs, err = s.queryRepository.SearchByCompanyName(ctx, domainQuery.Keyword, domainQuery.GetLimit())
			total = int64(len(certs))
		}
	} else {
		// 多字段搜索，这里简化为按公司名搜索
		certs, err = s.queryRepository.SearchByCompanyName(ctx, domainQuery.Keyword, domainQuery.GetLimit())
		total = int64(len(certs))
	}

	if err != nil {
		s.logger.Error("搜索认证失败", zap.Error(err))
		return nil, fmt.Errorf("搜索认证失败: %w", err)
	}

	// 3. 转换为响应DTO
	items := make([]*responses.CertificationResponse, len(certs))
	for i, cert := range certs {
		items[i] = s.convertToResponse(cert)
	}

	// 4. 构建列表响应
	response := responses.NewCertificationListResponse(items, total, query.Page, query.PageSize)

	return response, nil
}

// GetCertificationStatistics 获取认证统计
func (s *CertificationApplicationServiceImpl) GetCertificationStatistics(
	ctx context.Context,
	query *queries.GetCertificationStatisticsQuery,
) (*responses.CertificationStatisticsResponse, error) {
	s.logger.Debug("获取认证统计", zap.String("period", query.Period))

	// 1. 转换为领域查询对象
	domainQuery := query.ToDomainQuery()

	// 2. 验证查询参数
	if err := domainQuery.Validate(); err != nil {
		return nil, fmt.Errorf("统计查询参数无效: %w", err)
	}

	// 3. 确定时间周期
	var period repositories.CertificationTimePeriod
	switch query.Period {
	case "daily":
		period = repositories.PeriodDaily
	case "weekly":
		period = repositories.PeriodWeekly
	case "monthly":
		period = repositories.PeriodMonthly
	case "yearly":
		period = repositories.PeriodYearly
	default:
		period = repositories.PeriodDaily
	}

	// 4. 获取统计数据
	stats, err := s.queryRepository.GetStatistics(ctx, period)
	if err != nil {
		s.logger.Error("获取认证统计失败", zap.Error(err))
		return nil, fmt.Errorf("获取认证统计失败: %w", err)
	}

	// 5. 获取进度统计（如果需要）
	var progressStats *repositories.CertificationProgressStats
	if query.IncludeProgressStats {
		progressStats, err = s.queryRepository.GetProgressStatistics(ctx)
		if err != nil {
			s.logger.Warn("获取进度统计失败", zap.Error(err))
		}
	}

	// 6. 构建响应
	response := &responses.CertificationStatisticsResponse{
		Period:        query.Period,
		TimeRange:     domainQuery.GetTimeRange(),
		Statistics:    stats,
		ProgressStats: progressStats,
		GeneratedAt:   domainQuery.StartDate,
		Charts:        s.generateChartsData(stats, progressStats),
	}

	return response, nil
}

// ================ e签宝回调处理 ================

// HandleEsignCallback 处理e签宝回调
func (s *CertificationApplicationServiceImpl) HandleEsignCallback(
	ctx context.Context,
	cmd *commands.EsignCallbackCommand,
) (*responses.CallbackResponse, error) {
	s.logger.Info("开始处理e签宝回调",
		zap.String("certification_id", cmd.CertificationID),
		zap.String("callback_type", cmd.CallbackType))

	// 1. 解析回调数据
	callbackData, err := s.callbackHandler.ParseCallbackData(cmd.RawData)
	if err != nil {
		s.logger.Error("解析回调数据失败", zap.Error(err))
		return responses.NewCallbackResponse(false, cmd.CertificationID, cmd.CallbackType,
			fmt.Sprintf("解析回调数据失败: %s", err.Error())), err
	}

	// 2. 构建工作流回调命令
	workflowCmd := &services.EsignCallbackCommand{
		CertificationID: cmd.CertificationID,
		CallbackType:    cmd.CallbackType,
		CallbackData:    callbackData,
	}

	// 3. 根据回调类型分发处理
	var workflowResult *services.WorkflowResult
	switch cmd.CallbackType {
	case "auth_result":
		workflowResult, err = s.workflowOrchestrator.HandleEnterpriseVerificationCallback(ctx, workflowCmd)
	case "sign_result":
		workflowResult, err = s.workflowOrchestrator.HandleContractSignCallback(ctx, workflowCmd)
	default:
		err = fmt.Errorf("不支持的回调类型: %s", cmd.CallbackType)
	}

	if err != nil {
		s.logger.Error("处理回调失败", zap.Error(err))
		return responses.NewCallbackResponse(false, cmd.CertificationID, cmd.CallbackType,
			fmt.Sprintf("处理回调失败: %s", err.Error())), err
	}

	// 4. 构建成功响应
	response := responses.NewCallbackResponse(true, cmd.CertificationID, cmd.CallbackType, workflowResult.Message)

	// 5. 设置状态转换信息
	if workflowResult.StateTransition != nil {
		response.StateTransition = workflowResult.StateTransition
		response.OldStatus = workflowResult.StateTransition.OldStatus
		response.NewStatus = workflowResult.StateTransition.NewStatus
	}

	s.logger.Info("e签宝回调处理成功", zap.String("certification_id", cmd.CertificationID))
	return response, nil
}

// ================ 管理员操作 ================

// ForceTransitionStatus 强制状态转换（管理员）
func (s *CertificationApplicationServiceImpl) ForceTransitionStatus(
	ctx context.Context,
	cmd *commands.ForceTransitionStatusCommand,
) (*responses.CertificationResponse, error) {
	s.logger.Info("开始强制状态转换",
		zap.String("certification_id", cmd.CertificationID),
		zap.String("admin_id", cmd.AdminID),
		zap.String("target_status", string(cmd.TargetStatus)))

	// 1. 权限验证（这里简化，实际应该有更复杂的权限验证）
	// TODO: 实现管理员权限验证逻辑

	// 2. 执行状态转换
	result, err := s.aggregateService.TransitionState(
		ctx,
		cmd.CertificationID,
		cmd.TargetStatus,
		enums.ActorTypeAdmin,
		cmd.AdminID,
		cmd.Reason,
		map[string]interface{}{
			"force": cmd.Force,
		},
	)
	if err != nil {
		s.logger.Error("强制状态转换失败", zap.Error(err))
		return nil, fmt.Errorf("强制状态转换失败: %w", err)
	}

	// 3. 加载最新的认证信息
	cert, err := s.aggregateService.LoadCertification(ctx, cmd.CertificationID)
	if err != nil {
		s.logger.Error("加载认证信息失败", zap.Error(err))
		return nil, fmt.Errorf("加载认证信息失败: %w", err)
	}

	// 4. 转换为响应DTO
	response := s.convertToResponse(cert)

	// 5. 添加状态转换信息
	if result != nil {
		response.Metadata = map[string]interface{}{
			"state_transition": result,
			"admin_operation":  true,
		}
	}

	s.logger.Info("强制状态转换成功", zap.String("certification_id", cmd.CertificationID))
	return response, nil
}

// GetSystemMonitoring 获取系统监控数据
func (s *CertificationApplicationServiceImpl) GetSystemMonitoring(
	ctx context.Context,
	query *queries.GetSystemMonitoringQuery,
) (*responses.SystemMonitoringResponse, error) {
	s.logger.Debug("获取系统监控数据", zap.String("time_range", query.TimeRange))

	// 1. 获取基础统计数据
	stats, err := s.queryRepository.GetStatistics(ctx, repositories.PeriodDaily)
	if err != nil {
		s.logger.Error("获取基础统计失败", zap.Error(err))
		return nil, fmt.Errorf("获取系统监控数据失败: %w", err)
	}

	// 2. 构建监控指标
	metrics := make(map[string]interface{})

	if query.ShouldIncludeMetric("certification_count") {
		metrics["certification_count"] = stats.TotalCertifications
	}
	if query.ShouldIncludeMetric("success_rate") {
		metrics["success_rate"] = stats.SuccessRate
	}
	if query.ShouldIncludeMetric("failure_rate") {
		metrics["failure_rate"] = 1.0 - stats.SuccessRate
	}
	if query.ShouldIncludeMetric("avg_processing_time") {
		metrics["avg_processing_time"] = stats.AvgProcessingTime.String()
	}
	if query.ShouldIncludeMetric("status_distribution") {
		metrics["status_distribution"] = stats.StatusDistribution
	}

	// 3. 生成系统警告
	alerts := s.generateSystemAlerts(stats)

	// 4. 评估系统健康状态
	systemHealth := s.evaluateSystemHealth(stats, alerts)

	// 5. 构建响应
	response := &responses.SystemMonitoringResponse{
		TimeRange:     query.TimeRange,
		Metrics:       metrics,
		Alerts:        alerts,
		SystemHealth:  systemHealth,
		LastUpdatedAt: stats.StartDate,
	}

	return response, nil
}

// ================ 辅助方法 ================

// convertToResponse 转换实体为响应DTO
func (s *CertificationApplicationServiceImpl) convertToResponse(cert *entities.Certification) *responses.CertificationResponse {
	response := &responses.CertificationResponse{
		ID:                   cert.ID,
		UserID:               cert.UserID,
		Status:               cert.Status,
		StatusName:           enums.GetStatusName(cert.Status),
		Progress:             cert.GetProgress(),
		CreatedAt:            cert.CreatedAt,
		UpdatedAt:            cert.UpdatedAt,
		InfoSubmittedAt:      cert.InfoSubmittedAt,
		EnterpriseVerifiedAt: cert.EnterpriseVerifiedAt,
		ContractAppliedAt:    cert.ContractAppliedAt,
		ContractSignedAt:     cert.ContractSignedAt,
		IsCompleted:          cert.IsCompleted(),
		IsFailed:             enums.IsFailureStatus(cert.Status),
		IsUserActionRequired: cert.IsUserActionRequired(),
		NextAction:           enums.GetUserActionHint(cert.Status),
		AvailableActions:     cert.GetAvailableActions(),
		RetryCount:           cert.RetryCount,
		Metadata:             make(map[string]interface{}),
	}

	// 设置企业信息（从认证实体中构建）
	// TODO: 这里需要从企业信息服务或其他地方获取完整的企业信息
	// response.EnterpriseInfo = cert.EnterpriseInfo

	// 设置合同信息（从认证实体中构建）
	if cert.ContractFileID != "" || cert.EsignFlowID != "" {
		// TODO: 从认证实体字段构建合同信息值对象
		// response.ContractInfo = &value_objects.ContractInfo{...}
	}

	// 设置失败信息
	if enums.IsFailureStatus(cert.Status) {
		response.FailureReason = cert.FailureReason
		response.FailureReasonName = enums.GetFailureReasonName(cert.FailureReason)
		response.FailureMessage = cert.FailureMessage
		response.CanRetry = enums.IsRetryable(cert.FailureReason)
	}

	return response
}

// generateChartsData 生成图表数据
func (s *CertificationApplicationServiceImpl) generateChartsData(
	stats *repositories.CertificationStatistics,
	progressStats *repositories.CertificationProgressStats,
) map[string]interface{} {
	charts := make(map[string]interface{})

	// 状态分布饼图
	if stats.StatusDistribution != nil {
		statusChart := make(map[string]interface{})
		statusChart["type"] = "pie"
		statusChart["data"] = stats.StatusDistribution
		charts["status_distribution"] = statusChart
	}

	// 失败原因分布
	if stats.FailureDistribution != nil {
		failureChart := make(map[string]interface{})
		failureChart["type"] = "bar"
		failureChart["data"] = stats.FailureDistribution
		charts["failure_distribution"] = failureChart
	}

	// 进度分布
	if progressStats != nil && progressStats.ProgressDistribution != nil {
		progressChart := make(map[string]interface{})
		progressChart["type"] = "histogram"
		progressChart["data"] = progressStats.ProgressDistribution
		charts["progress_distribution"] = progressChart
	}

	return charts
}

// generateSystemAlerts 生成系统警告
func (s *CertificationApplicationServiceImpl) generateSystemAlerts(stats *repositories.CertificationStatistics) []responses.SystemAlert {
	var alerts []responses.SystemAlert

	// 成功率警告
	if stats.SuccessRate < 0.8 {
		level := "warning"
		if stats.SuccessRate < 0.6 {
			level = "critical"
		}

		alert := responses.SystemAlert{
			Level:     level,
			Type:      "success_rate_low",
			Message:   fmt.Sprintf("认证成功率过低：%.1f%%", stats.SuccessRate*100),
			Metric:    "success_rate",
			Value:     stats.SuccessRate,
			Threshold: 0.8,
			CreatedAt: stats.StartDate,
		}
		alerts = append(alerts, alert)
	}

	// 处理时间警告
	if stats.AvgProcessingTime.Hours() > 24 {
		alert := responses.SystemAlert{
			Level:     "warning",
			Type:      "processing_time_high",
			Message:   fmt.Sprintf("平均处理时间过长：%.1f小时", stats.AvgProcessingTime.Hours()),
			Metric:    "avg_processing_time",
			Value:     stats.AvgProcessingTime.String(),
			Threshold: "24h",
			CreatedAt: stats.StartDate,
		}
		alerts = append(alerts, alert)
	}

	return alerts
}

// evaluateSystemHealth 评估系统健康状态
func (s *CertificationApplicationServiceImpl) evaluateSystemHealth(
	stats *repositories.CertificationStatistics,
	alerts []responses.SystemAlert,
) responses.SystemHealthStatus {
	overall := "healthy"
	components := map[string]string{
		"certification_service": "healthy",
		"esign_integration":     "healthy",
		"database":              "healthy",
		"state_machine":         "healthy",
	}

	// 根据警告判断健康状态
	for _, alert := range alerts {
		if alert.Level == "critical" {
			overall = "critical"
			break
		} else if alert.Level == "warning" && overall == "healthy" {
			overall = "warning"
		}
	}

	// 根据统计数据评估组件状态
	if stats.SuccessRate < 0.6 {
		components["certification_service"] = "critical"
		components["esign_integration"] = "warning"
	} else if stats.SuccessRate < 0.8 {
		components["certification_service"] = "warning"
	}

	return responses.SystemHealthStatus{
		Overall:    overall,
		Components: components,
		LastCheck:  stats.StartDate,
		Details: map[string]interface{}{
			"total_certifications": stats.TotalCertifications,
			"success_rate":         stats.SuccessRate,
			"avg_processing_time":  stats.AvgProcessingTime.String(),
		},
	}
}