package com.fzzy.sys.controller.system;

import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.*;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.ShiroUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.framework.shiro.service.SysPasswordService;
import com.ruoyi.system.domain.SysCompany;
import com.ruoyi.system.service.*;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.stream.Collectors;

/**
 * 组织管理
 *
 * @author andy
 */
@Controller
@RequestMapping("/system/company")
public class SysCompanyController extends BaseController {

    private String prefix = "system/company";

    @Autowired
    private ISysCompanyService companyService;
    @Autowired
    private ISysDeptService deptService;
    @Autowired
    private ISysRoleService roleService;
    @Autowired
    private SysPasswordService passwordService;

    @Autowired
    private ISysUserService userService;
    @Autowired
    private ISysDictTypeService dictTypeService;
    @Autowired
    private ISysDictDataService dictDataService;
    @Autowired
    private ISysMenuService menuService;

    @RequiresPermissions("system:company:view")
    @GetMapping()
    public String config() {
        return prefix + "/company";
    }

    /**
     * 查询参数配置列表
     */
    @RequiresPermissions("system:company:list")
    @PostMapping("/list")
    @ResponseBody
    public TableDataInfo list(SysCompany company) {

        if (null == company.getCompanyId()) {
            company.setCompanyId(ShiroUtils.getLoginUserCompanyId());
        }

        startPage();
        List<SysCompany> list = companyService.selectAll();

        return getDataTable(list);
    }

    @Log(title = "参数管理", businessType = BusinessType.EXPORT)
    @RequiresPermissions("system:company:export")
    @PostMapping("/export")
    @ResponseBody
    public AjaxResult export(SysCompany config) {

        List<SysCompany> list = companyService.selectAll();

        ExcelUtil<SysCompany> util = new ExcelUtil<SysCompany>(SysCompany.class);

        return util.exportExcel(list, "参数数据");
    }

    /**
     * 新增参数配置
     */
    @GetMapping("/add")
    public String add() {
        return prefix + "/add";
    }

    /**
     * 新增保存参数配置
     */
    @RequiresPermissions("system:company:add")
    @Log(title = "参数管理", businessType = BusinessType.INSERT)
    @PostMapping("/add")
    @ResponseBody
    public AjaxResult addSave(@Validated SysCompany company) {
        if (!companyService.checkCompanyIdUnique(company)) {
            return error("新增参数'" + company.getName() + "'失败，参数键名已存在");
        }
        company.setCreateBy(getLoginName());

        //新增组织
        int res = companyService.insertCompany(company);
        //新增组织后的联动操作，创建部门，用户，角色，菜单，字典
        createCompanyStep(company);

        return toAjax(res);
//        return toAjax(companyService.insertCompany(company));
    }

    /**
     * 修改参数配置
     */
    @RequiresPermissions("system:company:edit")
    @GetMapping("/edit/{companyId}")
    public String edit(@PathVariable("companyId") String companyId, ModelMap mmap) {
        mmap.put("company", companyService.selectCompanyById(companyId));
        return prefix + "/edit";
    }

    /**
     * 修改保存参数配置
     */
    @RequiresPermissions("system:company:edit")
    @Log(title = "参数管理", businessType = BusinessType.UPDATE)
    @PostMapping("/edit")
    @ResponseBody
    public AjaxResult editSave(@Validated SysCompany company) {
        if (!companyService.checkCompanyIdUnique(company)) {
            return error("修改参数'" + company.getName() + "'失败，参数键名已存在");
        }
        company.setUpdateBy(getLoginName());
        return toAjax(companyService.updateCompany(company));
    }

    /**
     * 删除参数配置
     */
    @RequiresPermissions("system:company:remove")
    @Log(title = "参数管理", businessType = BusinessType.DELETE)
    @PostMapping("/remove")
    @ResponseBody
    public AjaxResult remove(String ids) {
        companyService.deleteCompanyByIds(ids);
        return success();
    }

    /**
     * 刷新参数缓存
     */
    @RequiresPermissions("system:company:remove")
    @Log(title = "参数管理", businessType = BusinessType.CLEAN)
    @GetMapping("/refreshCache")
    @ResponseBody
    public AjaxResult refreshCache() {
        companyService.resetCompanyCache();
        return success();
    }

    /**
     * 校验参数键名
     */
    @PostMapping("/checkCompanyIdUnique")
    @ResponseBody
    public boolean checkCompanyIdUnique(SysCompany config) {
        return companyService.checkCompanyIdUnique(config);
    }




    /**
     * 新增组织后的联动操作，创建部门，用户，角色，菜单，字典
     * @param company
     */
    private void createCompanyStep(SysCompany company){
        //新增组织复制字典信息
        copyDict(company);
        //新增组织复制菜单信息
        List<SysMenu> menus = copyMenu(company);
        //新增组织顶级部门
        SysDept dept = addDept(company);
        //新增组织角色超级管理员，并添加角色权限菜单信息
        SysRole role = addRole(company,menus);
        //新增组织管理用户，并更新用户超级管理员角色权限信息
        addUser(company,dept,role);

    }


