package com.xhkjedu.sapi.service.system;

import com.xhkjedu.sapi.mapper.system.ModuleMapper;
import com.xhkjedu.sapi.mapper.system.ModuledefaultMapper;
import com.xhkjedu.sapi.model.system.TModule;
import com.xhkjedu.sapi.model.system.TModuledefault;
import com.xhkjedu.sapi.utils.ApiUtil;
import com.xhkjedu.sapi.vo.system.ModuleSelVo;
import com.xhkjedu.utils.N_Utils;
import com.xhkjedu.vo.ResultVo;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

/**
 * @author ywx
 * @classname ModuledefaultService
 * @description 
 * @date 2020/7/2 10:36
 **/
@Service
public class ModuledefaultService {
    @Resource
    private ModuledefaultMapper moduledefaultMapper;
    @Resource
    private ModuleMapper moduleMapper;

    //添加
    @Transactional(rollbackFor = Exception.class)
    public ResultVo save(TModuledefault model) {
        if (model.getLevel() != 1) {
            if (N_Utils.isNotEmpty(model.getModuleurl())) {
                Integer num = moduledefaultMapper.countByUrl(model.getModuleurl(), model.getBelong());
                if (num != 0) {
                    return new ResultVo(1, "该应用地址已存在，禁止添加");
                }
            }

            if(N_Utils.isNotEmpty(model.getMabbrevname())){
                Integer num = moduledefaultMapper.countByMabbrevname(model.getMabbrevname(), model.getBelong());
                if (num != 0) {
                    return new ResultVo(1, "该应用编码已存在，禁止添加");
                }
            }
        }

        String id = ApiUtil.getId();
        model.setModuleid(id);
        model.setCreatetime(N_Utils.getSecondTimestamp());
        if (model.getDisplay() == null) model.setDisplay(1);
        if (model.getMdefault() == null) model.setMdefault(0);
        if (model.getLevel() == 1) model.setBelongcode(3);
        moduledefaultMapper.insertSelective(model);

        //当模块为一级（分类）时不需要给学校添加，是二级（模块）时给学校添加
        if(model.getLevel() != 1){
            //获取学校id集合
            List<Integer> schoolids = moduledefaultMapper.listSchoolId();
            if (N_Utils.isListEmpty(schoolids)) return new ResultVo(0, "保存成功", id);
            List<TModule> moduleList = new ArrayList<>();//学校模块集合
            String modulepid = model.getModulepid();
            boolean notEmpty = N_Utils.isNotEmpty(modulepid);
            List<TModule> schoolModuleList = new ArrayList<>();//学校模块集合
            if (notEmpty) {
                TModuledefault mp = findById(modulepid);
                schoolModuleList = moduledefaultMapper.getModuleIdByDefaultId(modulepid, schoolids, mp.getBelong());
            }
            for (Integer schoolid : schoolids) {
                TModule m = new TModule();
                BeanUtils.copyProperties(model, m);
                m.setModuleid(ApiUtil.getId());
                m.setDisplaytype(1);
                m.setSourcetype(1);
                m.setDefaultid(id);
                m.setDefaultbcode(model.getBelongcode());
                m.setSchoolid(schoolid);
                if (notEmpty) {
                    TModule schoolModule = schoolModuleList.stream().filter(s -> s.getSchoolid().equals(schoolid)).findFirst().orElse(null);
                    if (schoolModule != null) {
                        m.setModulepid(schoolModule.getModuleid());
                    }
                }
                moduleList.add(m);
            }
            moduleMapper.batchSave(moduleList);//批量保存学校模块信息
        }
        return new ResultVo(0, "保存成功",id);
    }

    //删除
    @Transactional(rollbackFor = Exception.class)
    public Integer deleteById(String id) {
        moduleMapper.deleteByDefaultId(id);
        return moduledefaultMapper.deleteByPrimaryKey(id);
    }


    /*
     * 修改应用时修改对应的属性值
     * 应用名称：如果学校平台自定义了名称，则不更新此学校的应用名称，除此之外的学校覆盖应用名称。
     * 适用终端：直接覆盖所有的学校。
     * 应用排序：不覆盖任何学校。
     * 站内应用：直接覆盖所有的学校，且学校不允许更改。
     * 是否显示：如果选中不显示，则直接下架所有学校的此应用。如果选中显示，则自动上架所有学校的此应用。
     * 应用地址：直接覆盖所有的学校，且学校不允许更改。
     * 应用编码：直接覆盖所有的学校，且学校不允许更改。
     * 所属分类：不覆盖任何学校。
     * 应用图标：如果学校平台自定义了图标，则不覆盖此学校的此应用图标，除此之外的学校自动覆盖此应用图标。
     * 应用描述：直接覆盖所有的学校，且学校不允许更改。
     **/
    @Transactional(rollbackFor = Exception.class)
    public void update(TModuledefault model) {

        String moduleid = model.getModuleid();
        //修改默认模块事，先获取原默认模块属性
        TModuledefault originModule = moduledefaultMapper.selectByPrimaryKey(moduleid);

        if(originModule.getLevel() == 2){
            //应用名称改变则处理,如果学校已设置不动，未设置更改
            if(!originModule.getModulename().equals(model.getModulename())){
                moduleMapper.updateBatchModulename(moduleid,originModule.getModulename(),model.getModulename());
            }
            //应用图标，如果学校已设置不动，未设置更改
            if(N_Utils.isEmpty(originModule.getModuleico()) || !originModule.getModuleico().equals(model.getModuleico())){
                moduleMapper.updateBatchModuleico(moduleid, model.getModuleico());
            }

            if(!N_Utils.isTrueInteger(model.getBelongcode())){
                model.setBelongcode(originModule.getBelongcode());
            }

            //直接覆盖所有学校：适用终端、站内应用、应用地址、应用编码、应用描述
            moduleMapper.updateBatchFixed(model);

            //区域更改终端类型时，更改模块对应的t_role_module对应belongcode
            if(!originModule.getBelongcode().equals(model.getBelongcode())){
                moduleMapper.updateBatchBelongcode(model);
            }
        }

        moduledefaultMapper.updateByPrimaryKeySelective(model);//更新默认模块信息
    }

