package article

import (
	"context"
	"fmt"
	"time"
	"tyapi-server/internal/domains/article/entities"
	"tyapi-server/internal/domains/article/repositories"

	"go.uber.org/zap"
)

// TaskManagementService 任务管理服务
type TaskManagementService struct {
	scheduledTaskRepo repositories.ScheduledTaskRepository
	logger            *zap.Logger
}

// NewTaskManagementService 创建任务管理服务
func NewTaskManagementService(
	scheduledTaskRepo repositories.ScheduledTaskRepository,
	logger *zap.Logger,
) *TaskManagementService {
	return &TaskManagementService{
		scheduledTaskRepo: scheduledTaskRepo,
		logger:           logger,
	}
}

// GetTaskStatus 获取任务状态
func (s *TaskManagementService) GetTaskStatus(ctx context.Context, taskID string) (*entities.ScheduledTask, error) {
	task, err := s.scheduledTaskRepo.GetByTaskID(ctx, taskID)
	if err != nil {
		return nil, fmt.Errorf("获取任务状态失败: %w", err)
	}
	return &task, nil
}

// GetArticleTaskStatus 获取文章的定时任务状态
func (s *TaskManagementService) GetArticleTaskStatus(ctx context.Context, articleID string) (*entities.ScheduledTask, error) {
	task, err := s.scheduledTaskRepo.GetByArticleID(ctx, articleID)
	if err != nil {
		return nil, fmt.Errorf("获取文章定时任务状态失败: %w", err)
	}
	return &task, nil
}

// CancelTask 取消任务
func (s *TaskManagementService) CancelTask(ctx context.Context, taskID string) error {
	if err := s.scheduledTaskRepo.MarkAsCancelled(ctx, taskID); err != nil {
		return fmt.Errorf("取消任务失败: %w", err)
	}
	
	s.logger.Info("任务已取消", zap.String("task_id", taskID))
	return nil
}

// GetActiveTasks 获取活动任务列表
func (s *TaskManagementService) GetActiveTasks(ctx context.Context) ([]entities.ScheduledTask, error) {
	tasks, err := s.scheduledTaskRepo.GetActiveTasks(ctx)
	if err != nil {
		return nil, fmt.Errorf("获取活动任务列表失败: %w", err)
	}
	return tasks, nil
}

// GetExpiredTasks 获取过期任务列表
func (s *TaskManagementService) GetExpiredTasks(ctx context.Context) ([]entities.ScheduledTask, error) {
	tasks, err := s.scheduledTaskRepo.GetExpiredTasks(ctx)
	if err != nil {
		return nil, fmt.Errorf("获取过期任务列表失败: %w", err)
	}
	return tasks, nil
}

// CleanupExpiredTasks 清理过期任务
func (s *TaskManagementService) CleanupExpiredTasks(ctx context.Context) error {
	expiredTasks, err := s.GetExpiredTasks(ctx)
	if err != nil {
		return err
	}
	
	for _, task := range expiredTasks {
		if err := s.scheduledTaskRepo.MarkAsCancelled(ctx, task.TaskID); err != nil {
			s.logger.Warn("清理过期任务失败", zap.String("task_id", task.TaskID), zap.Error(err))
			continue
		}
		s.logger.Info("已清理过期任务", zap.String("task_id", task.TaskID))
	}
	
	return nil
}

// GetTaskStats 获取任务统计信息
func (s *TaskManagementService) GetTaskStats(ctx context.Context) (map[string]interface{}, error) {
	activeTasks, err := s.GetActiveTasks(ctx)
	if err != nil {
		return nil, err
	}
	
	expiredTasks, err := s.GetExpiredTasks(ctx)
	if err != nil {
		return nil, err
	}
	
	stats := map[string]interface{}{
		"active_tasks_count":   len(activeTasks),
		"expired_tasks_count":  len(expiredTasks),
		"total_tasks_count":    len(activeTasks) + len(expiredTasks),
		"next_task_time":       nil,
		"last_cleanup_time":    time.Now(),
	}
	
	// 计算下一个任务时间
	if len(activeTasks) > 0 {
		nextTask := activeTasks[0]
		for _, task := range activeTasks {
			if task.ScheduledAt.Before(nextTask.ScheduledAt) {
				nextTask = task
			}
		}
		stats["next_task_time"] = nextTask.ScheduledAt
	}
	
	return stats, nil
}