    /**
     * 新增组织添加顶级部门信息
     * @param company
     */
    private SysDept addDept(SysCompany company){
        //查看是否存在顶级部门，存在则不进行创建
        SysDept dept = new SysDept();
        dept.setCompanyId(company.getCompanyId());
        List<SysDept> depts = deptService.selectDeptList(dept);
        if(depts != null && depts.size() > 0){
            dept = depts.get(0);
            return dept;
        }

        dept = new SysDept();
        dept.setCompanyId(company.getCompanyId());
        dept.setDeptId(Long.parseLong(company.getCompanyId()));
        dept.setParentId(0L);
        dept.setAncestors("0");
        dept.setDeptName(company.getName());
        dept.setOrderNum(0);
        dept.setStatus("0");
        dept.setDelFlag("0");
        dept.setCreateBy(company.getName());
        deptService.insertDept(dept);

        //防止like查询，提高查询效率
        dept.setDeptName(null);
        depts = deptService.selectDeptList(dept);
        if(depts != null && depts.size() > 0){
            dept = depts.get(0);
        }
        return dept;
    }

    /**
     * 新增组织添加超级管理员角色
     * @param company
     */
    private SysRole addRole(SysCompany company, List<SysMenu> menus){
        //查看是否存在管理员权限信息，存在则不进行创建
        SysRole role = new SysRole();
        role.setCompanyId(company.getCompanyId());
        List<SysRole> roles = roleService.selectRoleList(role);
        if(roles != null && roles.size() > 0){
            role = roles.get(0);
            return role;
        }

        role = new SysRole();
        role.setCompanyId(company.getCompanyId());
        role.setRoleName("超级管理员");
        role.setRoleKey("admin" + company.getCompanyId());
        role.setRoleSort("0");
        role.setDataScope("1");
        role.setStatus("0");
        role.setDelFlag("0");
        role.setRemark("超级管理员");
        role.setCreateBy(company.getName());

        //封装菜单ID信息
        Long[]  menuIds = menus.stream().map(SysMenu::getMenuId).toArray(Long[]::new);
        role.setMenuIds(menuIds);
        roleService.insertRole(role);

        role = new SysRole();
        role.setCompanyId(company.getCompanyId());
        roles = roleService.selectRoleList(role);
        if(roles != null && roles.size() > 0){
            role = roles.get(0);
        }
        return role;
    }

    /**
     * 新增组织添加默认登陆用户
     * @param company
     */
    private void addUser(SysCompany company,SysDept dept,SysRole role){
        SysUser user = new SysUser();
        user.setCompanyId(company.getCompanyId());
        user.setUserName("系统管理员");
        user.setDeptId(dept.getDeptId());
        //默认登陆账号：admin+companyId
        user.setLoginName("admin" + company.getCompanyId());
        //默认登陆密码：admin+companyId
        user.setPassword("admin" + company.getCompanyId());
        user.setSalt(ShiroUtils.randomSalt());
//        密码加密
        user.setPassword(passwordService.encryptPassword(user.getLoginName(), user.getPassword(), user.getSalt()));
        user.setPwdUpdateDate(DateUtils.getNowDate());
        user.setUserType("00");
        user.setSex("2");
        user.setStatus("0");
        user.setDelFlag("0");
        user.setRemark("默认管理用户");
        user.setCreateBy(company.getName());

        //配置该用户的权限信息
        Long[] roleIds = new Long[1];
        roleIds[0] = role.getRoleId();
        user.setRoleIds(roleIds);

        userService.insertUser(user);

//        //查询该组织下的用户
//        user = new SysUser();
//        user.setCompanyId(company.getCompanyId());
//        List<SysUser> users = userService.selectUserList(user);
//        if(users != null && users.size() > 0){
//            user = users.get(0);
//        }
//
//        //框架中impl实现方法，但是没有在service中做成接口
//        // 位置SysUserServiceImpl：315行
//        userService.insertUserRole(user.getUserId(),roleIds);
    }


