package com.hotent.enterpriseDeclare.controller.opinion;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.hotent.base.annotation.ApiGroup;
import com.hotent.base.constants.ApiGroupConsts;
import com.hotent.base.model.CommonResult;
import com.hotent.base.util.StringUtil;
import com.hotent.enterpriseDeclare.manager.CostAuditPeriodRecordManager;
import com.hotent.enterpriseDeclare.manager.CostSurveyTemplateUploadDataManager;
import com.hotent.enterpriseDeclare.model.CostAuditPeriodRecord;
import com.hotent.enterpriseDeclare.model.CostSurveyTemplateUploadData;
import com.hotent.project.manager.CostProjectApprovalManager;
import com.hotent.project.manager.CostProjectTaskManager;
import com.hotent.project.model.CostProjectApproval;
import com.hotent.project.model.CostProjectTask;
import com.hotent.project.resp.CostProjectApprovalDetailResp;
import com.hotent.surveyinfo.dao.CostSurveyTemplateItemsDao;
import com.hotent.surveyinfo.manager.CostSurveyTemplateHeadersManager;
import com.hotent.surveyinfo.manager.CostSurveyTemplateManager;
import com.hotent.surveyinfo.manager.CostSurveyTemplateUploadManager;
import com.hotent.surveyinfo.manager.CostSurveyTemplateVersionManager;
import com.hotent.surveyinfo.model.CostSurveyTemplateHeaders;
import com.hotent.surveyinfo.model.CostSurveyTemplateItems;
import com.hotent.surveyinfo.model.CostSurveyTemplateUpload;
import com.hotent.surveyinfo.model.CostSurveyTemplateVersion;
import com.hotent.surveyinfo.model.dto.CostItemData;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

@Api(tags = "成本监审任务填报")
@RestController
@RequestMapping("/api/enterprise/castTaskInfo")
@ApiGroup(group = {ApiGroupConsts.GROUP_COST})
public class CostAuditTaskInfoController {


    @Autowired
    private CostSurveyTemplateUploadManager costSurveyTemplateUploadManager;

    @Autowired
    private CostSurveyTemplateItemsDao costSurveyTemplateItemsDao;

    @Autowired
    private CostSurveyTemplateVersionManager costSurveyTemplateVersionManager;

    @Autowired
    private CostSurveyTemplateHeadersManager costSurveyTemplateHeadersManager;

    @Autowired
    private CostSurveyTemplateUploadDataManager costSurveyTemplateUploadDataManager;

    @Autowired
    private CostAuditPeriodRecordManager costAuditPeriodRecordManager;

    @Autowired
    private CostSurveyTemplateManager costSurveyTemplateManager;

    @Autowired
    private CostProjectApprovalManager costProjectApprovalManager;

    @Autowired
    private CostProjectTaskManager costProjectTaskManager;
    /**
     * 企业报送-成本调查表-列表
     * @param taskId 任务ID
     * @return 上传记录列表（包含是否必填、是否上传等信息）
     * @throws Exception
     */
    @GetMapping(value="/listByTaskId")
    public CommonResult<List<CostSurveyTemplateUpload>> listByTaskId(
            @RequestParam(required = false) String taskId,
            @RequestParam(required = false) String catalogId
            ) throws Exception {
        List<CostSurveyTemplateUpload> uploadList = costSurveyTemplateUploadManager.listByTaskId(taskId);
        //创建记录
        if (uploadList.isEmpty()){
            List<CostSurveyTemplateUpload> costSurveyTemplateUploads = costSurveyTemplateUploadManager.listByCatalogId(catalogId);
            for (CostSurveyTemplateUpload costSurveyTemplateUpload : costSurveyTemplateUploads) {
                CostSurveyTemplateUpload upload = new CostSurveyTemplateUpload();
                BeanUtils.copyProperties(costSurveyTemplateUpload, upload);
                upload.setId(null);
                upload.setTaskId(taskId);
                upload.setIsUpload("0");
                costSurveyTemplateUploadManager.save(upload);
            }
        }
        return CommonResult.<List<CostSurveyTemplateUpload>>ok().value( costSurveyTemplateUploadManager.listByTaskId(taskId));
    }

