package com.takai.web.controller.takaiai;

import com.alibaba.fastjson2.JSONObject;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.takai.ai.domain.TakaiSysOss;
import com.takai.ai.domain.dto.*;
import com.takai.ai.domain.entity.*;
import com.takai.ai.service.ITakaiAiService;
import com.takai.ai.utils.MinioUtil;
import com.takai.bigmodel.domain.entity.PageParams;
import com.takai.common.annotation.Log;
import com.takai.common.constant.HttpStatus;
import com.takai.common.core.controller.BaseController;
import com.takai.common.core.domain.AjaxResult;
import com.takai.common.core.domain.R;
import com.takai.common.core.domain.TreeStruct;
import com.takai.common.core.domain.entity.SysDictData;
import com.takai.common.core.domain.entity.SysUser;
import com.takai.common.core.domain.model.LoginUser;
import com.takai.common.core.page.TableDataInfo;
import com.takai.common.enums.BusinessType;
import com.takai.common.enums.ProjectTypeEnum;
import com.takai.common.exception.ServiceException;
import com.takai.common.utils.SecurityUtils;
import com.takai.common.utils.poi.ExcelUtil;
import com.takai.framework.web.service.SysPermissionService;
import com.takai.system.domain.SysProject;
import com.takai.system.domain.SysProjectTree;
import com.takai.system.service.ISysDictDataService;
import com.takai.system.service.ISysProjectService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

@Slf4j
@RestController
@RequestMapping("/deepseek/api")
public class TakaiAiController extends BaseController {

    @Autowired
    private ITakaiAiService takaiAisService;

    @Autowired
    private ISysDictDataService dictDataService;

    @Autowired
    private SysPermissionService permissionService;

    @Autowired
    private ISysProjectService sysProjectService;

    @Autowired
    private MinioUtil minioUtil;

