package io.renren.modules.levelManage.controller;

import io.renren.common.utils.PageUtils;
import io.renren.common.utils.R;
import io.renren.modules.levelManage.entity.LevelEntity;
import io.renren.modules.levelManage.service.LevelService;
import io.renren.modules.sys.controller.AbstractController;
import io.renren.modules.sys.entity.SysUserEntity;
import io.renren.modules.sys.service.SysMenuService;
import io.renren.modules.sys.service.SysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.*;


/**
 * 层级关系表
 *
 * @author chenshun
 * @email sunlightcs@gmail.com
 * @date 2022-03-28 17:07:26
 */
@RestController // @ResponseBody 它的作用简短截说就是指该类中所有的API接口返回的数据，甭管你对应的方法返回Map或是其他Object，它会以Json字符串的形式返回给客户端
@RequestMapping("/level")
public class LevelController extends AbstractController {
    @Autowired
    private LevelService levelService;
    @Autowired
    private SysUserService sysUserService;
    @Autowired
    private SysMenuService sysMenuService;

    /**
     * 列表
     */
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params){
        PageUtils page = levelService.queryPage(params);
        return R.ok().put("page", page);
    }

    /**
     * 根据名称进行搜索
     */
    @RequestMapping("selectByName")
    public R selectByName(@RequestParam(defaultValue = "1") Integer page,
                          @RequestParam(defaultValue = "100") Integer size,
                          @RequestParam(value = "name") String name)
    {
        List<LevelEntity> levelList = levelService.selectByName(page,size,name);
        Integer total = levelService.getCountByName(name);
        return R.ok().put("count",total).put("levelList",levelList);
    }


    /**
     * 按层级关系展示的列表
     */
    @RequestMapping("/listParent")
    public R list(){
        List<LevelEntity> levelEntityList =levelService.list();

        //将所有层级关系放入hashmap中
        HashMap<Long, LevelEntity> levelMap = new HashMap<>();
        for (LevelEntity level : levelEntityList) {
            levelMap.put(level.getId(), level);
        }
        //对用户名同理
        List<SysUserEntity> userEntityList = sysUserService.list();
        HashMap<Long,SysUserEntity> userMap=new HashMap<>();
        for(SysUserEntity user: userEntityList)
        {
            userMap.put(user.getUserId(),user);
        }
        //对每一个level,通过他的parentid，将parent名放进去,对用户一样
        for (LevelEntity level : levelEntityList) {
            LevelEntity parent = levelMap.get(level.getParentId());
            if (Objects.nonNull(parent)) {
                level.setParentName(parent.getName());
            }
            SysUserEntity user= userMap.get(level.getUid());
            if(Objects.nonNull(user))
            {
                level.setUName(user.getUsername());
            }
        }

        return R.ok().put("levelList",levelEntityList);
    }

    /**
     * 层级关系信息，加上一个第0层级，用于新加入层级时的父层级选择
     */
    @GetMapping("/listParentWithZero")
    public R  listParentWithZero(){

        List<LevelEntity> levelEntityList =levelService.list();
        //将所有层级关系放入hashmap中
        HashMap<Long, LevelEntity> levelMap = new HashMap<>();
        for (LevelEntity level : levelEntityList) {
            levelMap.put(level.getId(), level);
        }
        //对每一个level,通过他的parentid，将parent名放进去,对用户一样
        for (LevelEntity level : levelEntityList) {
            LevelEntity parent = levelMap.get(level.getParentId());
            if (Objects.nonNull(parent)) {
                level.setParentName(parent.getName());
            }
        }
        LevelEntity zero =new LevelEntity();
        zero.setLevel(0L);
        zero.setParentId((long) 0);
        zero.setId((long) 0);
        zero.setName("根层级");

        levelEntityList.add(zero);
        return R.ok().put("levelList",levelEntityList);
    }

    /**
     * 获取某一个层级的信息
     */
    @RequestMapping("/getById")
    public R getLevelById(@RequestParam("id") Integer id)
    {
        LevelEntity levelEntity=levelService.getById(id);
        return R.ok().put("levelEntity",levelEntity);
    }

    /**
     * 获取某一个层级的子层级
     */
    @RequestMapping("/getSonLevel")
    public R getSonLevel(@RequestParam("id") Long id)
    {
        List<LevelEntity> levelEntityList=levelService.getSonLevel(id);
        return R.ok().put("data",levelEntityList);
    }

    /**
     * 信息
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id){
		LevelEntity level = levelService.getById(id);

        return R.ok().put("level", level);
    }

    /**
     * 保存
     */
    @RequestMapping("/save")
    public R save(@RequestBody LevelEntity level){
        LevelEntity parent = levelService.getById(level.getParentId());
        level.setCreateDate(new Date());
        level.setUid(getUserId());
        if(parent!=null)
            level.setLevel(parent.getLevel()+1);
        else
        {
            level.setLevel(1L);
            level.setParentId(0L);
        }
        levelService.save(level);
        return R.ok();
    }

    /**
     * 修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody LevelEntity level){
        LevelEntity parent = levelService.getById(level.getParentId());
        level.setCreateDate(new Date());
        level.setUid(getUserId());
        if(parent!=null)
            level.setLevel(parent.getLevel()+1);
        else
        {
            level.setLevel(1L);
            level.setParentId(0L);
        }
		levelService.updateById(level);
        return R.ok();
    }

    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
		levelService.removeByIds(Arrays.asList(ids));

        return R.ok();
    }


    /**
     * 查询已启用的层级数，作为是否可以启用层级的标记
     */
    @RequestMapping("/getEnabledCount")
    public R queryEnabledCount()
    {
        Integer count = levelService.queryEnabledCount();
        return R.ok().put("enabledCount",count);
    }

    /**
     * 根据子层级id，进行其所有父层级的启用
     */
    @RequestMapping("/setEnabled")
    public R setEnabled(@RequestParam("id") Long id,@RequestParam("projectId") Long projectId)
    {
        //启用层级，分为4步：1.查出当前层级的所有父层级；2.进行父层级状态查询，没有表的直接返回错误信息；
        // 3.修改每一个表的enable标志,同时将parentid植入
        // 目前否定；4.将父层级加入到菜单表里面，暂定菜单名为层级名，属于menu_id为44的层级管理
//        Long parentId=44L;
        List<LevelEntity> enabledEntity= levelService.getAllParentById(id);
        for(LevelEntity level:enabledEntity)
        {
            if (level.getCreateTable()==0)
                return R.error().put("msg","当前层级或其父层级没有创建表格");
            else
                level.setEnabled(1);
            level.setProjectId(projectId);
        }
        if(!levelService.saveOrUpdateBatch(enabledEntity))
        {
            return R.error().put("msg","当前层级或其父层级启用状态修改失败");
        }
//        List<SysMenuEntity> menuList=new ArrayList<>();
//        int i=0;
//        for(LevelEntity level:enabledEntity)
//        {
//            SysMenuEntity menuEntity=new SysMenuEntity();
//            menuEntity.setParentId(parentId);
//            menuEntity.setName(level.getName());
//            menuEntity.setUrl("universalTable");
//            menuEntity.setType(1);
//            menuEntity.setOrderNum(++i);
//            menuEntity.setTableId(level.getId());
//            menuList.add(menuEntity);
//        }
//        if(!sysMenuService.saveBatch(menuList))
//        {
//            for(LevelEntity level:enabledEntity)
//            {
//                level.setEnabled(0);
//            }
//            if(!levelService.saveBatch(enabledEntity))
//            {
//                return R.error().put("msg","系统菜单插入失败，层级状态回滚失败");
//            }
//            return R.error().put("msg","系统菜单插入失败，层级状态已回滚");
//        }
        return R.ok();
    }

    /**
     * 清除所有启用信息
     */
    @RequestMapping("/clearEnabled")
    public R clclearEnabled()
    {
        //进行已启用层级的删除，分为3步：1.查找所有启用的层级 2.将这些层级的启用标志进行修改 3.从菜单页面删除url是universalTable的行
        String url="universalTable";
        List<LevelEntity> enabledLevelList=levelService.getEnabledLevels();
        for(LevelEntity level: enabledLevelList)
        {
            level.setEnabled(0);
            level.setProjectId(0L);
        }
        if(!levelService.saveOrUpdateBatch(enabledLevelList))
        {
            return R.error().put("msg","层级状态修改失败");
        }
        //目前暂不考虑菜单相关
//        if(!sysMenuService.deleteByURL(url))
//        {
//            return R.error().put("msg","删除菜单页面失败");
//        }

        return R.ok();
    }

    @RequestMapping("/isLeaf")
    public R isLeaf(@RequestParam("id") Long id)
    {
        /**
         * 通过判断启用的节点中，是否有节点的父节点id为传入参数，判断该节点是否为叶子
         * 叶子不会是其它的parent，所以一定为0
         * 因为是叶子，所以传真值，即1
         * 其它传0
         */
        Integer parentCount=levelService.queryEnabledCountWithParentId(id);
        if(parentCount.equals(0))
            return R.ok().put("data",0);
        else
            return R.ok().put("data",1);
    }

    @RequestMapping("/getEnabledSon")
    public R getEnabledSon(@RequestParam("id") Long id)
    {
        LevelEntity levelEntity=levelService.getEnabledSon(id);
        return R.ok().put("data",levelEntity);
    }

    @RequestMapping("/getParentList")
    public R gegetEnabledList(@RequestParam("id") Long id)
    {
        List<LevelEntity> parentList=levelService.getAllParentById(id);
        return R.ok().put("data",parentList);
    }

    /**
     * 为了防止出现同一父层级的多个子层级同时启用，因此需要在启用前对层级的父层级是否启用进行判断
     * 当enable=0时，代表不能启用，1时代表可以
     * @param id
     * @return
     */
    @RequestMapping("/enablebility")
    public R hasEnablebility(@RequestParam("id") Long id){
        List<LevelEntity> parentList=levelService.getAllParentById(id);
        for(LevelEntity level: parentList){
            if(level.getEnabled()==null || level.getEnabled()==0)
                continue;
            else
                return R.ok().put("enable",0);
        }
        return R.ok().put("enable",1);
    }
}
