package com.supervision.police.dto;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.supervision.police.domain.CaseEvidence;
import com.supervision.police.domain.EvidenceDirectory;
import lombok.Data;

import java.util.*;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 案件证据目录
 */
@Data
public class EvidenceDirectoryDTO {

    /**
     * 目录id
     */
    private String id;

    /**
     * 目录名
     */
    private String directoryName;

    /**
     * 父级目录id
     */
    private String parentId;

    /**
     * 目录分类
     */
    private String categoryId;

    /**
     * 子目录
     */
    private List<EvidenceDirectoryDTO> child;


    /**
     * 文件信息
     */
    private List<EvidenceFileDTO> fileInfoList = new ArrayList<>();

    /**
     * 证据信息，供前端使用。level为 1、2 级时evidenceInfo为空。为3级时不为空，
     * 且与fileInfoList[evidenceInfo]保持一致
     */
    private CaseEvidence evidenceInfo;

    private int level = -1;

    /**
     * 证据数量
     */
    private int evidenceCount;

    public EvidenceDirectoryDTO() {
    }
    public EvidenceDirectoryDTO(List<EvidenceDirectoryDTO> children) {
        this.child = children;
    }

    public EvidenceDirectoryDTO(EvidenceDirectory directory){
        if (directory == null){
            return;
        }
        this.id = directory.getId();
        this.directoryName = directory.getDirectoryName();
        this.categoryId = directory.getCategoryId();
        this.parentId = directory.getParentId();
        this.child = new ArrayList<>();
    }

    public EvidenceDirectoryDTO findDirectory(String directoryId){

        if (StrUtil.isEmpty(directoryId)){
            return null;
        }

        if (StrUtil.equals(this.id, directoryId)){
            return this;
        }
        if (CollUtil.isNotEmpty(this.getChild())){
            for (EvidenceDirectoryDTO evidenceDirectoryDTO : this.getChild()) {
                EvidenceDirectoryDTO directoryDTO = evidenceDirectoryDTO.findDirectory(directoryId);
                if (directoryDTO != null){
                    return directoryDTO;
                }
            }
        }
        return null;
    }

    public List<String> findDirectoryIdList(String categoryId){
        List<String> list = new ArrayList<>();
        if (StrUtil.equals(this.categoryId, categoryId)){
            list.add(this.id);
        }
        if (CollUtil.isNotEmpty(this.child)){
            for (EvidenceDirectoryDTO directoryDTO : this.child) {
                if (StrUtil.equals(directoryDTO.getCategoryId(), categoryId)){
                    list.addAll(directoryDTO.findDirectoryIdList(categoryId));
                }
            }
        }
        return list;
    }

    public List<String> listAllFileId(){
        List<String> fileIdList = new ArrayList<>();
        if (CollUtil.isNotEmpty(this.fileInfoList)){
            fileIdList.addAll(this.fileInfoList.stream().map(EvidenceFileDTO::getFileId).toList());
        }
        if (CollUtil.isNotEmpty(this.child)){
            for (EvidenceDirectoryDTO child : this.getChild()) {
                fileIdList.addAll(child.listAllFileId());
            }

        }
        return fileIdList;
    }

    public List<EvidenceFileDTO> listAllFile(){
        List<EvidenceFileDTO> fileList = new ArrayList<>();
        if (CollUtil.isNotEmpty(this.fileInfoList)){
            fileList.addAll(this.fileInfoList);
        }
        if (CollUtil.isNotEmpty(this.child)){
            for (EvidenceDirectoryDTO child : this.getChild()) {
                fileList.addAll(child.listAllFile());
            }

        }
        return fileList;
    }

    public List<EvidenceDirectoryDTO> listAllDirectory(){
        List<EvidenceDirectoryDTO> directoryList = new ArrayList<>();
        directoryList.add(this);
        if (CollUtil.isNotEmpty(this.child)){
            for (EvidenceDirectoryDTO child : this.getChild()) {
                directoryList.addAll(child.listAllDirectory());
            }

        }
        return directoryList;
    }

    public int evalLevel(String id, int currentLevel) {
        if (StrUtil.isEmpty(id)){
            return -1;
        }
        if (StrUtil.equals(this.id, id)){
            return currentLevel;
        }
        if (CollUtil.isNotEmpty(this.child)){
            for (EvidenceDirectoryDTO evidenceCategoryDTO : child) {
                int level = evidenceCategoryDTO.evalLevel(id, currentLevel + 1);
                if (level != -1){
                    return level;
                }
            }
        }
        return -1;
    }

    public void setDirectoryLevel(int currentLevel){
        this.level = currentLevel;
        if (CollUtil.isNotEmpty(this.child)){
            for (EvidenceDirectoryDTO directoryDTO : this.getChild()) {
                directoryDTO.setDirectoryLevel(currentLevel + 1);
            }
        }
    }

    public void appendChildDirectory(){
        if (CollUtil.isNotEmpty(this.child)){
            for (EvidenceDirectoryDTO directoryDTO : child) {
                EvidenceFileDTO evidenceFileDTO = new EvidenceFileDTO();
                evidenceFileDTO.setFileId(directoryDTO.getId());
                evidenceFileDTO.setDirectoryId(this.id);
                evidenceFileDTO.setDirectoryFlag("1");
                evidenceFileDTO.setFileName(directoryDTO.getDirectoryName());
                this.fileInfoList.add(evidenceFileDTO);

                // 递归子级目录
                directoryDTO.appendChildDirectory();
            }
        }
    }

