package com.vincent.rsf.server.ai.service.provider;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.vincent.rsf.server.ai.model.AiDiagnosticToolResult;
import com.vincent.rsf.server.ai.model.AiPromptContext;
import com.vincent.rsf.server.manager.entity.Task;
import com.vincent.rsf.server.manager.enums.TaskStsType;
import com.vincent.rsf.server.manager.enums.TaskType;
import com.vincent.rsf.server.manager.mapper.TaskMapper;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;

@Service
public class AiTaskSummaryService implements AiDiagnosticDataProvider {

    private static final String TOOL_CODE = "task_summary";
    private static final String TOOL_NAME = "任务摘要";

    @Resource
    private TaskMapper taskMapper;

    /**
     * 返回任务工具默认顺序。
     */
    @Override
    public int getOrder() {
        return 20;
    }

    /**
     * 返回任务工具编码。
     */
    @Override
    public String getToolCode() {
        return TOOL_CODE;
    }

    /**
     * 返回任务工具展示名。
     */
    @Override
    public String getToolName() {
        return TOOL_NAME;
    }

    /**
     * 返回任务工具默认说明。
     */
    @Override
    public String getDefaultToolPrompt() {
        return "结合任务摘要识别积压、异常状态和最近变更任务。";
    }

    /**
     * 汇总任务状态和最近变更任务，生成任务摘要工具结果。
     */
    @Override
    public AiDiagnosticToolResult buildDiagnosticData(AiPromptContext context) {
        return new AiDiagnosticToolResult()
                .setToolCode(getToolCode())
                .setToolName(getToolName())
                .setSeverity("INFO")
                .setSummaryText(buildTaskSummary());
    }

    /**
     * 基于 man_task 生成任务总览、状态分布、类型分布和最近任务摘要。
     */
    private String buildTaskSummary() {
        List<Task> activeTasks = taskMapper.selectList(new LambdaQueryWrapper<Task>()
                .select(Task::getTaskCode, Task::getTaskStatus, Task::getTaskType, Task::getOrgLoc, Task::getTargLoc, Task::getUpdateTime)
                .eq(Task::getStatus, 1));

        Map<Integer, Long> statusCounters = new LinkedHashMap<>();
        Map<Integer, Long> typeCounters = new LinkedHashMap<>();
        for (Task task : activeTasks) {
            Integer taskStatus = task.getTaskStatus();
            Integer taskType = task.getTaskType();
            statusCounters.put(taskStatus, statusCounters.getOrDefault(taskStatus, 0L) + 1);
            typeCounters.put(taskType, typeCounters.getOrDefault(taskType, 0L) + 1);
        }

        List<Task> latestTasks = taskMapper.selectList(new LambdaQueryWrapper<Task>()
                .select(Task::getTaskCode, Task::getTaskStatus, Task::getTaskType, Task::getOrgLoc, Task::getTargLoc, Task::getUpdateTime)
                .eq(Task::getStatus, 1)
                .orderByDesc(Task::getUpdateTime)
                .last("limit 5"));

        StringBuilder summary = new StringBuilder();
        summary.append("以下是基于 man_task 的实时汇总，请优先依据这些任务数据回答；如果用户问题超出任务表范围，请明确说明。");
        summary.append("\n任务总览：共 ")
                .append(activeTasks.size())
                .append(" 条有效任务。");
        if (!statusCounters.isEmpty()) {
            summary.append("\n任务状态分布：")
                    .append(formatStatuses(statusCounters))
                    .append("。");
        }
        if (!typeCounters.isEmpty()) {
            summary.append("\n任务类型分布：")
                    .append(formatTypes(typeCounters))
                    .append("。");
        }
        if (!latestTasks.isEmpty()) {
            summary.append("\n最近更新任务 TOP5：")
                    .append(formatLatestTasks(latestTasks))
                    .append("。");
        }
        return summary.toString();
    }

    /**
     * 格式化任务状态统计。
     */
    private String formatStatuses(Map<Integer, Long> rows) {
        List<String> parts = new ArrayList<>();
        for (Map.Entry<Integer, Long> row : rows.entrySet()) {
            parts.add(resolveTaskStatus(row.getKey()) + " " + row.getValue() + " 条");
        }
        return String.join("，", parts);
    }

    /**
     * 格式化任务类型统计。
     */
    private String formatTypes(Map<Integer, Long> rows) {
        List<String> parts = new ArrayList<>();
        for (Map.Entry<Integer, Long> row : rows.entrySet()) {
            parts.add(resolveTaskType(row.getKey()) + " " + row.getValue() + " 条");
        }
        return String.join("，", parts);
    }

    /**
     * 格式化最近更新任务列表。
     */
    private String formatLatestTasks(List<Task> tasks) {
        List<String> parts = new ArrayList<>();
        for (Task task : tasks) {
            parts.add((task.getTaskCode() == null ? "未命名任务" : task.getTaskCode())
                    + "（"
                    + resolveTaskType(task.getTaskType())
                    + "，"
                    + resolveTaskStatus(task.getTaskStatus())
                    + "，源库位 " + emptyToDash(task.getOrgLoc())
                    + "，目标库位 " + emptyToDash(task.getTargLoc())
                    + "）");
        }
        return String.join("；", parts);
    }

    /**
     * 将任务状态编码转换为可读文案。
     */
    private String resolveTaskStatus(Integer taskStatus) {
        if (taskStatus == null) {
            return "未知状态";
        }
        for (TaskStsType item : TaskStsType.values()) {
            if (item.id.equals(taskStatus)) {
                return item.desc;
            }
        }
        return "状态" + taskStatus;
    }

    /**
     * 将任务类型编码转换为可读文案。
     */
    private String resolveTaskType(Integer taskType) {
        if (taskType == null) {
            return "未知类型";
        }
        for (TaskType item : TaskType.values()) {
            if (item.type.equals(taskType)) {
                return item.desc;
            }
        }
        return "类型" + taskType;
    }

    /**
     * 统一处理空字符串显示。
     */
    private String emptyToDash(String value) {
        return value == null || value.trim().isEmpty() ? "-" : value;
    }
}