package com.hotent.enterpriseDeclare.controller.material;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.hotent.base.annotation.ApiGroup;
import com.hotent.base.constants.ApiGroupConsts;
import com.hotent.base.controller.BaseController;
import com.hotent.base.model.CommonResult;
import com.hotent.base.util.StringUtil;
import com.hotent.project.manager.CostProjectTaskManager;
import com.hotent.project.manager.CostProjectTaskMaterialSummaryDetailManager;
import com.hotent.project.manager.CostProjectTaskMaterialSummaryManager;
import com.hotent.project.model.CostProjectTask;
import com.hotent.project.model.CostProjectTaskMaterialSummary;
import com.hotent.project.model.CostProjectTaskMaterialSummaryDetail;
import com.hotent.project.req.MaterialSummarySortReq;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 资料归纳主表 前端控制器
 *
 * @company 山西清众科技股份有限公司
 * @author 超级管理员
 * @since 2025-01-27
 */
@RestController
@RequestMapping("/api/materialSummary/v1")
@Api(tags = "资料归纳主表")
@ApiGroup(group = {ApiGroupConsts.GROUP_COST})
public class CostProjectTaskMaterialSummaryController extends BaseController<CostProjectTaskMaterialSummaryManager, CostProjectTaskMaterialSummary> {


    @Autowired
    private CostProjectTaskManager costProjectTaskManager;

    @Autowired
    private CostProjectTaskMaterialSummaryDetailManager costProjectTaskMaterialSummaryDetailManager;

    /**
     * 根据taskId获取资料归纳列表
     * @param taskId 任务ID
     * @return 资料归纳列表（包含明细）
     */
    @GetMapping(value = "/listByTaskId")
    @ApiOperation(value = "根据taskId获取资料归纳列表", httpMethod = "GET", notes = "根据taskId获取资料归纳列表（包含明细）")
    @Transactional
    public CommonResult<List<CostProjectTaskMaterialSummary>> listByTaskId(
            @ApiParam(name = "taskId", value = "任务ID", required = true)
            @RequestParam(required = true) String taskId) {

        List<CostProjectTaskMaterialSummary> summaryList = baseService.listByTaskId(taskId);
        // 如果为空，自动生成13个基础资料类别
        if (summaryList == null || summaryList.isEmpty()) {
            // 获取任务信息
            com.hotent.project.model.CostProjectTask mainTask = costProjectTaskManager.getById(taskId);
            if (mainTask != null) {
                // 查询子任务列表
                List<CostProjectTask> childTasks = costProjectTaskManager.list(
                        new LambdaQueryWrapper<CostProjectTask>().eq(CostProjectTask::getPid, taskId)
                );
                // 同步生成资料归纳
                asyncMaterialSummaryService.generateMaterialSummary(mainTask, childTasks);
                asyncMaterialSummaryService.calculatePageCountAsync(mainTask.getId());
                // 重新查询
                summaryList = baseService.listByTaskId(taskId);
            }
        }

        return CommonResult.<List<CostProjectTaskMaterialSummary>>ok().value(summaryList);
    }

    @GetMapping(value = "/DetailistlByMasterId")
    @ApiOperation(value = "根据taskId获取资料归纳列表", httpMethod = "GET", notes = "根据taskId获取资料归纳列表（包含明细）")
    @Transactional
    public CommonResult<List<CostProjectTaskMaterialSummaryDetail>> listByMasetId(
            @ApiParam(name = "masterId", value = "主文件夹ID", required = true)
            @RequestParam(required = true) String masterId) {

        List<CostProjectTaskMaterialSummaryDetail> list = costProjectTaskMaterialSummaryDetailManager.list(
                new LambdaQueryWrapper<CostProjectTaskMaterialSummaryDetail>()
                        .eq(CostProjectTaskMaterialSummaryDetail::getMasterId, masterId)
        );
        return CommonResult.<List<CostProjectTaskMaterialSummaryDetail>>ok().value(list);
    }

    /**
     * 根据id获取资料归纳详情
     * @param id 主表ID
     * @return 资料归纳详情（包含明细）
     */
    @GetMapping(value = "/getDetail")
    @ApiOperation(value = "根据id获取资料归纳详情", httpMethod = "GET", notes = "根据id获取资料归纳详情（包含明细）")
    public CommonResult<CostProjectTaskMaterialSummary> getDetail(
            @ApiParam(name = "id", value = "主表ID", required = true)
            @RequestParam(required = true) String id) {
        return CommonResult.<CostProjectTaskMaterialSummary>ok().value(baseService.getDetail(id));
    }

