package service

import (
	"fmt"
	"strings"

	"dd_fiber_api/internal/camp"
	"dd_fiber_api/internal/camp/dao"
	"dd_fiber_api/pkg/snowflake"
)

// TaskService 任务服务
type TaskService struct {
	taskDAO *dao.TaskDAO
}

// NewTaskService 创建任务服务
func NewTaskService(taskDAO *dao.TaskDAO) *TaskService {
	return &TaskService{
		taskDAO: taskDAO,
	}
}

// CreateTask 创建任务
func (s *TaskService) CreateTask(req *camp.CreateTaskRequest) (*camp.CreateTaskResponse, error) {
	// 若设置了前置任务：仅同小节内有效，且本节内已有任务时才能设置（第一个任务不能设前置）
	if req.PrerequisiteTaskID != "" {
		prereq, err := s.taskDAO.GetByID(req.PrerequisiteTaskID)
		if err != nil {
			return &camp.CreateTaskResponse{
				Success: false,
				Message: "前置任务不存在或已删除",
			}, nil
		}
		if prereq.SectionID != req.SectionID {
			return &camp.CreateTaskResponse{
				Success: false,
				Message: "前置任务必须属于同一个小节",
			}, nil
		}
		count, err := s.taskDAO.CountActiveBySection(req.SectionID)
		if err != nil {
			return &camp.CreateTaskResponse{
				Success: false,
				Message: fmt.Sprintf("校验失败: %v", err),
			}, nil
		}
		if count == 0 {
			return &camp.CreateTaskResponse{
				Success: false,
				Message: "本节第一个任务不能设置前置任务",
			}, nil
		}
	}

	taskID := snowflake.GetInstance().NextIDString()

	task := &camp.Task{
		ID:                 taskID,
		CampID:             req.CampID,
		SectionID:          req.SectionID,
		TaskType:           req.TaskType,
		Title:              req.Title,
		Content:            req.Content,
		Condition:          req.Condition,
		PrerequisiteTaskID: req.PrerequisiteTaskID,
	}

	err := s.taskDAO.Create(task)
	if err != nil {
		return &camp.CreateTaskResponse{
			Success: false,
			Message: fmt.Sprintf("创建任务失败: %v", err),
		}, nil
	}

	return &camp.CreateTaskResponse{
		ID:      taskID,
		Success: true,
		Message: "创建任务成功",
	}, nil
}

// GetTask 获取任务
func (s *TaskService) GetTask(id string, userID string) (*camp.GetTaskResponse, error) {
	task, err := s.taskDAO.GetByID(id)
	if err != nil {
		return &camp.GetTaskResponse{
			Success: false,
			Message: fmt.Sprintf("获取任务失败: %v", err),
		}, nil
	}

	// 如果提供了 user_id，可以在这里获取用户相关的状态信息
	// 例如：是否已完成、当前进度等
	// 目前先返回基础信息，后续可以根据需要扩展

	return &camp.GetTaskResponse{
		Task:    task,
		Success: true,
		Message: "获取任务成功",
	}, nil
}

// UpdateTask 更新任务
func (s *TaskService) UpdateTask(req *camp.UpdateTaskRequest) (*camp.UpdateTaskResponse, error) {
	// 若设置了前置任务：必须同小节；当前任务不能是本节第一个任务（ID 最小）；前置任务 ID 必须小于当前任务 ID
	if req.PrerequisiteTaskID != "" {
		prereq, err := s.taskDAO.GetByID(req.PrerequisiteTaskID)
		if err != nil {
			return &camp.UpdateTaskResponse{
				Success: false,
				Message: "前置任务不存在或已删除",
			}, nil
		}
		if prereq.SectionID != req.SectionID {
			return &camp.UpdateTaskResponse{
				Success: false,
				Message: "前置任务必须属于同一个小节",
			}, nil
		}
		minID, err := s.taskDAO.MinTaskIDBySection(req.SectionID)
		if err != nil {
			return &camp.UpdateTaskResponse{
				Success: false,
				Message: fmt.Sprintf("校验失败: %v", err),
			}, nil
		}
		if minID == req.ID {
			return &camp.UpdateTaskResponse{
				Success: false,
				Message: "本节第一个任务（ID 最小）不能设置前置任务",
			}, nil
		}
		if strings.Compare(req.PrerequisiteTaskID, req.ID) >= 0 {
			return &camp.UpdateTaskResponse{
				Success: false,
				Message: "前置任务必须是本节内 ID 更小的任务",
			}, nil
		}
	}

	task := &camp.Task{
		ID:                 req.ID,
		CampID:             req.CampID,
		SectionID:          req.SectionID,
		TaskType:           req.TaskType,
		Title:              req.Title,
		Content:            req.Content,
		Condition:          req.Condition,
		PrerequisiteTaskID: req.PrerequisiteTaskID,
	}

	err := s.taskDAO.Update(task)
	if err != nil {
		return &camp.UpdateTaskResponse{
			Success: false,
			Message: fmt.Sprintf("更新任务失败: %v", err),
		}, nil
	}

	return &camp.UpdateTaskResponse{
		Success: true,
		Message: "更新任务成功",
	}, nil
}

// DeleteTask 删除任务
func (s *TaskService) DeleteTask(id string) (*camp.DeleteTaskResponse, error) {
	// TODO: 检查是否存在用户进度
	// 暂时先允许删除，后续可以添加检查逻辑

	err := s.taskDAO.Delete(id)
	if err != nil {
		return &camp.DeleteTaskResponse{
			Success: false,
			Message: fmt.Sprintf("删除任务失败: %v", err),
		}, nil
	}

	return &camp.DeleteTaskResponse{
		Success: true,
		Message: "删除任务成功",
	}, nil
}

// ListTasks 列出任务（支持关键词搜索和筛选）
func (s *TaskService) ListTasks(req *camp.ListTasksRequest) (*camp.ListTasksResponse, error) {
	// 设置默认值
	if req.Page < 1 {
		req.Page = 1
	}
	if req.PageSize < 1 {
		req.PageSize = 10
	}
	if req.PageSize > 100 {
		req.PageSize = 100
	}

	tasks, total, err := s.taskDAO.List(req.Keyword, req.CampID, req.SectionID, req.TaskType, req.Page, req.PageSize)
	if err != nil {
		return &camp.ListTasksResponse{
			Success: false,
			Message: fmt.Sprintf("获取任务列表失败: %v", err),
		}, nil
	}

	return &camp.ListTasksResponse{
		Tasks:   tasks,
		Total:    total,
		Success:  true,
		Message:  "获取任务列表成功",
	}, nil
}