    /**
     * 企业报送-成本调查表-在线填报所需字段
     * @param surveyTemplateId 成本调查表id
     * @return 指标项数据列表（带key-value拼接）
     */
    @GetMapping(value = "/listItemsByCurrentTemplateId")
    @ApiOperation(value = "根据成本调查表现行模板id获取所有指标数据", httpMethod = "GET", notes = "根据成本调查表现行模板id获取所有指标数据（带key-value拼接）")
    public CommonResult<CostItemData> listItemsByCurrentTemplateId(
            @ApiParam(name = "surveyTemplateId", value = "关联的成本调查表ID", required = true)
            @RequestParam(required = true) String surveyTemplateId) throws Exception
    {

        //根据模板id 查询历史版本是现行的版本信息
        CostSurveyTemplateVersion versiontemplate = costSurveyTemplateVersionManager.selectCurrentVersion(surveyTemplateId);
        if (versiontemplate == null) {
            return CommonResult.<CostItemData>ok().value(new CostItemData());
        }

        List<CostSurveyTemplateItems> items = costSurveyTemplateItemsDao.selectBySurveyTemplateIdAndVersion(surveyTemplateId, versiontemplate.getId());
        List<CostSurveyTemplateHeaders> headlist = costSurveyTemplateHeadersManager.listVisibleBySurveyTemplateIdAndVersion(surveyTemplateId, versiontemplate.getId());
        String filename = headlist.stream().map(CostSurveyTemplateHeaders::getFieldName).collect(Collectors.joining(","));
        String filenids = headlist.stream().map(CostSurveyTemplateHeaders::getId).collect(Collectors.joining(","));

        // 按 orderNum 分组
        Map<Integer, List<CostSurveyTemplateItems>> groupedByHeadersId = items.stream()
                .collect(Collectors.groupingBy(CostSurveyTemplateItems::getOrderNum));

        List<Map<String, String>> result = new ArrayList<>();

        for (Map.Entry<Integer, List<CostSurveyTemplateItems>> entry : groupedByHeadersId.entrySet()) {
            List<CostSurveyTemplateItems> group = entry.getValue();
            if (group.isEmpty()) continue;

            // 主项（可以取第一个）
            CostSurveyTemplateItems mainItem = group.get(0);

            String headersIds = "";
            String itemIds = "";
            // 构造 key-value 映射
            Map<String, String> keyValueMap = new HashMap<>();
            for (CostSurveyTemplateItems item : group) {
                if (item.getRkey() != null && item.getRvalue() != null) {
                    keyValueMap.put(item.getRkey(), item.getRvalue());
                    headersIds += item.getHeadersId() + ",";
                    itemIds += item.getId() + ",";
                }
            }
            if (!StringUtil.isEmpty(headersIds))
                headersIds = headersIds.substring(0, headersIds.length() - 1);

            if (!StringUtil.isEmpty(itemIds))
                itemIds = itemIds.substring(0, itemIds.length() - 1);

            //mainItem 放入到keyValueMap中 除了 key value 这两个字段
            keyValueMap.put("id", mainItem.getId());
            keyValueMap.put("surveyTemplateId", mainItem.getSurveyTemplateId());
            keyValueMap.put("versionId", mainItem.getVersionId());
            keyValueMap.put("headersId", mainItem.getHeadersId());
            keyValueMap.put("cellCode", mainItem.getCellCode());
            keyValueMap.put("calculationFormula", mainItem.getCalculationFormula());
            keyValueMap.put("unit", mainItem.getUnit());
            keyValueMap.put("orderNum", mainItem.getOrderNum().toString());
            keyValueMap.put("jsonStr", mainItem.getJsonStr());
            keyValueMap.put("headersIds", headersIds);
            keyValueMap.put("itemIds", itemIds);
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            keyValueMap.put("createTime", mainItem.getCreateTime() != null ? mainItem.getCreateTime().format(formatter) : null);
            keyValueMap.put("updateTime", mainItem.getUpdateTime() != null ? mainItem.getUpdateTime().format(formatter) : null);
            keyValueMap.put("createBy", mainItem.getCreateBy());
            keyValueMap.put("updateBy", mainItem.getUpdateBy());
            keyValueMap.put("projectId", mainItem.getProjectId());
            keyValueMap.put("orderText", mainItem.getOrderText());
            keyValueMap.put("calculationTemplateId", mainItem.getCalculationTemplateId());
            keyValueMap.put("rowid", mainItem.getRowid());
            keyValueMap.put("parentid", mainItem.getParentid());

            result.add(keyValueMap);
        }
        CostItemData data = new CostItemData();
        data.setFixedFields(filename); // 存储动态字段名
        data.setItemlist(result);
        data.setFixedFieldids(filenids);
        return CommonResult.<CostItemData>ok().value(data);
    }