    /**
     * 新增组织复制字典信息
     * @param company
     */
    private void copyDict(SysCompany company){
        String companyId = ShiroUtils.getLoginUserCompanyId();
        //查看组织下是否存在字典信息，存在则不进行复制
        List<SysDictType> dictTypes = dictTypeService.selectDictTypeAll(company.getCompanyId());
        if(dictTypes == null || dictTypes.size() < 1){
            //复制字典类型表 sys_dict_type
            List<SysDictType> dictTypeSource = dictTypeService.selectDictTypeAll(companyId);
            if(dictTypeSource != null && dictTypeSource.size() > 0){
                SysDictType dictType = null;
                for(SysDictType dict : dictTypeSource){
                    dictType = new SysDictType();
                    dictType.setCompanyId(company.getCompanyId());
//                data.setDictId(dict.getDictId());
                    dictType.setDictName(dict.getDictName());
                    dictType.setDictType(dict.getDictType());
                    dictType.setStatus("0");
                    dictType.setRemark(dict.getRemark());
                    dictType.setCreateBy(company.getName());

                    dictTypeService.insertDictType(dictType);
                }
            }
        }


        //复制字典数据表 sys_dict_data
        SysDictData dictData = new SysDictData();
        dictData.setCompanyId(company.getCompanyId());
        //查看组织下是否存在字典信息，存在则不进行复制
        List<SysDictData> dictDatas = dictDataService.selectDictDataList(dictData);
        if(dictDatas == null || dictDatas.size() < 1){
            dictData.setCompanyId(companyId);
            List<SysDictData> dictDataSource = dictDataService.selectDictDataList(dictData);
            if(dictDataSource != null && dictDataSource.size() > 0){
                dictData = null;
                for(SysDictData dict : dictDataSource){
                    dictData = new SysDictData();
                    dictData.setCompanyId(company.getCompanyId());
//                dictData.setDictCode(dict.getDictCode());
                    dictData.setDictSort(dict.getDictSort());
                    dictData.setDictLabel(dict.getDictLabel());
                    dictData.setDictValue(dict.getDictValue());
                    dictData.setDictType(dict.getDictType());
                    dictData.setCssClass(dict.getCssClass());
                    dictData.setListClass(dict.getListClass());
                    dictData.setIsDefault(dict.getIsDefault());
                    dictData.setStatus("0");
                    dictData.setRemark(dict.getRemark());
                    dictData.setCreateBy(company.getName());

                    dictDataService.insertDictData(dictData);
                }
            }
        }



    }

    /**
     * 新增组织复制菜单权限表
     * 单独创建一个系统内置的用户，用来进行菜单复制
     * @param company
     */
    private List<SysMenu> copyMenu(SysCompany company){
        //复制菜单权限表 sys_menu
        SysMenu menuParam = new SysMenu();
        menuParam.setCompanyId(company.getCompanyId());
        //根据组织号查询菜单列表，查看组织下是否存在菜单信息，存在则不进行复制
        List<SysMenu> list = menuService.selectBySysMenu(menuParam);
        if(list == null || list.size() < 1){
            menuParam.setCompanyId(ShiroUtils.getLoginUserCompanyId());
            Long userId = 1L;
            //获取目标用户下的所有菜单信息
            List<SysMenu> menus = menuService.selectMenuList(menuParam, userId);
            List<SysMenu> menuSource = ChildPerms(menus, 0L);
            //复制菜单
            copyChildMenu(menuSource,0L,company);
        }
        //查询并返回新插入的菜单信息
        menuParam = new SysMenu();
        menuParam.setCompanyId(company.getCompanyId());
        //根据组织号查询菜单列表
        List<SysMenu> res = menuService.selectBySysMenu(menuParam);
        return res;
    }

    private List<SysMenu> ChildPerms(List<SysMenu> menus, Long parentId){
        if(menus != null && menus.size() > 0){
            //获取所有该父节点的list
            List<SysMenu> res = menus.stream().filter(c -> c.getParentId().equals(parentId)).collect(Collectors.toList());
            if(res == null || res.size() < 1){
                return null;
            }
            for(SysMenu menu : res){
                List<SysMenu> child = ChildPerms(menus,menu.getMenuId());
                if(child != null && child.size() > 0){
                    menu.setChildren(child);
                }
            }
            return res;
        }else{
            return null;
        }
    }

    private void copyChildMenu(List<SysMenu> menus,Long parentId,SysCompany company){
        if(menus != null && menus.size() > 0){
            SysMenu data = null;
            SysMenu param = new SysMenu();
            for(SysMenu menu : menus){
                data = new SysMenu();
                data.setCompanyId(company.getCompanyId());
//                data.setMenuId(menu.getMenuId());
                data.setMenuName(menu.getMenuName());
                data.setParentId(parentId);
                data.setOrderNum(menu.getOrderNum());
                data.setUrl(menu.getUrl());
                data.setTarget(menu.getTarget());
                data.setMenuType(menu.getMenuType());
                data.setVisible(menu.getVisible());
                data.setIsRefresh(menu.getIsRefresh());
                data.setPerms(menu.getPerms());
                data.setIcon(menu.getIcon());
                data.setRemark(menu.getRemark());
                data.setCreateBy(company.getName());
                menuService.insertMenu(data);

                param.setCompanyId(company.getCompanyId());
                param.setParentId(parentId);
                //查询排序，id自增长，以id逆序排序，则第一个就是新插入的菜单
                List<SysMenu> list = menuService.selectBySysMenu(param);
                if(list != null){
                    SysMenu parentMenu = list.get(0);
                    copyChildMenu(menu.getChildren(),parentMenu.getMenuId(),company);
                }
            }
        }
    }
}