    public void appendChildFile(Map<String,List<EvidenceFileDTO>> fileMap){
        List<EvidenceFileDTO> evidenceFileDTOS = fileMap.get(this.id);
        if (CollUtil.isNotEmpty(evidenceFileDTOS)){
            evidenceFileDTOS.sort(Comparator.comparingInt(EvidenceFileDTO::getRank));
            this.fileInfoList.addAll(evidenceFileDTOS);
        }
        if (CollUtil.isNotEmpty(this.getChild())){
            for (EvidenceDirectoryDTO directoryDTO : this.child) {
                directoryDTO.appendChildFile(fileMap);
            }
        }

    }

    public void setFileEvidence(Map<String, CaseEvidence> caseEvidenceMap,Map<String, CategoryPromptDTO> categoryPromptMap){
        if (CollUtil.isNotEmpty(this.getChild())){
            for (EvidenceDirectoryDTO directoryDTO : this.child) {
                directoryDTO.setFileEvidence(caseEvidenceMap,categoryPromptMap);
            }
        }
        if (CollUtil.isEmpty(this.getFileInfoList())){
            return;
        }
        for (EvidenceFileDTO evidenceFileDTO : this.getFileInfoList()) {
            evidenceFileDTO.setPrompt(categoryPromptMap.get(evidenceFileDTO.getDirectoryId()));
            if (StrUtil.isNotEmpty(evidenceFileDTO.getEvidenceId())){
                evidenceFileDTO.setEvidenceInfo(caseEvidenceMap.get(evidenceFileDTO.getEvidenceId()));
            }
        }
        if (this.level == 3 ){
            if (CollUtil.isNotEmpty(this.getFileInfoList())){
                this.evidenceInfo = caseEvidenceMap.get(CollUtil.getFirst(this.getFileInfoList()).getEvidenceId());
            }

        }

    }

    public void removeEmptyDirectory(){

        if (CollUtil.isEmpty(this.child)){
            return;
        }
        for (EvidenceDirectoryDTO directoryDTO : this.child) {
            directoryDTO.removeEmptyDirectory();
        }
        this.getChild().removeIf(next -> CollUtil.isEmpty(next.getChild()) && CollUtil.isEmpty(next.getFileInfoList()));
    }

    /**
     * 判断分类id对应目录下是否存在有文件
     * @param categoryId 分类id
     * @return
     */
    public boolean categoryHasFile(String categoryId){

        if (StrUtil.isEmpty(categoryId)){
            return false;
        }

        if (StrUtil.equals(this.categoryId,categoryId)){
            return CollUtil.isNotEmpty(this.fileInfoList);
        }
        if (CollUtil.isEmpty(this.child)){
            return false;
        }
        for (EvidenceDirectoryDTO directoryDTO : this.child) {
            if (directoryDTO.categoryHasFile(categoryId)){
                return true;
            }
        }
        return false;
    }

    /**
     * 重新放置证据信息
     */
    public void replaceEvidence(){
        if (CollUtil.isNotEmpty(this.fileInfoList) && null != this.evidenceInfo){
            for (EvidenceFileDTO evidenceFileDTO : this.fileInfoList) {
                evidenceFileDTO.setEvidenceInfo(evidenceInfo);
            }
        }
        if (CollUtil.isNotEmpty(this.child)){
            for (EvidenceDirectoryDTO directoryDTO : this.child) {
                directoryDTO.replaceEvidence();
            }
        }
    }

    public List<String> getFileIdList() {
        if (CollUtil.isNotEmpty(this.fileInfoList)){
            return this.fileInfoList.stream().map(EvidenceFileDTO::getFileId).collect(Collectors.toList());
        }else {
            return new ArrayList<>();
        }
    }

    public List<String> getDirectoryPath(String directoryId) {

        if (StrUtil.equals(this.id, directoryId)){
            return new ArrayList<>(Collections.singletonList(this.directoryName));
        }
        if (CollUtil.isNotEmpty(this.child)){
            for (EvidenceDirectoryDTO directoryDTO : this.child) {
                List<String> directoryPath = directoryDTO.getDirectoryPath(directoryId);
                if (CollUtil.isNotEmpty(directoryPath)){
                    if (StrUtil.isNotEmpty(this.directoryName)){
                        directoryPath.add(0,this.directoryName);
                    }
                    return directoryPath;
                }
            }
        }
        return new ArrayList<>(1);

    }

    public void appendEvidenceCount(List<CaseEvidence> caseEvidenceList) {

        if (CollUtil.isEmpty(caseEvidenceList)){
            return;
        }
        List<String> directoryIds = this.listAllDirectory().stream().map(EvidenceDirectoryDTO::getId).collect(Collectors.toList());
        directoryIds.add(this.id);
        long count = caseEvidenceList.stream().filter(caseEvidence ->
                StrUtil.isNotEmpty(caseEvidence.getDirectoryId()) && directoryIds.contains(caseEvidence.getDirectoryId())
        ).count();
        this.evidenceCount = (int) count;

        if (CollUtil.isNotEmpty(this.child)){
            for (EvidenceDirectoryDTO directoryDTO : this.child) {
                directoryDTO.appendEvidenceCount(caseEvidenceList);
            }
        }

    }
}