    /**
     * 企业报送-成本调查表-在线填报保持
     * @param dataList 数据列表（实体类列表，包含uploadId、auditedUnitId、rowid、rkey、rvalue等字段）
     * @return 保存结果
     */
    @PostMapping(value = "/saveUploadData")
    @ApiOperation(value = "保存成本调查表模板上传数据", httpMethod = "POST", notes = "保存成本调查表模板上传数据，直接使用实体类列表。固定表和单记录直接保存，动态表需要先创建监审期间记录")
    public CommonResult<String> saveUploadData(
            @ApiParam(name = "dataList", value = "数据列表", required = true)
            @RequestBody List<CostSurveyTemplateUploadData> dataList) throws Exception {

        if (dataList == null || dataList.isEmpty()) {
            return CommonResult.<String>error().message("数据列表不能为空");
        }

        // 从第一条数据中提取信息
        CostSurveyTemplateUploadData firstData = dataList.get(0);
        String uploadId = firstData.getUploadId();
        String surveyTemplateId = firstData.getSurveyTemplateId();
        
        // 判断模板类型
        String templateType = null;
        if (StringUtil.isNotEmpty(surveyTemplateId)) {
            com.hotent.surveyinfo.model.CostSurveyTemplate template = costSurveyTemplateManager.getDetail(surveyTemplateId);
            if (template != null) {
                templateType = template.getTemplateType();
            }
        } else if (StringUtil.isNotEmpty(uploadId)) {
            CostSurveyTemplateUpload upload = costSurveyTemplateUploadManager.get(uploadId);
            if (upload != null && StringUtil.isNotEmpty(upload.getSurveyTemplateId())) {
                com.hotent.surveyinfo.model.CostSurveyTemplate template = costSurveyTemplateManager.getDetail(upload.getSurveyTemplateId());
                if (template != null) {
                    templateType = template.getTemplateType();
                }
            }
        }

        // 如果是动态表(3)，需要检查periodRecordId
        if ("3".equals(templateType)) {
            String periodRecordId = firstData.getPeriodRecordId();
            if (StringUtil.isEmpty(periodRecordId)) {
                return CommonResult.<String>error().message("动态表需要先创建监审期间记录，periodRecordId不能为空");
            }
        }

        costSurveyTemplateUploadDataManager.saveData(dataList);
        return CommonResult.<String>ok().message("保存数据成功");
    }

    /**
     * 企业报送-成本调查表-在线填报记录查看
     * @param queryData 查询条件（实体类，包含uploadId和auditedUnitId）
     * @return 数据列表（实体类列表）
     */
    @PostMapping(value = "/getUploadData")
    @ApiOperation(value = "查询成本调查表模板上传数据", httpMethod = "POST", notes = "查询成本调查表模板上传数据，返回实体类列表")
    public CommonResult<List<CostSurveyTemplateUploadData>> getUploadData(
            @ApiParam(name = "queryData", value = "查询条件", required = true)
            @RequestBody CostSurveyTemplateUploadData queryData) throws Exception {

        if (queryData == null || StringUtil.isEmpty(queryData.getUploadId()) || StringUtil.isEmpty(queryData.getAuditedUnitId())) {
            return CommonResult.<List<CostSurveyTemplateUploadData>>error().message("uploadId和auditedUnitId不能为空");
        }

        List<CostSurveyTemplateUploadData> dataList = costSurveyTemplateUploadDataManager.
                listByUploadIdAndAuditedUnitId(queryData.getUploadId(),queryData.getPeriodRecordId());
        return CommonResult.<List<CostSurveyTemplateUploadData>>ok().value(dataList);
    }

