package com.zcxk.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.zcxk.common.ToolUtil;
import com.zcxk.dao.*;
import com.zcxk.dto.TenantDto;
import com.zcxk.entity.*;
import com.zcxk.model.LoginUser;
import com.zcxk.service.TenantService;
import com.zcxk.util.Snowflake;
import com.zcxk.util.UserUtil;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;


/**
 * @description 租户管理实现类
 * @auto wangli
 * @data 2020-10-26 15:44
 */
@Service("tenantService")
public class TenantServiceImpl implements TenantService {
    /**
     * 租户
     */
     @Resource
     private TenantMapper tenantMapper;
    /**
     * 用户
     */
     @Resource
     private UserMapper userMapper;
    /**
     * 角色
     */
    @Resource
     private RoleMapper roleMapper;
    /**
     * 角色
     */
    @Resource
    private RoleMenuMapper roleMenuMapper;
    /**
     * 机构
     */
    @Resource
    private OrgMapper orgMapper;

    /**
     * 机构
     */
    @Resource
    private UserRoleMapper userRoleMapper;

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    @Override
    public TenantDto selectById(Integer id) {
        TenantDto tenantDto = tenantMapper.selectById(id);
        //获取租户菜单
        if(tenantDto != null){
            tenantDto.setTenantMenuIds(tenantMapper.selectTenantMenuIds(tenantDto.getCode()));
        }
        return tenantDto;
    }
    /**
     * 通过租户标识查询单条数据
     *
     * @param code 租户标识
     * @return 实例对象
     */
    public TenantDto selectByCode(String code){
        TenantDto tenantDto = tenantMapper.selectByCode(code);
        return tenantDto;
    }

    /**
     * 查询所有
     *
     * @return 实例对象的集合
     */
    @Override
    public List<TenantDto> selectAll() {
        return tenantMapper.selectAll();
    }

    /**
     * 根据条件查询
     *
     * @return 实例对象的集合
     */
    @Override
    public List<TenantDto> selectList(TenantDto tenantDto) {
        return tenantMapper.selectList(tenantDto);
    }

    /**
     * 新增数据
     *
     * @param tenantDto 实例对象
     * @return 实例对象
     */
    @Override
    public Integer insert(TenantDto tenantDto) {
        LoginUser loginUser = UserUtil.getCurrentUser();
        //创建租户信息
        if(loginUser != null){
            tenantDto.setUpdateBy(loginUser.getUsername());
            tenantDto.setCreateBy(loginUser.getUsername());
        }
        tenantDto.setDateCreate(new Date());
        tenantDto.setDateUpdate(new Date());
        tenantDto.setCode(Snowflake.generateId().toString());
        tenantDto.setStatus(1);
        tenantDto.setTenantState(1);
        tenantMapper.insert(tenantDto);

        //创建租户菜单信息
        if(tenantDto.getTenantMenuIds().size()>0){
            tenantMapper.createTenantMenu(tenantDto.getCreateBy(),tenantDto.getCode(),tenantDto.getTenantMenuIds());
        }
        //创建角色
        Role role = new Role();
        role.setRoleName(tenantDto.getTenantName());
        role.setDescription(tenantDto.getTenantName() +"初始化角色");
        role.setRoleState(1);
        role.setPermissionType(2);
        role.setTenantId(tenantDto.getCode());
        role.setCreateBy(loginUser.getUsername());
        role.setDateCreate(new Date());
        role.setStatus(1);
        //插入角色
        roleMapper.insert(role);
        //插入角色菜单（租户菜单id）
        Integer roleId =role.getId();
        List<Integer> menuIds = tenantDto.getTenantMenuIds();
        List<RoleMenu>menus=new ArrayList<>();
        roleMapper.deleteRoleMenu(role);
        menuIds.forEach(id->{
            RoleMenu roleMenu=new RoleMenu();
            roleMenu.setRoleId(roleId);
            roleMenu.setMenuId(id);
            roleMenu.setStatus(1);
            menus.add(roleMenu);
        });
        if(menus.size()>0){
            roleMenuMapper.batchInsert(menus);
        }


//        roleService.updateRoleMenuRelations(roleRequestDto);

        /*创建机构*/
        Org org = new Org();
        org.setTenantId(tenantDto.getCode());
        org.setOrgLeaderName(tenantDto.getUserName());
        org.setOrgLeaderPhone(tenantDto.getPhone());
        org.setOrgName(tenantDto.getTenantName());
        org.setOrgState(1);
        org.setOrgType("company");  //机构类型
        org.setParentId(0);
        org.setCreateBy(loginUser.getUsername());
        org.setDateCreate(new Date());
        org.setStatus(1);
        org.setParentOrgId(0);
        orgMapper.insert(org);


        //创建管理员信息
        UserEntity userEntity =new UserEntity();
        userEntity.setTenantId(tenantDto.getCode());
        userEntity.setCreateBy(tenantDto.getCreateBy());
        userEntity.setDateCreate(new Date());
        userEntity.setUpdateBy(tenantDto.getUpdateBy());
        userEntity.setDateUpdate(new Date());
        userEntity.setStatus(1);
        userEntity.setPhone(tenantDto.getPhone());
        userEntity.setUsername(tenantDto.getUserName());
        userEntity.setUserType("-999");//租户系统管理员
        userEntity.setRoleId(role.getId().longValue()); //赋值角色
        userEntity.setCompanyOrgId(org.getId().longValue());//公司
//        userEntity.setDeptOrgId(org.getId().longValue());//机构
        userEntity.setEnableState("1");
        userMapper.insert(userEntity);

        UserRoleEntity userRoleEntity = new UserRoleEntity();
        userRoleEntity.setCreateBy(userEntity.getCreateBy());
        userRoleEntity.setUpdateBy(userEntity.getUpdateBy());
        userRoleEntity.setDateCreate(userEntity.getDateCreate());
        userRoleEntity.setDateUpdate(userEntity.getDateUpdate());
        userRoleEntity.setStatus(1);
        userRoleEntity.setRoleId(Long.valueOf(userEntity.getRoleId()));
        userRoleEntity.setUserId(userEntity.getId());
        userRoleMapper.insert(userRoleEntity);


        return 1;
    }