    //获取详情
    public TModuledefault findById(String id) {
        return moduledefaultMapper.selectByPrimaryKey(id);
    }

    //获取列表
    public List <TModuledefault> listAll(Integer belong, Integer belongcode, Integer display) {
        List<TModuledefault> modules = new ArrayList<>();
        List<TModule> lst = listModulesTree(belong, belongcode, display,1);
        lst.forEach(m->{
            List<TModule> twomodules = m.getModulechilds();
            m.setModulechilds(null);
            TModuledefault d = copyProperties(m);
            modules.add(d);
            twomodules.forEach(m2->{
                List<TModule> threemodules = m2.getModulechilds();
                m2.setModulechilds(null);
                TModuledefault d2 = copyProperties(m2);
                modules.add(d2);
                threemodules.forEach(m3->{
                    TModuledefault d3 = copyProperties(m3);
                    modules.add(d3);
                });
            });
        });
        return modules;
    }

    /**
     * 复制模块信息
     * @Param [m]
     * @Author ywx
     * @Date 2020/7/2 15:16
     * @return com.xhkjedu.model.system.TModuledefault
     **/
    private TModuledefault copyProperties(TModule m) {
        TModuledefault moduledefault = new TModuledefault();
        moduledefault.setModuleid(m.getModuleid());
        moduledefault.setModulename(m.getModulename());
        moduledefault.setMabbrevname(m.getMabbrevname());
        moduledefault.setModuleurl(m.getModuleurl());
        moduledefault.setModuleico(m.getModuleico());
        moduledefault.setModulepid(m.getModulepid());
        moduledefault.setMorder(m.getMorder());
        moduledefault.setMinout(m.getMinout());
        moduledefault.setMclass(m.getMclass());
        moduledefault.setLevel(m.getLevel());
        moduledefault.setComm(m.getComm());
        moduledefault.setCreatetime(m.getCreatetime());
        moduledefault.setMdefault(m.getMdefault());
        moduledefault.setBelong(m.getBelong());
        moduledefault.setBelongcode(m.getBelongcode());
        moduledefault.setDisplay(m.getDisplay());
        return moduledefault;
    }

    public List<TModule> listModulesTree(Integer belong, Integer belongcode, Integer display,Integer ly){
        List<TModule> lst = new ArrayList<>();
        if(ly == 1){
            lst = moduledefaultMapper.listModulesByBelong(belong, belongcode,display);
        }else if(ly == 2){
            lst = moduledefaultMapper.listAllModules();
        }

        List<TModule> rtnlst = new ArrayList<>();

        for(TModule m : lst){
            if(m.getLevel()==1){
                rtnlst.add(m);
            }
        }

        for(TModule m : rtnlst){
            List<TModule> childs = m.getModulechilds();
            for(TModule mc: lst){
                if(m.getModuleid().equals(mc.getModulepid())){
                    if(!isExistModule(childs,m.getModuleid())){
                        childs.add(mc);
                    }
                }
            }
        }

        return rtnlst;
    }

    //判断集合中是否存在模块
    private boolean isExistModule(List<TModule> lst,String moduleid){
        for(TModule m: lst){
            if(m.getModuleid().equals(moduleid)){
                return true;
            }
        }
        return false;
    }

    //首层模块
    public List<ModuleSelVo> listLevelModule(Integer belong) {
        return moduledefaultMapper.listLevelModule(belong);
    }


    /*
     * @Description 显示
     * @Date 2024/6/20 11:19:17
     * @Author WN
     * @Param [moduleid]
     * @Return void
     **/
    @Transactional(rollbackFor = Exception.class)
    public void handleDisplay(String moduleid){
        //修改默认模块事，先获取原默认模块属性
        TModuledefault originModule = moduledefaultMapper.selectByPrimaryKey(moduleid);
        if(originModule.getLevel() == 2){
            //代表操作的是模块
            moduledefaultMapper.updateModuleDisplay(moduleid,1);
            moduleMapper.updateDisplayByDefaultid(moduleid);
        }else{
            //操作的为分组则显示分组下所有的应用
            moduledefaultMapper.updateModuleDisplayForLevel(moduleid,1);
            //修改学校模块信息
            moduleMapper.updateBatchDisplayForLevel(moduleid);
        }
    }

    /*
     * @Description 隐藏
     * @Date 2024/6/20 11:19:27
     * @Author WN
     * @Param [moduleid]
     * @Return void
     **/
    @Transactional(rollbackFor = Exception.class)
    public void handleUnDisplay(String moduleid){
        //修改默认模块事，先获取原默认模块属性
        TModuledefault originModule = moduledefaultMapper.selectByPrimaryKey(moduleid);
        if(originModule.getLevel() == 2){
            moduledefaultMapper.updateModuleDisplay(moduleid,10);
            moduleMapper.updateUnDisplayByDefaultid(moduleid);
        }else {
            //操作的为分组则显示分组下所有的应用
            moduledefaultMapper.updateModuleDisplayForLevel(moduleid,10);
            //修改学校模块信息
            moduleMapper.updateBatchUnDisplayForLevel(moduleid);
        }

    }

}
