package com.ruoyi.service.impl;

import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.constant.HttpStatus;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.domain.ReviewEnterpriseArchive;
import com.ruoyi.domain.Task;
import com.ruoyi.domain.vo.EnterpriseImportFileVO;
import com.ruoyi.domain.vo.ReviewEnterpriseArchiveViewItemVO;
import com.ruoyi.domain.vo.ReviewEnterpriseArchiveViewVO;
import com.ruoyi.mapper.TaskMapper;
import com.ruoyi.service.ReviewEnterpriseArchiveService;
import com.ruoyi.mapper.ReviewEnterpriseArchiveMapper;
import com.ruoyi.system.service.ISysUserService;
import com.ruoyi.web.request.ReviewEnterpriseArchiveFindByTaskIdRequest;
import com.ruoyi.web.request.ReviewEnterpriseArchiveFindFileNameListRequest;
import com.ruoyi.web.request.ReviewEnterpriseArchiveFindRequest;
import com.ruoyi.web.request.ReviewEnterpriseArchiveGetInfoRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletResponse;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.*;

import static com.ruoyi.common.utils.DateUtils.getNowDate;

/**
* @author wangfei
* @description 针对表【t_review_enterprise_archive(车企留档文件)】的数据库操作Service实现
* @createDate 2024-02-22 15:32:57
*/
@Service
public class ReviewEnterpriseArchiveServiceImpl extends ServiceImpl<ReviewEnterpriseArchiveMapper, ReviewEnterpriseArchive>
    implements ReviewEnterpriseArchiveService {

    @Autowired
    private ReviewEnterpriseArchiveMapper reviewEnterpriseArchiveMapper;

    @Autowired
    private ISysUserService sysUserService;

    @Autowired
    private ReviewEnterpriseArchiveService reviewEnterpriseArchiveService;

    @Autowired
    private TaskMapper taskMapper;


    @Override
    public List<ReviewEnterpriseArchiveViewVO> view(Long taskId) {

        Task task = taskMapper.selectById(taskId);

        List<ReviewEnterpriseArchive> archives = reviewEnterpriseArchiveMapper.findByTaskId(taskId);

        List<ReviewEnterpriseArchiveViewVO> resultList = new ArrayList<>();

        // 原始数据originalList
        List<ReviewEnterpriseArchiveViewVO> originalList = new ArrayList<>();

        if (task.getSystemReviewTaskId() != null) {
            originalList.addAll(
                    buildReviewEnterpriseArchiveViewVO(archives, reviewEnterpriseArchiveMapper.findViewItemVOByTaskId(task.getSystemReviewTaskId()))
            );
        }

        if (task.getCarReviewTaskId() != null) {
            originalList.addAll(
                    buildReviewEnterpriseArchiveViewVO(archives, reviewEnterpriseArchiveMapper.findViewItemVOByTaskId(task.getCarReviewTaskId()))
            );
        }

        // 创建一个映射，将文件名作为键，将具有相同文件名的对象列表作为值
        Map<String, List<ReviewEnterpriseArchiveViewVO>> map = new HashMap<>();

        // 遍历原始列表，将对象合并到相应的文件名键所对应的值列表中
        for (ReviewEnterpriseArchiveViewVO item : originalList) {
            String fileName = item.getFileName();
            if (!map.containsKey(fileName)) {
                map.put(fileName, new ArrayList<>());
            }
            map.get(fileName).add(item);
        }

        // 遍历映射中的值列表，将对象合并到结果列表中
        for (List<ReviewEnterpriseArchiveViewVO> itemList : map.values()) {
            // 如果有多个对象，合并它们
            if (itemList.size() > 1) {
                ReviewEnterpriseArchiveViewVO mergedItem = mergeItems(itemList);
                resultList.add(mergedItem);
            } else {
                resultList.addAll(itemList);
            }
        }

        return resultList;
    }

    /**
     * 合并具有相同文件名的对象
     * @param itemList
     * @return
     */
    private static ReviewEnterpriseArchiveViewVO mergeItems(List<ReviewEnterpriseArchiveViewVO> itemList) {
        // 创建一个新的 ReviewEnterpriseArchiveViewVO 对象来保存合并后的结果
        ReviewEnterpriseArchiveViewVO mergedItem = new ReviewEnterpriseArchiveViewVO();

        // 由于这里 items 列表需要合并，因此需要创建一个新的列表来保存合并后的结果
        List<ReviewEnterpriseArchiveViewItemVO> mergedItemList = new ArrayList<>();

        // 遍历 itemList 列表，将所有的 items 合并到 mergedItemList 中
        for (ReviewEnterpriseArchiveViewVO item : itemList) {
            mergedItemList.addAll(item.getItems());
        }

        // 将合并后的 items 设置到 mergedItem 中
        mergedItem.setItems(mergedItemList);

        // 对于其他属性，这里简单地选择第一个对象中的值作为合并后的结果
        mergedItem.setId(itemList.get(0).getId());
        mergedItem.setFileName(itemList.get(0).getFileName());

        return mergedItem;
    }

    @Override
    public Long addEnterpriseArchive(ReviewEnterpriseArchive reviewEnterpriseArchive) {

        LoginUser loginUser = SecurityUtils.getLoginUser();
        SysUser user = sysUserService.selectUserById(loginUser.getUserId());

        reviewEnterpriseArchive.setCreateBy(user.getNickName());
        reviewEnterpriseArchive.setCreateTime(new Date());

        Long sum = reviewEnterpriseArchiveMapper.findFileName(reviewEnterpriseArchive.getTaskId(),reviewEnterpriseArchive.getFileName());

        if (sum >0 ) {
            throw new ServiceException("新增文件名称重复，请检查", HttpStatus.ERROR);
        } else {
            reviewEnterpriseArchiveService.save(reviewEnterpriseArchive);

            ReviewEnterpriseArchiveFindByTaskIdRequest request = new ReviewEnterpriseArchiveFindByTaskIdRequest();
            request.setTaskId(reviewEnterpriseArchive.getTaskId());
            List<ReviewEnterpriseArchive> list = reviewEnterpriseArchiveMapper.findEnterpriseArchiveByTaskId(request);
            if (list != null && list.size() != 0) {
                for (ReviewEnterpriseArchive archive : list) {
                    if (!Objects.equals(archive.getEnterpriseName(), reviewEnterpriseArchive.getEnterpriseName())) {
                        archive.setEnterpriseName(reviewEnterpriseArchive.getEnterpriseName());
                    }
                }
                reviewEnterpriseArchiveService.updateBatchById(list);
            }
        }

        return reviewEnterpriseArchive.getId();


    }

    @Override
    public List<ReviewEnterpriseArchive> findEnterpriseArchive(ReviewEnterpriseArchiveFindRequest request) {
        return reviewEnterpriseArchiveMapper.findEnterpriseArchive(request);
    }

    @Override
    public ReviewEnterpriseArchive getInfo(ReviewEnterpriseArchiveGetInfoRequest request) {
        return reviewEnterpriseArchiveMapper.selectById(request.getId());
    }


    @Override
    public List<ReviewEnterpriseArchive> findList(ReviewEnterpriseArchiveFindFileNameListRequest request) {
        return reviewEnterpriseArchiveMapper.findList(request.getTaskId());
    }

    @Override
    public List<ReviewEnterpriseArchive> findEnterpriseArchiveByTaskId(ReviewEnterpriseArchiveFindByTaskIdRequest request) {
        return reviewEnterpriseArchiveMapper.findEnterpriseArchiveByTaskId(request);
    }

    private List<ReviewEnterpriseArchiveViewVO> buildReviewEnterpriseArchiveViewVO(List<ReviewEnterpriseArchive> archives, List<ReviewEnterpriseArchiveViewItemVO> viewItems) {

        List<ReviewEnterpriseArchiveViewVO> viewList = new ArrayList();

        for(ReviewEnterpriseArchive archive : archives) {
            ReviewEnterpriseArchiveViewVO view = new ReviewEnterpriseArchiveViewVO();
            view.setId(archive.getId());
            view.setFileName(archive.getFileName());
            setReviewEnterpriseArchiveViewItemVO(view, viewItems);

            viewList.add(view);
        }

        return viewList;
    }

    private void setReviewEnterpriseArchiveViewItemVO(ReviewEnterpriseArchiveViewVO view, List<ReviewEnterpriseArchiveViewItemVO> viewItems) {
        if (viewItems == null) return;
        List<ReviewEnterpriseArchiveViewItemVO> subList = new ArrayList();
        Long archiveId = view.getId();

        for(ReviewEnterpriseArchiveViewItemVO item : viewItems) {
            if(item.getArchiveId() != null && item.getArchiveId().equals(archiveId)) {
                subList.add(item);
            }
        }

        view.setItems(subList);
    }

    @Override
    public void importEnterprise(List<EnterpriseImportFileVO> list,Long taskId, HttpServletResponse response){
        for(EnterpriseImportFileVO vo: list){
            vo.setCreateTime(getNowDate());
            vo.setCreateBy( SecurityUtils.getLoginUser().getUser().getNickName());
            vo.setTaskId(Long.valueOf(taskId));
            vo.setId(IdUtil.getSnowflake().nextId());
            Long sum = reviewEnterpriseArchiveMapper.findFileName(Long.valueOf(taskId), vo.getFileName());
            if (sum >0 ) {
                throw new ServiceException("新增文件名称重复，请检查", HttpStatus.ERROR);
            }
            if(vo.getFileName().isEmpty()){
                throw new ServiceException("文件名称不能为空", HttpStatus.ERROR);
            }
        }
        reviewEnterpriseArchiveMapper.insertEnterprise(list);
    }
}