    /**
     * 修改数据
     *
     * @param tenantDto 实例对象
     * @return 实例对象
     */
    @Override
    public int update(TenantDto tenantDto) {
        LoginUser loginUser = UserUtil.getCurrentUser();
        if(tenantDto.getId() == null){
            return 0;
        }
        //修改租户信息
        if(loginUser != null){
            tenantDto.setUpdateBy(loginUser.getUsername());
        }
        tenantDto.setDateUpdate(new Date());

        tenantMapper.update(tenantDto);

        //修改租户菜单信息
        //界面传回的租户菜单id
        List<Integer > newTenantMenuIds = tenantDto.getTenantMenuIds();
        //数据库中已存在的租户菜单id
        List<Integer > oldTenantMenuIds = tenantMapper.selectTenantMenuIds(tenantDto.getCode());
        //相同的暂时不改动

        //新增的菜单id（需要新增的）
        List<Integer> addTenantMenuIds = newTenantMenuIds.stream().filter(item -> !oldTenantMenuIds.contains(item)).collect(Collectors.toList());
        //创建租户菜单信息
        if(addTenantMenuIds.size()>0){
            tenantMapper.createTenantMenu(tenantDto.getUpdateBy(),tenantDto.getCode(),addTenantMenuIds);
        }
        //去掉的菜单id(需要删除的)
        List<Integer> deleteTenantMenuIds = oldTenantMenuIds.stream().filter(item -> !newTenantMenuIds.contains(item)).collect(Collectors.toList());
        if(deleteTenantMenuIds.size()>0){
            tenantMapper.deleteTenantMenuIds(tenantDto.getCode(),deleteTenantMenuIds);
        }
        //修改管理员信息
        UserEntity userEntity =userMapper.findUserById(tenantDto.getUserId());
        userEntity.setUpdateBy(tenantDto.getUpdateBy());
        userEntity.setDateUpdate(new Date());
        userEntity.setPhone(tenantDto.getPhone());
        userEntity.setUsername(tenantDto.getUserName());
        userEntity.setEnableState("1");
        userMapper.updateById(userEntity);


        //创建角色

        Role role = roleMapper.selectById(userEntity.getRoleId().intValue());
        role.setRoleName(tenantDto.getTenantName());
        role.setDescription(tenantDto.getTenantName() +"初始化角色");
        role.setCreateBy(loginUser.getUsername());
        role.setDateUpdate(new Date());
        //更新角色
        roleMapper.update(role);
        //更新角色菜单（租户菜单id）
        Integer roleId =role.getId();
        List<RoleMenu>menus=new ArrayList<>();
        roleMapper.deleteRoleMenu(role);
        newTenantMenuIds.forEach(id->{
            RoleMenu roleMenu=new RoleMenu();
            roleMenu.setRoleId(roleId);
            roleMenu.setMenuId(id);
            roleMenu.setStatus(1);
            roleMenu.setDateCreate(new Date());
            roleMenu.setCreateBy(tenantDto.getUpdateBy());
            roleMenu.setDateUpdate(new Date());
            roleMenu.setUpdateBy(tenantDto.getUpdateBy());
            menus.add(roleMenu);
        });
        if(menus.size()>0){
            roleMenuMapper.batchInsert(menus);
        }
        return 1;
    }

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 是否成功
     */
    @Override
    public int deleteById(Integer id) {
        TenantDto tenantDto = tenantMapper.selectById(id);
        //先删除租户菜单
        tenantMapper.deleteTenantMenuIds(tenantDto.getCode(),null);
        //删除用户信息
        tenantMapper.deleteUserByTenantId(id);
        return tenantMapper.deleteById(id);
    }

    /**
     * 查询总数据数
     *
     * @return 数据总数
     */
    @Override
    public int count() {
        return tenantMapper.count();
    }

    /**
     * 分页查询
     *
     * @return 对象列表
     */
    @Override
    public IPage<TenantDto> selectPage(IPage<TenantDto> page, TenantDto tenantDto) {
        return tenantMapper.selectPage(page, tenantDto);
    }

    public boolean checkTenantNameUnique(TenantDto tenantDto) {
        List<Integer> tenantIds = tenantMapper.countIds(tenantDto.getTenantName());

        if(tenantIds.size()>1){ //名字匹配多个结果
            return true;
        }else if(tenantIds.size() == 0 ){   //没有匹配的结果
            return false;
        }else if(ToolUtil.isEmpty(tenantDto.getId())){  //新增情况匹配到一个结果
            return true;
        }else if(!tenantDto.getId().equals(tenantIds.get(0))){ //修改时匹配到一个结果，但id不相等
            return true;
        }else { //修改时匹配到一个结果且id相等
            return false;
        }

    }

}