package com.estate.expert.admin.service.impl;

import com.estate.expert.admin.domain.common.EntityRef;
import com.estate.expert.admin.domain.common.request.PageReq;
import com.estate.expert.admin.domain.common.response.PageResp;
import com.estate.expert.admin.domain.standard.hierachy.HierarchyIds;
import com.estate.expert.admin.domain.standard.problem.Problem;
import com.estate.expert.admin.domain.standard.problem.ProblemDto;
import com.estate.expert.admin.domain.standard.problem.ProblemRepository;
import com.estate.expert.admin.domain.user.User;
import com.estate.expert.admin.enums.BizResultCode;
import com.estate.expert.admin.service.HierarchyService;
import com.estate.expert.admin.service.ProblemService;
import com.estate.expert.admin.service.common.CrudServiceBaseImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.List;
import java.util.UUID;

/**
 * 问题服务实现
* @author daisyli
*/
@Slf4j
@Service
public class ProblemServiceImpl extends CrudServiceBaseImpl<Problem, ProblemDto> implements ProblemService {

    @Resource
    private ProblemRepository problemRepository;

    @Resource
    private HierarchyService hierarchyService;

    @Override
    public PageResp<ProblemDto> list(Integer hierarchyId, List<String> hierarchyPaths, String keyword, PageReq pageReq) {
        var paths = hierarchyService.findAllPaths(hierarchyId, hierarchyPaths);
        var page = problemRepository.findProblems(hierarchyId, paths, keyword, pageReq.toPageRequest());
        return PageResp.of(page, toDto(page.getContent()));
    }

    @Override
    public PageResp<EntityRef> listAbstracts(Integer hierarchyId, List<String> hierarchyPaths, String keyword, PageReq pageReq) {
        var paths = hierarchyService.findAllPaths(hierarchyId, hierarchyPaths);
        var page = problemRepository.findProblems(hierarchyId, paths, keyword, pageReq.toPageRequest());
        var abstracts = page.getContent().stream().map(entityRefMapper::toReference).toList();
        return PageResp.of(page, abstracts);
    }

    @Override
    public List<Integer> listIds(Integer hierarchyId, List<String> hierarchyPaths) {
        if(CollectionUtils.isEmpty(hierarchyPaths))
            hierarchyPaths = List.of("/");
        var paths = hierarchyService.findAllPaths(hierarchyId, hierarchyPaths);
        return problemRepository.findProblemIds(hierarchyId, paths);
    }

    @Override
    public List<Integer> findAllProblemIds(Integer hierarchyId) {
        return problemRepository.findAllProblemIds(hierarchyId);
    }

    @Override
    public void cloneProblems(Integer hierarchyId, Integer newHierarchyId) {
        var problems = problemRepository.findAllByHierarchyIdAndDeleted(hierarchyId, false);

        problems.forEach(problem -> {
            entityManager.detach(problem);
            problem.setId(null);
            problem.setName(UUID.randomUUID().toString());
        });
        var newProblems = problems.stream()
                .peek(problem -> problem.setHierarchyId(newHierarchyId)).toList();
        addEntities(null, newProblems);
    }

    @Override
    public List<Problem> findProblems(Integer hierarchyId, List<String> hierarchyPaths, List<Integer> problemIds) {
        var problems =
                CollectionUtils.isEmpty(problemIds) ?
                        problemRepository.findProblems(hierarchyId, hierarchyPaths) :
                        problemRepository.findProblems(hierarchyId, hierarchyPaths, problemIds);
        return problems;
    }

    @Override
    public void deleteByHierarchy(Integer hierarchyId, List<String> hierarchyPaths) {
        if(hierarchyId == null)
            return;
        if(hierarchyId.equals(HierarchyIds.DEPARTMENT))
            return;
        // 对于综合模型和设备模型，需要删除相关问题
        var ids = listIds(hierarchyId, hierarchyPaths);
        if(CollectionUtils.isEmpty(ids))
            return;
        this.deleteAllById(ids);
    }


    @Override
    public List<String> getHierarchyNames(Problem problem) {
        if (problem == null)
            return List.of();

        var hierarchy = hierarchyService.get(problem.getHierarchyId());
        BizResultCode.HIERARCHY_NOT_EXIST.check(hierarchy == null);
        var node = hierarchy.getContent().get(problem.getHierarchyPath());
        if(node == null)
            return List.of();

        return node.getNames();
    }

    @Override
    public Problem add(User creator, Problem entity) {
        entity.setName(UUID.randomUUID().toString());
        return super.add(creator, entity);
    }
}