package com.yunhai.bschclassmanage.service.impl;

import com.yunhai.bschclassmanage.Repository.SchBinSchsystemRepository;
import com.yunhai.bschclassmanage.entity.BaseSchsystem;
import com.yunhai.bschclassmanage.entity.SchBinSchsystem;
import com.yunhai.bschclassmanage.enums.AcademicStage;
import com.yunhai.bschclassmanage.enums.NodeType;
import com.yunhai.bschclassmanage.enums.SchType;
import com.yunhai.bschclassmanage.model.entityField.EntityFieldNames;
import com.yunhai.bschclassmanage.model.vo.AcademicStageSchsystemVO;
import com.yunhai.bschclassmanage.model.vo.SchSystemVO;
import com.yunhai.bschclassmanage.model.vo.SelectIntVO;
import com.yunhai.bschclassmanage.model.vo.TreeSelectVO;
import com.yunhai.bschclassmanage.service.IBaseSchsystemGradeService;
import com.yunhai.bschclassmanage.service.IBaseSchsystemService;
import com.yunhai.bschclassmanage.service.ISchBinSchsystemService;
import com.yunhai.bschclassmanage.service.ISyncUserBaseService;
import com.yunhai.bschclassmanage.utils.RedisConstants;
import com.yunhai.bschclassmanage.utils.RedisUtil;
import com.yunhai.platform.utils.exception.DException;
import com.yunhai.platform.utils.model.BoaGroup;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.criteria.Predicate;
import java.lang.reflect.Array;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class SchBinSchsystemService implements ISchBinSchsystemService {

    @Autowired
    private SchBinSchsystemRepository schBinSchsystemRepository;

    @Autowired
    private IBaseSchsystemService baseSchsystemService;

    @Autowired
    private ISyncUserBaseService syncUserBaseService;

    @Autowired
    private RedisUtil redisUtil;

    public List<SchBinSchsystem> getSchBinSchsystemList(Integer schId){
        Specification specification = (Specification) (root, criteriaQuery, criteriaBuilder) -> {
            List<Predicate> predicates = new ArrayList<>();
            predicates.add(criteriaBuilder.equal(root.get(EntityFieldNames.schId),schId));
            return criteriaBuilder.and(predicates.toArray(new Predicate[predicates.size()]));
        };
        return schBinSchsystemRepository.findAll(specification);
    }

    public List<Integer> getSchIds(){
        return schBinSchsystemRepository.findAll().stream().map(s->s.getSchId()).distinct().collect(Collectors.toList());
    }


    public List<Integer> getSchBinSchsystemIds(Integer schId){
        return getSchBinSchsystemList(schId).stream().map(s->s.getSchSystemId()).collect(Collectors.toList());
    }



    /**
     * 获取学校关联的学段与学制映射（一个学段仅对应一个学制）
     * @param schId 学校ID
     * @return Map<学段ID, 学制ID>
     */
    public Map<Integer, Integer> getAcademicStageToSchsystemMap(Integer schId) {
        List<Integer> schsystemIds = getSchBinSchsystemIds(schId);
        return baseSchsystemService.getSchsystemList().stream()
                .filter(s -> schsystemIds.contains(s.getId()))
                .collect(Collectors.toMap(
                        BaseSchsystem::getAcademicStage, // key: 学段ID
                        BaseSchsystem::getId,            // value: 学制ID
                        (existing, replacement) -> existing // 若有重复，保留第一个（理论上不会发生）
                ));
    }

    public List<AcademicStageSchsystemVO> getAcademicStageSchsystemList(Integer schId) {
        List<AcademicStage> academicStageEnumList = AcademicStage.list();
        List<BaseSchsystem> baseSchSystemList = baseSchsystemService.getSchsystemList();
        Set<Integer> checkedIdSet = new HashSet<>(getSchBinSchsystemIds(schId));

        Map<Integer, List<BaseSchsystem>> groupByStage = baseSchSystemList.stream()
                .filter(s -> s.getAcademicStage() != null)
                .collect(Collectors.groupingBy(BaseSchsystem::getAcademicStage));

        return academicStageEnumList.stream()
                .map(stageEnum -> {
                    List<BaseSchsystem> stageSystems = groupByStage.getOrDefault(stageEnum.getKey(), Collections.emptyList());
                    List<SchSystemVO> schSystemVOList = stageSystems.stream()
                            .map(sys -> SchSystemVO.builder()
                                    .id(sys.getId())
                                    .name(sys.getName())
                                    .checked(checkedIdSet.contains(sys.getId()))
                                    .build())
                            .collect(Collectors.toList());

                    return AcademicStageSchsystemVO.builder()
                            .academicStageId(stageEnum.getKey())
                            .academicStageName(stageEnum.getValue())
                            .academicStageList(schSystemVOList)
                            .build();
                })
                .collect(Collectors.toList());
    }

    @Transactional(rollbackFor = Exception.class)
    public void saveSchBinSchsystem(SchBinSchsystem entity, Integer[] schsystemIds) {

        Integer schId=entity.getSchId();

        List<SchBinSchsystem> existingList = getSchBinSchsystemList(schId);
        if (!existingList.isEmpty()) {
            schBinSchsystemRepository.deleteAll(existingList);
        }

        List<SchBinSchsystem> newList = new ArrayList<>(schsystemIds.length);
        for (Integer systemId : schsystemIds) {
            if (systemId == null) {
                continue;
            }
            SchBinSchsystem newEntity = new SchBinSchsystem();  // ← 每次 new 一个新对象
            // 如果需要复制 entity 的其他属性
            BeanUtils.copyProperties(entity, newEntity);
            newEntity.setSchSystemId(systemId);
            newList.add(newEntity);
        }

        if (!newList.isEmpty()) {
            schBinSchsystemRepository.saveAll(newList);
        }
        String cacheKey = RedisConstants.SCHOOL_GRAGE+"_"+schId;
        SchGroupInitialization(schId);
        redisUtil.del(cacheKey);
    }


    //获取学校类型
    public Integer getSchType(Integer schId) {
        Set<Integer> schsystemIds = getSchBinSchsystemList(schId)
                .stream()
                .map(s -> s.getSchSystemId())
                .collect(Collectors.toSet());

        Set<Integer> typeIds = baseSchsystemService.getSchsystemList()
                .stream()
                .filter(s -> schsystemIds.contains(s.getId()))
                .map(s -> s.getType())
                .collect(Collectors.toSet());

        // 校验：类型必须唯一
        if (typeIds.isEmpty()) {
            throw new DException("该学校未绑定任何学制，请先绑定");
        }
        if (typeIds.size() > 1) {
            throw new DException("该学校绑定了多种学制类型（" + typeIds + "），数据异常，请检查");
        }

        // 此时 typeIds 仅有一个元素，直接获取
        Integer typeId = typeIds.iterator().next();

        if(typeId.equals(SchType.VOCATIONALEDUCATION.getKey())&&schsystemIds.size()>1){
            throw new DException("该学校只能选择单个学制，请重新选择学制！");
        }

        // 从枚举中匹配该 typeId
        return SchType.list().stream()
                .filter(s -> s.getKey().equals(typeId))
                .findFirst()
                .orElseThrow(() -> new DException("未找到对应的学制类型，typeId=" + typeId))
                .getKey();
    }



    public List<SelectIntVO> selectSchBinSchsystem(Integer schId) {
        // 1. 获取学校绑定的学制 ID 集合
        List<SchBinSchsystem> binList = getSchBinSchsystemList(schId);
        if (binList == null || binList.isEmpty()) {
            return Collections.emptyList();
        }
        Set<Integer> schsystemIds = binList.stream()
                .map(SchBinSchsystem::getSchSystemId)
                .collect(Collectors.toSet());

        // 2. 获取全部学制并过滤出绑定的
        List<BaseSchsystem> allSystems = baseSchsystemService.getSchsystemList();
        if (allSystems == null || allSystems.isEmpty()) {
            return Collections.emptyList();
        }

        // 3. 转换为 SchSystemVO 列表，checked 固定为 true
        return allSystems.stream()
                .filter(s -> schsystemIds.contains(s.getId()))
                .map(s -> {
                    SelectIntVO vo = new SelectIntVO();
                    vo.setId(s.getId());
                    vo.setName(s.getName());
                    return vo;
                })
                .collect(Collectors.toList());
    }


    public Map<Integer, String> getSchBinSchsystemMap(Integer schId) {
        List<SelectIntVO> list= selectSchBinSchsystem(schId);
        return list.stream()
                .collect(Collectors.toMap(
                        SelectIntVO::getId,   // key
                        SelectIntVO::getName,   // value
                        (oldVal, newVal) -> oldVal // 若key冲突，保留旧值（理论上不会冲突）
                ));
    }

    //学制树：第一层学段（value=学段id，title=学段名称），第二层学制（value=学制id，title=学制名称）
    public List<TreeSelectVO> selectSchsystemTree() {
        List<AcademicStageSchsystemVO> cached = getAcademicStageSchsystemList(null);
        List<TreeSelectVO> list = new ArrayList<>();
        for (AcademicStageSchsystemVO item : cached) {
            List<TreeSelectVO> children = new ArrayList<>();
            if (item.getAcademicStageList() != null) {
                for (SchSystemVO sys : item.getAcademicStageList()) {
                    children.add(TreeSelectVO.builder()
                            .id(sys.getId())
                            .label(sys.getName())
                            .build());
                }
            }
            list.add(TreeSelectVO.builder()
                    .id(item.getAcademicStageId())
                    .label(item.getAcademicStageName())
                    .children(children)
                    .build());
        }
        return list;
    }

    private void SchGroupInitialization(Integer schId)
    {
        //添加学生组
        BoaGroup teaGroup= syncUserBaseService.addGroup("教师组",schId,1,NodeType.TEACHER);
        BoaGroup stuGroup= syncUserBaseService.addGroup("学生组",schId,2,NodeType.STUDENT);

        //创建校长室
        syncUserBaseService.addGroup("校长室", teaGroup.getId(),1,NodeType.NORMAL);

        //获取学制
        List<SchBinSchsystem> schsystemBinList=getSchBinSchsystemList(schId);
        Map<Integer, String> schsystemMap=getSchBinSchsystemMap(schId);
        if(schsystemBinList.size()==1)
        {

        }else if(schsystemBinList.size()>1)
        {
            Integer scort=1;
            for (SchBinSchsystem schsystem:schsystemBinList) {
                //添加学段组
                BoaGroup sectionGroup= syncUserBaseService.addGroup(schsystemMap.get(schsystem.getId()),stuGroup.getId(),scort,NodeType.SECTION);
                schsystem.setGroupId(sectionGroup.getId());
                scort++;
            }
        }else {
            throw new DException("请选择学制！");
        }

    }



}