    /**
     * 企业报送-成本调查表-动态表-新增监审期间记录
     * @return 保存结果
     */
    @PostMapping(value = "/addPeriodRecord")
    @ApiOperation(value = "新增监审期间记录（动态表使用）", httpMethod = "POST", notes = "新增监审期间记录，用于动态表。必须先创建监审期间记录，然后才能编辑保存数据")
    public CommonResult<CostAuditPeriodRecord> addPeriodRecord(
            @ApiParam(name = "record", value = "监审期间记录", required = true)
            @RequestBody CostAuditPeriodRecord record) throws Exception {

        if (record == null) {
            return CommonResult.<CostAuditPeriodRecord>error().message("记录不能为空");
        }

        if (StringUtil.isEmpty(record.getAuditedUnitId())) {
            return CommonResult.<CostAuditPeriodRecord>error().message("auditedUnitId不能为空");
        }

        if (StringUtil.isEmpty(record.getAuditPeriod())) {
            return CommonResult.<CostAuditPeriodRecord>error().message("auditPeriod不能为空");
        }
        // 校验

        CostProjectTask task = costProjectTaskManager.getById(record.getTaskId());
        CostProjectApproval approval = costProjectApprovalManager.getById(task.getProjectId());
        if (approval == null) {
            return CommonResult.<CostAuditPeriodRecord>error().message("项目不存在");
        }
        if(!Arrays.asList(approval.getAuditPeriod().split( ",")).contains(record.getAuditPeriod())){
            return CommonResult.<CostAuditPeriodRecord>error().message("项目所属监审期间不存在");
        }
        // 如果已有的也不能添加
        CostAuditPeriodRecord existRecord = costAuditPeriodRecordManager.getOne(
                new QueryWrapper<CostAuditPeriodRecord>()
                        .eq("task_id", record.getTaskId())
                        .eq("audit_period", record.getAuditPeriod())
        );
        if (existRecord != null) {
            return CommonResult.<CostAuditPeriodRecord>error().message("项目所属监审期间已存在");
        }

        // 如果没有 uploadId，需要先创建主表
        String uploadId = record.getUploadId();
        if (StringUtil.isEmpty(uploadId)) {
            String catalogId = record.getCatalogId();
            String surveyTemplateId = record.getSurveyTemplateId();
            
            if (StringUtil.isEmpty(catalogId) || StringUtil.isEmpty(surveyTemplateId)) {
                return CommonResult.<CostAuditPeriodRecord>error().message("uploadId为空时，catalogId和surveyTemplateId不能为空");
            }

            // 创建主表记录
            CostSurveyTemplateUpload upload = new CostSurveyTemplateUpload();
            upload.setCatalogId(catalogId);
            upload.setSurveyTemplateId(surveyTemplateId);
            upload.setIsRequired("1");
            upload.setIsDeleted("0");
            upload.setOrderNum(0);
            upload.setTaskId(record.getTaskId());
            costSurveyTemplateUploadManager.save(upload);
            uploadId = upload.getId();
            record.setUploadId(uploadId);
        }

        // 设置填报时间为当前时间
        if (record.getReportingTime() == null) {
            record.setReportingTime(java.time.LocalDateTime.now());
        }

        costAuditPeriodRecordManager.createOrUpdate(record);
        return CommonResult.<CostAuditPeriodRecord>ok().value(record).message("新增监审期间记录成功");
    }

    /**
     * 企业报送-成本调查表-动态表-查询监审期间记录列表
     * @param queryData 查询条件（包含uploadId和auditedUnitId）
     * @return 记录列表
     */
    @PostMapping(value = "/listPeriodRecord")
    @ApiOperation(value = "查询监审期间记录列表（动态表使用）", httpMethod = "POST", notes = "查询监审期间记录列表，返回记录列表")
    public CommonResult<List<CostAuditPeriodRecord>> listPeriodRecord(
            @ApiParam(name = "queryData", value = "查询条件", required = true)
            @RequestBody CostAuditPeriodRecord queryData) throws Exception {

        if (queryData == null || StringUtil.isEmpty(queryData.getUploadId()) || StringUtil.isEmpty(queryData.getAuditedUnitId())) {
            return CommonResult.<List<CostAuditPeriodRecord>>ok().message(null);
        }

        List<CostAuditPeriodRecord> recordList = costAuditPeriodRecordManager.listByUploadIdAndAuditedUnitId(queryData.getUploadId(), queryData.getAuditedUnitId());
        return CommonResult.<List<CostAuditPeriodRecord>>ok().value(recordList);
    }

    /**
     * 企业报送-成本调查表-动态表-删除监审期间记录
     * @param id 记录ID
     * @return 删除结果
     */
    @PostMapping(value = "/deletePeriodRecord")
    @ApiOperation(value = "删除监审期间记录（动态表使用）", httpMethod = "POST", notes = "删除监审期间记录")
    public CommonResult<String> deletePeriodRecord(
            @ApiParam(name = "id", value = "记录ID", required = true)
            @RequestParam String id) throws Exception {

        if (StringUtil.isEmpty(id)) {
            return CommonResult.<String>error().message("id不能为空");
        }

        costAuditPeriodRecordManager.remove(id);
        return CommonResult.<String>ok().message("删除监审期间记录成功");
    }

    /**
     * 企业报送-成本调查表-审核
     * @return
     * @exception
     */
    @PostMapping(value="/review")
    public CommonResult<String> review(@RequestBody CostSurveyTemplateUpload costProjectTaskMaterial){
        CostSurveyTemplateUpload upload = costSurveyTemplateUploadManager.getById(costProjectTaskMaterial.getId());
        upload.setAuditedStatus(costProjectTaskMaterial.getAuditedStatus());
        costSurveyTemplateUploadManager.updateById(upload);
        return CommonResult.<String>ok();
    }
}