    /**
     * 新增、更新资料归纳主表
     * @param summary 资料归纳主表
     * @return
     */
    @PostMapping(value = "/save")
    @ApiOperation(value = "新增、更新资料归纳主表", httpMethod = "POST", notes = "新增、更新资料归纳主表")
    @Transactional
    public CommonResult<String> save(
            @ApiParam(name = "summary", value = "资料归纳主表", required = true)
            @RequestBody CostProjectTaskMaterialSummary summary) {
        String msg = StringUtil.isEmpty(summary.getId()) ? "添加资料归纳成功" : "更新资料归纳成功";
        baseService.createOrUpdate(summary);
        return CommonResult.<String>ok().message(msg);
    }

    /**
     * 新增、更新资料归纳子表
     * @return
     */
    @PostMapping(value = "/saveDetail")
    @ApiOperation(value = "新增、更新资料归纳子表", httpMethod = "POST", notes = "新增、更新资料归纳主表")
    @Transactional
    public CommonResult<String> saveDetail(
            @ApiParam(name = "summary", value = "资料归纳主表", required = true)
            @RequestBody CostProjectTaskMaterialSummaryDetail detail) {
        if (detail.getMasterId()==null){
            return CommonResult.<String>error().message("请选择资料归纳");
        }
        CostProjectTaskMaterialSummary summary = baseService.getById(detail.getMasterId());
        if (summary==null){
            return CommonResult.<String>error().message("请选择资料归纳");
        }
        detail.setTaskId(summary.getTaskId());

        // 如果有附件URL，自动解析文件页数
        if (StringUtil.isNotEmpty(detail.getAttachmentUrl())) {
            try {
                int pageCount = asyncMaterialSummaryService.calculateFilePageCount(detail.getAttachmentUrl());
                detail.setPageCount(pageCount);
            } catch (Exception e) {
                System.err.println("解析文件页数失败：" + e.getMessage());
            }
        }

        String msg = StringUtil.isEmpty(detail.getId()) ? "添加资料归纳成功" : "更新资料归纳成功";
        if (detail.getId()==null){
            detail.setCreateTime(LocalDateTime.now());
        }
        detail.setUpdateTime(LocalDateTime.now());
        costProjectTaskMaterialSummaryDetailManager.createOrUpdate(detail);

        // 保存明细后，更新主表的总页数
        try {
            asyncMaterialSummaryService.updateMasterTotalPageCount(detail.getMasterId());
        } catch (Exception e) {
            System.err.println("更新主表总页数失败：" + e.getMessage());
            // 更新失败不影响返回结果
        }

        return CommonResult.<String>ok().message(msg);
    }



    /**
     * 删除资料归纳明细
     * @param id 明细ID
     * @return
     */
    @DeleteMapping(value = "/deleteDetail")
    @ApiOperation(value = "删除资料归纳明细", httpMethod = "DELETE", notes = "删除资料归纳明细并同步更新主表总页数")
    @Transactional
    public CommonResult<String> deleteDetail(
            @ApiParam(name = "id", value = "明细ID", required = true)
            @RequestParam(required = true) String id) {

        // 先查询明细信息，获取主表ID
        CostProjectTaskMaterialSummaryDetail detail = costProjectTaskMaterialSummaryDetailManager.getById(id);
        if (detail == null) {
            return CommonResult.<String>error().message("资料归纳明细不存在");
        }

        String masterId = detail.getMasterId();

        // 删除明细（物理删除）
        costProjectTaskMaterialSummaryDetailManager.deleteById(id);

        // 删除后，更新主表的总页数
        try {
            if (StringUtil.isNotEmpty(masterId)) {
                asyncMaterialSummaryService.updateMasterTotalPageCount(masterId);
            }
        } catch (Exception e) {
            System.err.println("更新主表总页数失败：" + e.getMessage());
            // 更新失败不影响删除结果
        }

        return CommonResult.<String>ok().message("删除资料归纳明细成功");
    }

