package com.seer.teach.admin.service.impl;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.seer.teach.ai.service.AiChatModelService;
import com.seer.teach.common.constants.CommonConstant;
import com.seer.teach.common.entity.BaseEntity;
import com.seer.teach.teacher.service.AiModelCallService;
import com.seer.teach.teacher.service.platform.LlmResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.ai.chat.model.Generation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.transaction.support.TransactionTemplate;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;

/**
 * <p>
 * AI生成服务抽象基类
 * </p>
 *
 * @param <T> 响应数据传输对象类型
 * @param <R> 请求参数类型
 * @param <E> 实体类型，继承自BaseEntity
 * @author Lingma
 * @since 2025-12-11
 */
@Slf4j
public abstract class AbstractGenerationService<T, R, E extends BaseEntity> {

    @Autowired
    protected StringRedisTemplate stringRedisTemplate;

    @Autowired
    protected AiModelCallService aiModelCallService;

    @Autowired
    protected TransactionTemplate transactionTemplate;

    @Autowired
    protected AiChatModelService chatModelService;

    /**
     * 检查当前线程是否被中断
     *
     * @return 如果线程被中断返回true，否则返回false
     */
    protected boolean isThreadInterrupted() {
        if (Thread.currentThread().isInterrupted()) {
            log.info("任务被中断，停止执行");
            return true;
        }
        return false;
    }

    /**
     * 检查任务是否被取消
     *
     * @param taskId 任务ID
     * @return 如果任务被取消返回true，否则返回false
     */
    protected boolean isTaskCancelled(String taskId) {
        if (StringUtils.hasText(taskId) && stringRedisTemplate.hasKey(CommonConstant.TASK_CANCEL_PREFIX + taskId)) {
            return true;
        }
        return false;
    }

    /**
     * 调用大模型API
     *
     * @param scenarioCode 场景编码
     * @param prompt       提示词
     * @param params       参数
     * @param userId       用户ID
     * @return 模型响应结果
     */
    protected LlmResponse callLLM(String scenarioCode, String prompt, Map<String, Object> params, Integer userId) {
        log.info("调用大模型，场景编码: {}, 提示词长度: {}", scenarioCode, prompt.length());
        //ChatResponse chatResponse = chatModelService.chatMessage(scenarioCode, prompt);
        LlmResponse response = new LlmResponse();
        //Generation result = chatResponse.getResult();

        return aiModelCallService.callModel(scenarioCode, prompt, params, userId);
    }

    /**
     * 解析大模型响应并转换为实体对象列表
     *
     * @param content   响应内容
     * @param converter 转换函数，用于将JsonNode转换为实体对象
     * @return 解析后的实体对象列表
     */
    protected List<T> parseLLMResponse(String content, Function<JsonNode, T> converter) {
        try {
            log.info("解析大模型响应，内容长度: {}", content.length());
            // 尝试解析内容中的JSON数组
            content = content.trim();
            if (content.startsWith("```json")) {
                content = content.substring(7, content.length() - 3).trim();
            } else if (content.startsWith("```")) {
                content = content.substring(3, content.length() - 3).trim();
            }
            // 解析JSON响应
            ObjectMapper objectMapper = new ObjectMapper();
            // 解析题目数组
            JsonNode jsonArray = objectMapper.readTree(content);
            List<T> result = new ArrayList<>();
            if (jsonArray.isArray()) {
                for (JsonNode node : jsonArray) {
                    T item = converter.apply(node);
                    if (item != null) {
                        result.add(item);
                    }
                }
            }
            return result;
        } catch (Exception e) {
            log.error("解析大模型响应时发生异常", e);
            return Collections.emptyList();
        }
    }

    /**
     * 安全地从JsonNode获取字符串值
     *
     * @param node      JsonNode对象
     * @param fieldName 字段名
     * @return 字段值，如果不存在则返回空字符串
     */
    protected String getStringValue(JsonNode node, String fieldName) {
        return node.has(fieldName) ? node.get(fieldName).asText() : "";
    }

    /**
     * 安全地从JsonNode获取整数值
     *
     * @param node         JsonNode对象
     * @param fieldName    字段名
     * @param defaultValue 默认值
     * @return 字段值，如果不存在则返回默认值
     */
    protected int getIntValue(JsonNode node, String fieldName, Integer defaultValue) {
        return node.has(fieldName) ? node.get(fieldName).asInt() : (defaultValue != null ? defaultValue : 0);
    }

    /**
     * 安全地从JsonNode获取整数值，默认为0
     *
     * @param node      JsonNode对象
     * @param fieldName 字段名
     * @return 字段值，如果不存在则返回0
     */
    protected int getIntValue(JsonNode node, String fieldName) {
        return getIntValue(node, fieldName, 0);
    }

    /**
     * 执行批量处理的模板方法
     *
     * @param request   请求参数
     * @param generator 生成器函数
     * @param saver     保存器函数
     */
    protected Integer executeBatchProcess(R request,
                                          Function<R, List<T>> generator,
                                          java.util.function.Consumer<List<T>> saver) {
        // 检查任务是否被取消
        String taskId = getTaskIdFromRequest(request);
        if (isThreadInterrupted() || isTaskCancelled(taskId)) {
            return 0;
        }
        // 生成内容
        List<T> items = generator.apply(request);
        if (items.isEmpty()) {
            return 0;
        }
        if (isThreadInterrupted() || (taskId != null && isTaskCancelled(taskId))) {
            return 0;
        }
        return transactionTemplate.execute(status -> {
            // 保存内容
            saver.accept(items);
            return items.size();
        });
    }

    /**
     * 从请求中获取任务ID的抽象方法，由子类实现
     *
     * @param request 请求对象
     * @return 任务ID
     */
    protected abstract String getTaskIdFromRequest(R request);

}