    /**
     * 对话聊天
     *
     * @param response
     * @param request
     * @param sseParams
     * @return
     */
    @PostMapping(value = "/chat", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public SseEmitter chat(HttpServletResponse response, HttpServletRequest request, @RequestBody TakaiSseInfoParams sseParams)
            throws Exception {
        return takaiAisService.sseInvoke(sseParams);
    }

    @PostMapping("/async/completions")
    public AjaxResult asyncCompletions(@RequestBody TakaiCompletionsParams params) {
        return success(takaiAisService.asyncCompletions(params));
    }

    @PostMapping("/free/async/completions")
    public AjaxResult freeAsyncCompletions(@RequestBody TakaiCompletionsParams params) {
        return asyncCompletions(params);
    }

    /**
     * 应用列表
     *
     * @param params
     * @return
     */
    @PostMapping("/getApplicationList")
    public TableDataInfo getApplicationList(@RequestBody TakaiPageParams params) {
        TakaiApplication vo = setFlagParams(params.getUserId(), params.getTypeId(), params.getProjectId(), 1);
        PageHelper.startPage(params.getPageNumber(), params.getPageSize(), "").setReasonable(true);
        vo.setName(params.getName());
        List<TakaiApplicationResult> list = takaiAisService.getApplicationList(vo);
        Page<TakaiApplicationResult> page = (Page<TakaiApplicationResult>) list;
        return getDataTableResultTotal(list, page.getTotal());
    }

    /**
     * 创建应用
     *
     * @param params
     * @return
     */
    @PostMapping("/createApplication")
    public AjaxResult addApplication(@RequestBody TakaiApplicationParams params) {
        SysUser user = new SysUser();
        user.setUserId(params.getUserId());
        Set<String> permissions = permissionService.getMenuPermission(user);
        int i = 0;
        if (permissions != null && permissions.size() > 0 && (permissions.contains("deepseek:application:role") || permissions.contains("*:*:*"))) {
            i = takaiAisService.createApplication(params, true);
        }else{
            i = takaiAisService.createApplication(params, false);
        }
        return AjaxResult.success(i);
    }

    /**
     * 查询应用详情
     *
     * @param appId
     * @return
     */
    @GetMapping("/selectApplication/{appId}")
    public AjaxResult selectApplication(@PathVariable String appId) {
        JSONObject application = takaiAisService.selectApplication(appId);
        return AjaxResult.success(application);
    }

    /**
     * 修改应用
     *
     * @param params
     * @param appId
     * @return
     */
    @PutMapping("/updateApplication/{appId}")
    public AjaxResult updateApplication(@RequestBody TakaiApplicationParams params, @PathVariable String appId) {
        SysUser user = new SysUser();
        user.setUserId(params.getUserId());
        Set<String> permissions = permissionService.getMenuPermission(user);
        int application = 0;
        if (permissions != null && permissions.size() > 0 && (permissions.contains("deepseek:application:role") || permissions.contains("*:*:*"))) {
            application = takaiAisService.updateApplication(params, appId, true);
        }else{
            application = takaiAisService.updateApplication(params, appId, false);
        }
        return AjaxResult.success(application);
    }

    /**
     * 删除应用
     *
     * @param appId
     * @return
     */
    @DeleteMapping("/delApplication/{appId}")
    public AjaxResult delApplication(@PathVariable String appId) {
        int application = takaiAisService.delApplication(appId);
        return AjaxResult.success(application);
    }

    /**
     * 首页
     *
     * @param params
     * @return
     */
    @PostMapping("/index")
    public AjaxResult index(@RequestBody PageParams params) {
        TakaiApplication vo = setFlagParams(params.getUserId(), params.getTypeId(), params.getProjectId(), 2);
        // 问答应用总数
        List<TakaiApplicationResult> appList = takaiAisService.getApplicationList(vo);
        // 知识库总数
        List<TakaiKnowledge> knowledgeList = takaiAisService.queryKnowledgeList();
        Map<String, Object> map = new HashMap();
        map.put("applicationCount", appList.size());
        map.put("knowledgeCount", knowledgeList.size());
        return success(map);
    }

    /**
     * 获取知识库下拉列表
     *
     * @return
     */
    @GetMapping("/knowledgeList")
    public AjaxResult getKnowledgeList() {
        return success(takaiAisService.queryKnowledgeList());
    }


    /**
     * 知识库列表
     *
     * @param params
     * @return
     */
    @PostMapping("/getKnowledgeList")
    public TableDataInfo getKnowledgeList(@RequestBody TakaiPageParams params) {
        PageHelper.startPage(params.getPageNumber(), params.getPageSize(), "").setReasonable(true);
        List<TakaiKnowledge> list = takaiAisService.queryKnowledgeList();
        Page<TakaiKnowledge> page = (Page<TakaiKnowledge>) list;
        return getDataTableResultTotal(list, page.getTotal());
    }

    /**
     * 创建知识库
     *
     * @param knowledge
     * @return
     */
    @PostMapping("/createKnowledge")
    public AjaxResult createKnowledge(@RequestBody TakaiKnowledgeParams knowledge) {
        int i = takaiAisService.createKnowledge(knowledge);
        return success(i);
    }

    /**
     * 知识库详情
     *
     * @param knowledgeId
     * @return
     */
    @GetMapping("/detailKnowledge/{knowledgeId}")
    public AjaxResult detailKnowledge(@PathVariable String knowledgeId) {
        TakaiKnowledge result = takaiAisService.detailKnowledge(knowledgeId);
        return success(result);
    }

    /**
     * 修改知识库
     *
     * @param knowledge
     * @param knowledgeId
     * @return
     */
    @PutMapping("/updateKnowledge/{knowledgeId}")
    public AjaxResult updateKnowledge(@RequestBody TakaiKnowledgeParams knowledge, @PathVariable String knowledgeId) {
        int i = takaiAisService.updateKnowledge(knowledge, knowledgeId);
        return success(i);
    }

    /**
     * 删除知识库
     *
     * @param knowledgeId
     * @return
     */
    @DeleteMapping("/delKnowledge/{knowledgeId}")
    public AjaxResult delKnowledge(@PathVariable String knowledgeId) {
        int i = takaiAisService.delKnowledge(knowledgeId);
        return success(i);
    }

    /**
     * 知识列表
     *
     * @param params
     * @return
     */
    @PostMapping("/documentList")
    public TableDataInfo documentList(@RequestBody TakaiDocumentParams params) {
        PageHelper.startPage(params.getPage(), params.getSize(), "").setReasonable(true);
        List<TakaiDocument> list = takaiAisService.documentList(params);
        Page<TakaiDocument> page = (Page<TakaiDocument>) list;
        return getDataTableResultTotal(list, page.getTotal());
//        SysUser user = new SysUser();
//        user.setUserId(Long.valueOf(params.getUserId()));
//        // 角色集合
//        Set<String> permissions = permissionService.getMenuPermission(user);
//        // admin 所有文件
//        if (permissions.contains("document:public") && permissions.contains("document:internal") && permissions.contains("document:confidential") && permissions.contains("document:topsecret")) {
//            params.setFileLevel("4");
//        }
//        // 项目经理 机密文件 + 所有项目下的内部文件 + 公开文件
//        else if (permissions.contains("public") && permissions.contains("internal") && permissions.contains("confidential")) {
//            params.setFileLevel("3");
//        }
//        // 普通用户 所属项目下的内部文件 + 公开文件
//        else if (permissions.contains("public") && permissions.contains("internal")) {
//            params.setFileLevel("2");
//        }
//        // 游客 只能浏览公开文件
//        else if (permissions.contains("public")){
//            params.setFileLevel("1");
//        }else{
//            params.setFileLevel("0"); // 没有权限
//        }
//        List<TakaiDocument> sTotal = takaiAisService.documentList(params);
//        PageHelper.startPage(params.getPage(), params.getSize(), "").setReasonable(true);
//        List<TakaiDocument> list = takaiAisService.documentList(params);
//        return getDataTableResultTotal(list, Long.valueOf(sTotal.size()));
    }

    /**
     * 知识详情
     *
     * @param documentId
     * @return
     */
    @GetMapping("/documentDetail/{documentId}")
    public AjaxResult documentDetail(@PathVariable String documentId) {
        return success(takaiAisService.documentDetail(documentId));
    }

    /**
     * 更新知识
     *
     * @param params
     * @param documentId
     * @return
     */
    @PutMapping("/updateDocument/{documentId}")
    public AjaxResult updateDocument(@RequestBody TakaiDocumentParams params, @PathVariable String documentId) {
        int i = takaiAisService.updateDocument(params, documentId);
        return success(i);
    }

    /**
     * 删除知识
     *
     * @param documentId
     * @return
     */
    @DeleteMapping("/delDocument/{documentId}")
    public AjaxResult delDocument(@PathVariable String documentId) {
        int i = takaiAisService.delDocument(documentId);
        return success(i);
    }

    /**
     * 删除知识
     *
     * @param documentId
     * @return
     */
    @DeleteMapping("/delUnfinishedDocument/{documentId}")
    public R<Integer> delUnfinishedDocument(@PathVariable String documentId) {
        int i = takaiAisService.delUnfinishedDocument(documentId);
        return R.ok(i);
    }

    /**
     * 上传知识文件
     *
     * @param files
     * @param knowledgeId
     * @return
     * @throws Exception
     */
    @PostMapping("/uploadDocument/{knowledgeId}") //@RequestPart DocumentParams documentParams,
    public AjaxResult uploadDocument(@RequestParam("files") MultipartFile[] files,
                                     @PathVariable String knowledgeId) throws Exception {
        try {
            // 1. 先同步上传文件到MinIO（IO操作，建议后续也异步，这里先保留）
            List<TakaiSysOss> ossList;
            try {
                ossList = minioUtil.uploadMultiple(files);
                if (ossList == null || ossList.isEmpty()) {
                    log.error("MinIO上传文件为空，直接返回");
                    return error("MinIO上传文件为空");
                }
            } catch (Exception e) {
                log.error("MinIO上传文件失败", e);
                return error("MinIO上传文件失败");
            }
            String updateBy = SecurityUtils.getLoginUser() == null ? "" : SecurityUtils.getLoginUser().getUserId();
            // 调用异步方法
            CompletableFuture<Integer> future = takaiAisService.uploadDocument(files, knowledgeId,ossList,updateBy);
            // 处理结果（非阻塞）
            future.whenComplete((successCount, ex) -> {
                if (ex != null) {
                    log.error("上传文档异步任务失败", ex);
                } else {
                    log.info("上传文档完成，成功处理{}个文件", successCount);
                    // 可触发后续逻辑，比如通知前端
                }
            });
            return success(1);
        } catch (Exception e) {
            return error("上传文档失败");
        }
    }

    /**
     * python文档解析回调接口
     *
     * @param params
     * @return
     * @throws Exception
     */
    @PostMapping("/updateDocumentByPython") //@RequestPart DocumentParams documentParams,
    public R<Void> updateDocumentByPython(@RequestBody JkDocumentPythonParams params){
        takaiAisService.updateDocumentByPython(params);
        return R.ok();
    }


    /**
     * 上传切片图片
     *
     * @param files
     * @param knowledgeId
     * @return
     * @throws Exception
     */
    @PostMapping("/uploadSliceImage/{knowledgeId}/{documentId}")
    public AjaxResult uploadSliceImage(@RequestParam("files") MultipartFile[] files,
                                     @PathVariable String knowledgeId,
                                     @PathVariable String documentId) throws Exception {
        try {
            List<TakaiSliceImage> originTextList = takaiAisService.uploadSliceImage(files, knowledgeId, documentId);
            return success(originTextList);
        } catch (Exception e) {
            return error(e.getMessage());
        }
    }

    /**
     * 获取知识配置信息
     *
     * @param documentId
     * @return
     */
    @GetMapping("/documentSetting/{documentId}")
    public AjaxResult documentSetting(@PathVariable String documentId) {
        TakaiDocumentSettings json = takaiAisService.documentSetting(documentId);
        return success(json);
    }

    /**
     * 更新知识配置详情
     *
     * @param documentSetting
     * @param documentId
     * @return
     */
    @PutMapping("/updateDocumentSetting/{documentId}")
    public AjaxResult updateDocumentSetting(@RequestBody TakaiDocumentSettings documentSetting, @PathVariable String documentId) {
        int i = takaiAisService.updateDocumentSetting(documentSetting, documentId); // 更新知识配置信息
        return success(i);
    }

    /**
     * 获取切片列表
     *
     * @param params
     * @return
     */
    @PostMapping("/getSliceList")
    public TableDataInfo getDialogDetail(@RequestBody TakaiSliceParams params) {
        PageHelper.startPage(params.getPageNum(), params.getPageSize(), "").setReasonable(true);
        List<TakaiSliceInfo> sliceList = takaiAisService.selectByDocumentId(params.getDocument_id(), params.getText());
        Page<TakaiSliceInfo> page = (Page<TakaiSliceInfo>) sliceList;
        return getDataTableResultTotal(sliceList, page.getTotal());
    }

    /**
     * 删除切片
     *
     * @param sliceId
     * @param knowledgeId
     */
    @DeleteMapping("/deleteSlice/{sliceId}/{knowledgeId}/{documentId}")
    public AjaxResult deleteSlice(@PathVariable String sliceId, @PathVariable String knowledgeId, @PathVariable String documentId) {
        return success(takaiAisService.deleteSlice(sliceId, knowledgeId, documentId));
    }

    /**
     * 切片详情
     *
     * @param sliceId
     * @param knowledgeId
     * @return
     */
    @GetMapping("/getSliceDetail/{sliceId}/{knowledgeId}")
    public AjaxResult test(@PathVariable String sliceId, @PathVariable String knowledgeId) {
        JSONObject json = takaiAisService.getSliceDetail(sliceId, knowledgeId);
        return success(json);
    }

    /**
     * 更新切片信息
     *
     * @param params
     * @return
     */
    @PutMapping("/updateSliceInfo")
    public AjaxResult updateSliceInfo(@RequestBody TakaiSliceUpdateParams params) {
        return success(takaiAisService.updateSliceInfo(params));
    }

    /**
     * 获取聊天列表
     *
     * @param params
     * @return
     */
    @PostMapping("/chatHistory/list")
    public TableDataInfo dataExportList(@RequestBody TakaiPageParams params) {
        LoginUser loginUser = SecurityUtils.getLoginUser();
        String userId = null;
        boolean isAdmin = false;
        if (loginUser != null) {
            userId = loginUser.getUserId();
            isAdmin = SecurityUtils.isAdmin(Long.valueOf(userId));
        }
        if(isAdmin) {
            userId = null;
        } else {
            userId = params.getUserId() == null ? userId : params.getUserId();
        }
        if (StringUtils.isNotBlank(params.getAppId())) {
            //获取应用聊天列表
            PageHelper.startPage(params.getPageNumber(), params.getPageSize(), "").setReasonable(true);
            List<TakaiDialogRespDTO> list = takaiAisService.selectDialogListByAppId(params.getAppId(), userId);
            List<Object> result = takaiAisService.setDialogList(list);
            Page<TakaiDialogRespDTO> page = (Page<TakaiDialogRespDTO>) list;
            return getDataTableResultTotal(result, page.getTotal());
        } else {
            //获取所有列表
            PageHelper.startPage(params.getPageNumber(), params.getPageSize(), "").setReasonable(true);
            List<TakaiDialogRespDTO> list = takaiAisService.selectDialogListByAppId(null, userId);
            List<Object> result = takaiAisService.setDialogList(list);
            Page<TakaiDialogRespDTO> page = (Page<TakaiDialogRespDTO>) list;
            return getDataTableResultTotal(result, page.getTotal());
        }
    }


    /**
     * 导出聊天记录
     *
     * @param response
     * @param id
     */
    @Log(title = "聊天详情", businessType = BusinessType.EXPORT)
    @PostMapping("/dialog/export/{id}")
    public void export(HttpServletResponse response, @PathVariable String id) {
        List<TakaiDialogRespDTO> dialogs = takaiAisService.exportExcel(id);
        ExcelUtil<TakaiDialogRespDTO> util = new ExcelUtil(TakaiDialogRespDTO.class);
        util.exportExcel(response, dialogs, "聊天记录");
    }


    /**
     * 应用列表
     *
     * @return
     */
    @GetMapping("/application/list")
    public AjaxResult applicationList() {
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if(loginUser != null){
            TakaiApplication vo = setFlagParams(loginUser.getUserId(), null, null, 3);
            List<TakaiApplicationResult> appList = takaiAisService.getApplicationList(vo);
            return success(appList);
        }else{
            TakaiApplication vo = setFlagParams(null, null, null, 3);
            List<TakaiApplicationResult> appList = takaiAisService.getApplicationList(vo);
            return success(appList);
        }
    }

    /**
     * 管理后台应用列表
     * @return
     */
    @GetMapping("/application/list/{userId}")
    public AjaxResult adminApp(@PathVariable String userId) {
        TakaiApplication vo = setFlagParams(userId, null, null, 3);
        List<TakaiApplicationResult> appList = takaiAisService.getApplicationList(vo);
        return success(appList);
    }

    @GetMapping("/role/list")
    public AjaxResult roleApp() {
        List<TakaiApplicationResult> appList = takaiAisService.selectRoleApp();
        return success(appList);
    }

    /**
     * 保存聊天记录
     *
     * @param dialogReqDTO
     * @return
     */
    @PostMapping("/dialog/save")
    public AjaxResult saveDialog(@RequestBody TakaiDialogReqDTO dialogReqDTO) {
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (loginUser != null) {
            dialogReqDTO.setUserId(loginUser.getUserId());
        }
        takaiAisService.saveDialog(dialogReqDTO);
        return success();
    }

    /**
     * 聊天集合
     *
     * @return
     */
    @GetMapping("/dialog/list/{appId}")
    public AjaxResult dialogList(@PathVariable String appId) {
        LoginUser loginUser = SecurityUtils.getLoginUser();
        String userId = null;
        if (loginUser != null) {
            userId = loginUser.getUserId();

        }
        List<Object> dialogs = takaiAisService.getDialogList(appId, userId);
        return success(dialogs);
    }

    /**
     * 聊天详情
     *
     * @param dialogId
     * @return
     */
    @GetMapping("/dialog/detail/{dialogId}")
    public AjaxResult dialogDetail(@PathVariable String dialogId) {
        List<TakaiDialogRespDTO> detail = takaiAisService.getDialogDetail(dialogId);
        return success(detail);
    }

    /**
     * 删除聊天记录
     *
     * @param id
     * @return
     */
    @DeleteMapping("/dialog/del/{id}")
    public AjaxResult delDialog(@PathVariable String id) {
        takaiAisService.DelDialogDetail(id);
        return success();
    }

    /**
     * 聊天标题重命名
     *
     * @param dialogReqDTO
     * @return
     */
    @PutMapping("/dialog/update")
    public AjaxResult updateDialog(@RequestBody TakaiDialogReqDTO dialogReqDTO) {
        takaiAisService.updateDialog(dialogReqDTO);
        return success();
    }

    /**
     * 预设问题
     *
     * @param appId
     * @return
     */
    @GetMapping("/presets/{appId}")
    public AjaxResult presets(@PathVariable String appId) {
        List<TakaiQuestionDTO> list = takaiAisService.selectQuestionByAppId(appId);
        List<String> strList = new ArrayList();
        for (TakaiQuestionDTO vo : list) {
            strList.add(vo.getQuestion());
        }
        return success(strList);
    }

    /**
     * 预设问题
     *
     * @param appId
     * @return
     */
    @GetMapping("/free/presets/{appId}")
    public AjaxResult freePresets(@PathVariable String appId) {
        return presets(appId);
    }

    /**
     * 新增切片
     *
     * @param params
     * @return
     */
    @PostMapping("/add/slice")
    public AjaxResult addSlice(@RequestBody TakaiSliceUpdateParams params) {
        return success(takaiAisService.addSlice(params));
    }

    /**
     * 获取聊天切片列表
     *
     * @param params
     * @return
     */
    @PostMapping("/slicePage")
    public TableDataInfo dataExportList(@RequestBody SlicePageInfo params) {
        DocumentInfo chunkInfo = params.getChunk_info();
        List<ChunkList> chunkList = chunkInfo.getChunk_list();
        // 1. 先按 rerank_score 降序排序所有chunk
        List<ChunkList> sortedChunks = chunkList.stream()
                .sorted(Comparator.comparingDouble(
                        (ChunkList s) -> Double.parseDouble(s.getRerank_score())
                ).reversed())
                .collect(Collectors.toList());

        // 2. 提取排序后的chunk_ids（此时已按分数排序）
        List<String> sortedChunkIds = sortedChunks.stream()
                .map(ChunkList::getChunk_id)
                .collect(Collectors.toList());

        int fromIndex = (params.getPageNum() - 1) * params.getPageSize();

        int toIndex = Math.min(fromIndex + params.getPageSize(), chunkList.size());

        List<String> ids = sortedChunkIds.subList(fromIndex, toIndex);

        PageHelper.startPage(params.getPageNum(), params.getPageSize(), "").setReasonable(true);
        List<SliceInfo> list = takaiAisService.slicePageInfoList(ids);
        list.forEach(sliceInfo -> {
            chunkList.forEach(chunk -> {
                if (sliceInfo.getSliceId().equals(chunk.getChunk_id())) {
                    sliceInfo.setRerankScore(chunk.getRerank_score());
                    sliceInfo.setChunkLength(chunk.getChunk_len());
                }
            });
        });
        List<SliceInfo> sliceList = list.stream()
                .sorted(Comparator.comparingDouble((SliceInfo s) -> Double.parseDouble(s.getRerankScore())).reversed())
                .collect(Collectors.toList());
        return getDataTableResultTotal(sliceList, sortedChunkIds.size());
    }

    /**
     * 获取聊天切片列表
     *
     * @param params
     * @return
     */
    @PostMapping("/free/slicePage")
    public TableDataInfo freeDataExportList(@RequestBody SlicePageInfo params) {
        return dataExportList(params);
    }

    @GetMapping("/slice/search/{id}")
    public AjaxResult searchSlice(@PathVariable String id) {
        return success(takaiAisService.searchSlice(id));
    }

    @GetMapping("/free/slice/search/{id}")
    public AjaxResult freeSearchSlice(@PathVariable String id) {
        return searchSlice(id);
    }

    /**
     *
     * 类型列表
     * @param dictType
     * @return
     */
    @GetMapping(value = "/{dictType}")
    public AjaxResult geDictInfo(@PathVariable String dictType) {
        SysDictData dictData = new SysDictData();
        dictData.setDictType(dictType);
        List<SysDictData> dictDataList = dictDataService.selectDictDataList(dictData);
        return success(dictDataList);
    }

    /**
     *
     * 类型列表
     * @param
     * @return
     */
    @GetMapping(value = "/projectTree")
    public AjaxResult getPorjectTree() {
        SysDictData dictData = new SysDictData();
        dictData.setDictType("project_type");
        List<SysDictData> dictDataList = dictDataService.selectDictDataList(dictData);
        List<SysProject> projectList = sysProjectService.selectSysProjectList(null);
        logger.info("getPorjectTree:projectList:"+projectList.size());
        List<TreeStruct> projectTreeList = new ArrayList<>();
        for(SysDictData dict : dictDataList) {
            logger.info("getPorjectTree:dict:"+dict);
            String clientId;
            if(ProjectTypeEnum.HJL.getCode().equals(String.valueOf(dict.getDictValue()))) {
                clientId = ProjectTypeEnum.HJL.getClientId();
            } else if (ProjectTypeEnum.HXG.getCode().equals(String.valueOf(dict.getDictValue()))) {
                clientId = ProjectTypeEnum.HXG.getClientId();
            } else {
                clientId = "";
            }
            logger.info("getPorjectTree:clientId:"+clientId);
            TreeStruct projectType = new TreeStruct();
            projectType.setValue(clientId);
            projectType.setLabel(dict.getDictLabel());
            List<SysProject> filteredProjects = projectList.stream()
                    .filter(project -> clientId.equals(project.getSourceFrom()))
                    .collect(Collectors.toList());

            List<TreeStruct> children = new ArrayList<>();
            for(SysProject project : filteredProjects) {
                TreeStruct child = new TreeStruct();
                child.setValue(String.valueOf(project.getProjectId()));
                child.setLabel(project.getProjectName());
                children.add(child);
            }
            projectType.setChildren(children);
            projectTreeList.add(projectType);
        }


        return success(projectTreeList);
    }

    /**
     * 应用类型列表
     * @return
     */
    @GetMapping("/appType")
    public AjaxResult appType() {
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (loginUser != null) {
            SysDictData dictData = new SysDictData();
            dictData.setDictType("app_type");
            List<SysDictData> dictDataList = dictDataService.selectDictDataList(dictData);
            List<Object> list = takaiAisService.searchAppTypeGroupList(dictDataList, loginUser.getUserId());
            return success(list);
        } else {
            throw new ServiceException("获取用户信息异常", HttpStatus.UNAUTHORIZED);
        }
//        return null;
    }

    /**
     * 审核列表
     * @param params
     * @return
     */
    @PostMapping("/app/audit/list")
    public TableDataInfo documentAuditList(@RequestBody TakaiApplicationParams params) {
        startPage();
        List<TakaiApplication> list = takaiAisService.applicationListByApprover(params);
        return getDataTable(list);
    }

    /**
     * 开始审核
     * @return
     */
    @PutMapping(value = "/audit/{appId}/{userId}")
    public AjaxResult startAudit(@PathVariable String appId, @PathVariable String userId){
        return success(takaiAisService.startAudit(appId, userId));
    }

    /**
     * 审核
     * @param params
     * @param appId
     * @return
     */
    @PutMapping("/updateDocumentAudit/{appId}")
    public AjaxResult updateAuditApplication(@RequestBody TakaiApplicationParams params, @PathVariable String appId) {
        int i = takaiAisService.updateAuditApplication(params, appId);
        return success(i);
    }

    /**
     * 根据登录用户获取项目下的应用列表
     * @return
     */
    @GetMapping("/project/app")//@RequestBody TakaiPageParams params
    public AjaxResult appFlag() {
//        TakaiApplication vo = setFlagParams(params.getUserId());
//        vo.setApprover(params.getUserId());
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if(loginUser != null){
            TakaiApplication vo = setFlagParams(loginUser.getUserId(), null, null, 1);
            List<TakaiApplicationResult> s = takaiAisService.getApplicationList(vo);
            return success(takaiAisService.getChatAppList(s, loginUser.getUserId()));
        }else{
            return success(null);
        }
    }

    /**
     * 收藏列表
     * @param userId
     * @return
     */
    @GetMapping("/app/collect/list/{userId}")
    public AjaxResult appCollectList(@PathVariable String userId) {
        List<String> list = takaiAisService.selectAppCollectList(userId);
        return success(list);
    }

    /**
     * 收藏
     * @param appCollect
     * @return
     */
    @PostMapping("/app/collect")
    public AjaxResult appCollect(@RequestBody AppCollect appCollect) {
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if(loginUser != null){
            appCollect.setUserId(loginUser.getUserId());
            return success(takaiAisService.insertAppCollect(appCollect));
        }else {
            return success(null);
        }
    }

    /**
     * 取消收藏
     * @param appId
     * @return
     */
    @DeleteMapping("/app/collect/{appId}")
    public AjaxResult appCollectDel(@PathVariable String appId) {
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if(loginUser != null){
            return success(takaiAisService.deleteAppCollect(loginUser.getUserId(), appId));
        }else{
            return success(null);
        }
    }



    private TakaiApplication setFlagParams(String userId, String typeId, String projectId, int i) {
        if(i == 3){
            return returnParams(userId, typeId, projectId, "0");
        }else{
            // 角色集合
            SysUser user = new SysUser();
            user.setUserId(userId);
            Set<String> permissions = permissionService.getMenuPermission(user);
            if (permissions.contains("deepseek:application:create") || permissions.contains("deepseek:application:update")) {
                return returnParams(userId, typeId, projectId, "1");
            }else{
                return returnParams(userId, typeId, projectId, "0");
            }
        }
    }

    private TakaiApplication returnParams(String userId, String typeId, String projectId, String flag) {
        return TakaiApplication.builder().approver(userId == null ? null : userId)
                .typeId(typeId == null ? null : Long.valueOf(typeId))
                .projectId(projectId == null ? null : projectId)
                .flag(flag).build();
    }

    @GetMapping("/test")
    public AjaxResult test() {
        TakaiMediaReplacement vo = takaiAisService.getTakaiMediaReplacement();
        return success(vo);
    }


    @GetMapping("/download/{fileName}")
    public void downloadFile(@PathVariable String fileName) {
        try {
//            InputStream stream = minioUtil.download(bucketName, fileName);
            // 这里简化处理，实际应该设置正确的Content-Type和Content-Disposition
//            return ResponseEntity.ok()
//                    .header("Content-Type", "application/octet-stream")
//                    .header("Content-Disposition", "attachment; filename=\"" + fileName + "\"")
//                    .body(stream);
        } catch (Exception e) {
            logger.error("文件下载失败: " + e.getMessage());
        }
    }

    @DeleteMapping("/delete/{fileName}")
    public void deleteFile(@PathVariable String fileName) {
        try {
//            minioUtil.remove(bucketName, fileName);
        } catch (Exception e) {
            logger.error("文件删除失败: " + e.getMessage());
        }
    }

}