    /**
     * 批量保存资料归纳（主表+明细）
     * @param summary 资料归纳主表（包含detailList）
     * @return
     */
    @PostMapping(value = "/saveWithDetails")
    @ApiOperation(value = "批量保存资料归纳（主表+明细）", httpMethod = "POST", notes = "批量保存资料归纳（主表+明细）")
    @Transactional
    public CommonResult<String> saveWithDetails(
            @ApiParam(name = "summary", value = "资料归纳主表（包含detailList）", required = true)
            @RequestBody CostProjectTaskMaterialSummary summary) {
        String msg = StringUtil.isEmpty(summary.getId()) ? "保存资料归纳成功" : "更新资料归纳成功";
        baseService.saveWithDetails(summary);
        return CommonResult.<String>ok().message(msg);
    }

    /**
     * 删除资料归纳（级联删除明细）
     * @param id 主表ID
     * @return
     */
    @DeleteMapping(value = "/delete")
    @ApiOperation(value = "删除资料归纳", httpMethod = "DELETE", notes = "删除资料归纳（级联删除明细）")
    @Transactional
    public CommonResult<String> delete(
            @ApiParam(name = "id", value = "主表ID", required = true)
            @RequestParam(required = true) String id) {
        baseService.deleteById(id);
        return CommonResult.<String>ok().message("删除资料归纳成功");
    }

    /**
     * 资料排序
     * @param req 排序请求
     * @return
     */
    @PostMapping(value = "/sort")
    @ApiOperation(value = "资料排序", httpMethod = "POST", notes = "资料排序（上移/下移）")
    @Transactional
    public CommonResult<String> sort(
            @ApiParam(name = "req", value = "排序请求", required = true)
            @RequestBody MaterialSummarySortReq req) {
        if (StringUtil.isEmpty(req.getId()) || StringUtil.isEmpty(req.getDirection())) {
            return CommonResult.<String>error().message("ID和排序方向不能为空");
        }
        baseService.sort(req.getId(), req.getDirection());
        return CommonResult.<String>ok().message("排序成功");
    }

    @Autowired
    private com.hotent.project.service.AsyncMaterialSummaryService asyncMaterialSummaryService;

    /**
     * 档案校对通过，触发异步生成Word卷宗
     * @param taskId 任务ID
     * @return
     */
    @PostMapping(value = "/approveArchive")
    @ApiOperation(value = "档案校对通过", httpMethod = "POST", notes = "档案校对通过后，异步生成Word卷宗")
    public CommonResult<String> approveArchive(
            @ApiParam(name = "taskId", value = "任务ID", required = true)
            @RequestParam(required = true) String taskId) {

        // 校验任务是否存在资料归纳数据
        List<CostProjectTaskMaterialSummary> summaryList = baseService.listByTaskId(taskId);
        if (summaryList == null || summaryList.isEmpty()) {
            return CommonResult.<String>error().message("该任务没有资料归纳数据，无法校对");
        }

        // 校验所有资料是否都已上传附件
        boolean allHasAttachment = true;
        for (CostProjectTaskMaterialSummary summary : summaryList) {
            if (summary.getDetailList() != null) {
                for (com.hotent.project.model.CostProjectTaskMaterialSummaryDetail detail : summary.getDetailList()) {
                    if (StringUtil.isEmpty(detail.getAttachmentUrl())) {
                        allHasAttachment = false;
                        break;
                    }
                }
            }
            if (!allHasAttachment) {
                break;
            }
        }

        if (!allHasAttachment) {
            return CommonResult.<String>error().message("部分资料未上传附件，请完善后再进行校对");
        }

        // 异步生成Word卷宗
        asyncMaterialSummaryService.generateWordArchiveAsync(taskId);

        return CommonResult.<String>ok().message("档案校对通过，正在后台生成Word卷宗，请稍后查看");
    }

    /**
     * 查询Word卷宗生成状态
     * @param taskId 任务ID
     * @return
     */
    @GetMapping(value = "/getArchiveStatus")
    @ApiOperation(value = "查询Word卷宗生成状态", httpMethod = "GET", notes = "查询Word卷宗生成状态")
    public CommonResult<String> getArchiveStatus(
            @ApiParam(name = "taskId", value = "任务ID", required = true)
            @RequestParam(required = true) String taskId) {
        // TODO: 实现查询卷宗生成状态的逻辑
        // 可以在数据库中添加一个状态字段来记录生成进度
        return CommonResult.<String>ok().value("生成中").message("查询成功");
    }
}