package cn.huge.module.knowledge.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.knowledge.dao.mapper.LawInfoMapper;
import cn.huge.module.knowledge.dao.mapper.LawProvisionMapper;
import cn.huge.module.knowledge.domain.dto.DictionaryDTO;
import cn.huge.module.knowledge.domain.dto.LawInfoPageDTO;
import cn.huge.module.knowledge.domain.dto.LawProvisionKeyDTO;
import cn.huge.module.knowledge.domain.po.Dictionary;
import cn.huge.module.knowledge.domain.po.LawInfo;
// import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Maps;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

/**
 * @title: 法律表业务逻辑处理
 * @Description 法律表业务逻辑处理
 * @company hugeinfo
 * @author huangh
 * @Time 2024-12-05 16:15:00
 * @version 1.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class LawInfoService extends ServiceImpl<LawInfoMapper, LawInfo> {

    @Autowired
    private LawInfoMapper mapper;

    @Autowired
    private LawProvisionMapper lawProvisionMapper;

    @Autowired
    private DictionaryService dictionaryService;

    @Autowired
    private UtilsClientImpl utilsClient;

    /**
     * 更新对象
     * @param entity 对象
     */
    public void updateLawInfo(LawInfo entity) {
        try {
            mapper.updateLawInfo(entity);
        } catch (Exception e) {
            log.error("[LawInfoService.updateLawInfo]调用失败，异常信息：" + e, e);
            throw new ServiceException("LawInfoService.updateLawInfo", e);
        }
    }

    /**
     * 条件更新对象
     * @param entity 对象
     * @param terms 条件
     */
    public void updateLawInfoTerms(LawInfo entity, Map<String, Object> terms) {
        try {
            mapper.updateLawInfoTerms(entity, terms);
        } catch (Exception e) {
            log.error("[LawInfoService.updateLawInfoTerms]调用失败，异常信息：" + e, e);
            throw new ServiceException("LawInfoService.updateLawInfoTerms", e);
        }
    }

    /**
     * 根据编号物理删除
     * @param id 查询条件集合
     */
    public void deleteLawInfo(String id) {
        try {
            mapper.deleteLawInfo(id);
        } catch (Exception e) {
            log.error("[LawInfoService.deleteLawInfo]调用失败，异常信息：" + e, e);
            throw new ServiceException("LawInfoService.deleteLawInfo", e);
        }
    }

    /**
     * 按条件查询
     * @param terms 条件
     * @return List
     */
    public List<LawInfo> listTerms(Map<String, Object> terms) {
        return mapper.listTerms(terms);
    }

    /**
     * 按条件统计
     * @param terms 条件
     * @return long
     */
    public long countTerms(Map<String, Object> terms) {
        return mapper.countTerms(terms);
    }

    /**
     * 按条件分页查询
     * @param page 分页对象
     * @param terms 条件
     * @return Page
     */
    public Page<LawInfoPageDTO> pageQuery(PageRequest page, Map<String, Object> terms) {
        long total;
        List<LawInfoPageDTO> content;
        //  检查 terms 是否有 keyword 字段
        if (terms.get("keyword") == null) {
            //  如果没有 keyword，使用 法律信息 进行总数计算和分页查询
            total = mapper.countTerms(terms);
            content = mapper.pageTerms(page, terms);
        }else {
            //  如果有 keyword，使用 包含法条的sql 进行总数计算和分页查询
            total = mapper.countTermsKeyLaw(terms);
            content = mapper.pageTermsKeyLaw(page, terms);
            //  对查询结果进行遍历，为每个法律信息添加关键字相关的条款
            for (LawInfoPageDTO lawInfoPageDTO : content) {
                //  创建一个新的条件对象，用于查询关键字相关的条款
                Map<String, Object> termsProvision = Maps.newHashMap();
                termsProvision.put("lawInfoId", lawInfoPageDTO.getLawInfoId());
                termsProvision.put("keyword", terms.get("keyword"));
                //  查询关键字相关的条款，并将其设置到法律信息对象中
                List<LawProvisionKeyDTO> lawProvisionList = lawProvisionMapper.listTermsKey(termsProvision);
                lawInfoPageDTO.setKeywordProvisionList(lawProvisionList);
            }
            //  如果查询结果为空，则使用 法律信息 重新进行总数计算和分页查询
            if (content.isEmpty()){
                total = mapper.countTerms(terms);
                content = mapper.pageTerms(page, terms);
            }
        }
        //  创建并返回一个新的分页对象
        return new PageImpl<>(content, page, total);
    }

    /**
     * 统计各类别法律数量
     *
     */
    public List<DictionaryDTO> categoryCount(Map<String, Object> terms) {
        QueryWrapper<Dictionary> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("parent_code", "1");
        List<Dictionary> dictionaryList = dictionaryService.list(queryWrapper);
        List<DictionaryDTO> dictionaryDTOList = new ArrayList<>();
        List<DictionaryDTO> selectList = mapper.categoryCount(terms);

        // 创建一个map来快速查找子节点
        // Map<String, DictionaryDTO> map = new HashMap<>();

        for (Dictionary dictionary : dictionaryList) {
            QueryWrapper<Dictionary> queryWrapperSec = new QueryWrapper<>();
            DictionaryDTO dictionaryDTO = new DictionaryDTO();
            BeanUtils.copyProperties(dictionary, dictionaryDTO);
            dictionaryDTO.setChildren(new ArrayList<>());
            queryWrapperSec.eq("parent_code", dictionary.getCode());
            List<Dictionary> dictionaryListSec = dictionaryService.list(queryWrapperSec);

            for (Dictionary dictionarySec : dictionaryListSec) {
                DictionaryDTO dictionarySecDTO = new DictionaryDTO();
                BeanUtils.copyProperties(dictionarySec, dictionarySecDTO);
                for (DictionaryDTO selectItem : selectList) {
                    if (dictionaryDTO.getCode().equals(selectItem.getCode()) && dictionarySecDTO.getValue().equals(selectItem.getValue())) {
                        dictionarySecDTO.setCount(selectItem.getCount());
                    }
                }
                dictionaryDTO.getChildren().add(dictionarySecDTO);
                // map.put(dictionarySec.getCode(), dictionarySecDTO);
            }
            dictionaryDTOList.add(dictionaryDTO);
            // map.put(dictionary.getCode(), dictionaryDTO);
        }


        log.debug("各类别: " + dictionaryDTOList);
        log.debug("统计各类别法律数量: " + selectList);

        // // 合并selectList中的count值到dictionaryDTOList中
        // for (DictionaryDTO selectItem : selectList) {
        //     DictionaryDTO targetItem = map.get(selectItem.getCode());
        //     if (targetItem != null) {
        //         targetItem.setCount(selectItem.getCount());
        //     }
        // }

        return dictionaryDTOList;
    }

    /**
     * 新增或更新对象
     * @param lawInfo 实体对象
     */
    public void saveLawInfo(LawInfo lawInfo) {
        try {
            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(lawInfo.getLawInfoId())) {
                lawInfo.setLawInfoId(utilsClient.getNewTimeId());
                lawInfo.setCreateTime(nowDate);
            }
            lawInfo.setUpdateTime(nowDate);
            this.saveOrUpdate(lawInfo);
        } catch (Exception e) {
            log.error("[LawInfoService.saveLawInfo]调用失败，异常信息：" + e, e);
            throw new ServiceException("LawInfoService.saveLawInfo", e);
        }
    }

}