package com.nanjing.water.service;

import com.nanjing.water.common.ConstantFactory;
import com.nanjing.water.common.ExecutedResult;
import com.nanjing.water.common.PagerResult;
import com.nanjing.water.common.jwt.JWTUtil;
import com.nanjing.water.common.jwt.LoginUserDTO;
import com.nanjing.water.common.model.Tuple;
import com.nanjing.water.common.security.MD5Util;
import com.nanjing.water.common.util.*;
import com.nanjing.water.entity.enums.EState;
import com.nanjing.water.entity.enums.EUserType;
import com.nanjing.water.entity.request.ReqChangePassword;
import com.nanjing.water.entity.request.adminuser.ReqAdminLogin;
import com.nanjing.water.entity.request.adminuser.ReqCreateAdminUser;
import com.nanjing.water.entity.request.adminuser.ReqModifyAdminUser;
import com.nanjing.water.entity.request.adminuser.ReqSetListRole4Admin;
import com.nanjing.water.entity.response.admin.ResAdminLogin;
import com.nanjing.water.entity.response.admin.ResAdminMenuTreeAndPermission;
import com.nanjing.water.entity.response.admin.ResAdminPower;
import com.nanjing.water.entity.search.SearchAdminUser;
import com.nanjing.water.repository.impl.*;
import com.nanjing.water.repository.po.*;
import com.nanjing.water.repository.vo.AdminRoleVO;
import com.nanjing.water.repository.vo.AdminUserVO;
import com.nanjing.water.service.cache.AdminMenuService;
import com.nanjing.water.service.cache.AdminPermissionService;
import com.nanjing.water.service.convert.AdminMenuConvert;
import com.nanjing.water.service.convert.AdminPermissionConvert;
import com.nanjing.water.service.convert.AdminRoleConvert;
import com.nanjing.water.service.convert.AdminUserConvert;
import com.nanjing.water.service.dto.ResAdminDetail;
import com.wf.captcha.SpecCaptcha;
import org.apache.commons.lang3.BooleanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Service
public class AdminService extends BaseService {
    private static final List<Integer> LIST_ADMIN_TYPE = Arrays.asList(
            EUserType.ADMIN.getValue(),
            EUserType.ADMIN_USER.getValue()
    );

    @Autowired
    private AdminUserMapperImpl dao;
    @Autowired
    private AdminMenuMapperImpl menusDao;
    @Autowired
    private AdminPermissionMapperImpl permissionDao;
    @Autowired
    private AdminRoleMapperImpl roleDao;
    @Autowired
    private AdminRoleMenuRelationMapperImpl roleMenuRelationDao;
    @Autowired
    private AdminRolePermissionRelationMapperImpl rolePermissionRelationDao;
    @Autowired
    private AdminRoleRelationMapperImpl adminRoleRelationDao;

    @Autowired
    private AdminMenuService menusService;
    @Autowired
    private AdminPermissionService permissionService;
    @Autowired
    private AdminPowerService adminPowerService;
    @Autowired
    private StringRedisTemplate redisTemplate;


    // 添加后台管理员
    public ExecutedResult<Long> createAdmin(ReqCreateAdminUser request) {
        AdminUserPO find = dao.get4Name(request.getUserName());
        if (Objects.nonNull(find)) {
            return ExecutedResult.failed("管理员帐号已存在。" + request.getUserName());
        }
        AdminUserPO item = AdminUserConvert.INSTANCE.toCreate(request);
        item.setUserRelId(0L);
        item.setNickName(ParameterUtil.dealNullStr(request.getNickName()));
        item.setHeadImg(ParameterUtil.dealNullStr(request.getHeadImg()));
        item.setEmail(ParameterUtil.dealNullStr(request.getEmail()));
        item.setContact(ParameterUtil.dealNullStr(request.getContact()));
        // 密码加密
        item.setPassword(MD5Util.encrypt(request.getPassword() + ConstantFactory.KEY_PASSWORD));
        item.setStatus(EState.NORMAL.getValue());
        item.setCreateTime(LocalDateTimeUtil.nowTimeStamp());
        int rowCount = dao.insert(item);
        if (rowCount == 1) {
            return ExecutedResult.success(item.getId());
        }
        return ExecutedResult.failed("添加[管理员]失败。");
    }

    // 修改后台管理员
    public ExecutedResult<String> modify(ReqModifyAdminUser request) {
        ExecutedResult<AdminUserPO> check = this.check4Id(request.getId());
        if (check.isFailed()) {
            return ExecutedResult.failed(check.getMsg(), check.getMsgCode());
        }

        AdminUserPO item = new AdminUserPO();
        item.setId(request.getId());
        item.setNickName(ParameterUtil.dealNullStr(request.getNickName()));
        item.setHeadImg(ParameterUtil.dealNullStr(request.getHeadImg()));
        item.setContact(ParameterUtil.dealNullStr(request.getContact()));
        item.setEmail(ParameterUtil.dealNullStr(request.getEmail()));
        item.setStatus(request.getStatus());
        int rowCount = dao.updateById(item);
        if (rowCount == 1) {
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("编辑[管理员]失败。");
    }

    // 获取指定管理员详情
    public ExecutedResult<ResAdminDetail> detail(Long adminId) {
        ExecutedResult<AdminUserPO> check = this.check4Id(adminId);
        if (check.isFailed()) {
            return ExecutedResult.failed(check.getMsg(), check.getMsgCode());
        }
        ResAdminDetail result = AdminUserConvert.INSTANCE.toDetail(check.getData());

        result.setListRole(new ArrayList<>());
        //找到角色已有的菜单列表
        List<AdminRoleRelationPO> listRoleRel = adminRoleRelationDao.list4Admin(adminId);
        if (ListUtil.isNotNullOrEmpty(listRoleRel)) {
            List<Long> listRoleId = listRoleRel.stream()
                    .map(AdminRoleRelationPO::getRoleId)
                    .collect(Collectors.toList());
            List<AdminRolePO> listRole = roleDao.getList(listRoleId);
            result.setListRole(AdminRoleConvert.INSTANCE.toVo(listRole));
        }
        return ExecutedResult.success(result);
    }

    // 管理员登录
    public ExecutedResult<ResAdminLogin> adminLogin(ReqAdminLogin request) throws Exception {
        Integer maxNumber = 3;
        AdminUserPO user = dao.get4Name(request.getUserName());
        //获取缓存中的验证码
        String realCode = redisTemplate.opsForValue().get(request.getUuid());
        if (realCode == null) {
            return ExecutedResult.failed("验证码已失效，请重新获取~");
        }
        // 验证码校验
        if (!request.getCode().equalsIgnoreCase(realCode)) {
            return ExecutedResult.failed("验证码错误");
        }
        //获取缓存中设备码
        String machineCode = redisTemplate.opsForValue().get(request.getMachineCode());
        if (StringUtil.isNotNullOrEmpty(machineCode) && Integer.valueOf(machineCode) >= maxNumber) {
            return ExecutedResult.failed("登录次数限制，请10分钟后重新登录！");
        }
        if (checkPassword(user, request.getPassword())) {
            // 构建登录用户
            LoginUserDTO loginUser = new LoginUserDTO();
            loginUser.setUserId(user.getId().toString());
            loginUser.setUserType(user.getUserType());
            loginUser.setNickName(user.getNickName());
            loginUser.setPhone(user.getContact());
            // 保存用户信息到jwt
            String token = JWTUtil.getToken(loginUser);
            ResAdminLogin result = this.getListPower4Admin(user);
            result.setName(user.getNickName());
            result.setToken(token);
            return ExecutedResult.success(result);
        } else {
            Integer newAttempts = StringUtil.isNullOrEmpty(machineCode) ? 1 : Integer.valueOf(machineCode) + 1;
            redisTemplate.opsForValue().set(request.getMachineCode(), newAttempts.toString());
            redisTemplate.expire(request.getMachineCode(), 10, TimeUnit.MINUTES);
        }


        return ExecutedResult.failed("账号或密码错误!");
    }

    private static boolean checkPassword(AdminUserPO user, String passWord) throws Exception {
        if (Objects.isNull(user)) {
            return false;
        }
        if (BooleanUtils.isFalse(Objects.equals(user.getStatus(), EState.NORMAL.getValue()))) {
            return false;
        }
        if (BooleanUtils.isFalse(MD5Util.encrypt(passWord + ConstantFactory.KEY_PASSWORD).equals(user.getPassword()))) {
            return false;
        }
        return true;
    }

    /**
     * 生成验证码图片并返回其 Base64 编码字符串
     *
     * @param uuid 用于标识验证码的唯一标识符
     * @return 包含验证码图片 Base64 编码的响应结果
     */
    public ExecutedResult<String> generate(String uuid) {
        SpecCaptcha specCaptcha = new SpecCaptcha(100, 30, 4);
        // captcha.setCharType(Captcha.TYPE_DEFAULT);
        String code = specCaptcha.text().toLowerCase();
        // 缓存验证码
        redisTemplate.opsForValue().set(uuid, code);
        // 设置验证码3分钟后过期
        redisTemplate.expire(uuid, 3, TimeUnit.MINUTES);
        return ExecutedResult.success(specCaptcha.toBase64());
    }

    // 获取管理员权限列表
    public ExecutedResult<ResAdminPower> getPower(Long adminId) {
        ResAdminPower result = new ResAdminPower();
        result.setMenus(new ArrayList<>());

        ExecutedResult<AdminUserPO> check = this.check4Id(adminId);
        if (check.isFailed()) {
            return ExecutedResult.success(result);
        }
        AdminUserPO user = check.getData();

        List<AdminMenuPO> listMenu;
        List<AdminPermissionPO> listPermission = null;
        // 超级管理员有所有权限
        if (Objects.equals(user.getUserType(), EUserType.ADMIN.getValue())) {
            listMenu = menusService.listAllWithCache();
            listPermission = permissionService.listAllWithCache();
        } else {
            //找到角色已有的菜单列表
            List<AdminRoleRelationPO> listRole = adminRoleRelationDao.list4Admin(adminId);
            if (ListUtil.isNullOrEmpty(listRole)) {
                return ExecutedResult.success(result);
            }
            List<Long> listRoleId = listRole.stream()
                    .map(AdminRoleRelationPO::getRoleId)
                    .collect(Collectors.toList());

            listMenu = menusService.listUserAllWithCache(adminId, listRoleId, adminPowerService::getListMenu4Role);
            listPermission = permissionService.listUserAllWithCache(adminId, listRoleId, adminPowerService::getListPermission4Role);
        }
        if (ListUtil.isNotNullOrEmpty(listMenu)) {
            // 筛选状态
            listMenu = listMenu.stream()
                    .filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
                    .collect(Collectors.toList());
            result.setMenus(AdminMenuConvert.INSTANCE.toVo(listMenu));
        }
        if (ListUtil.isNotNullOrEmpty(listPermission)) {
            // 筛选状态
            listPermission = listPermission.stream()
                    .filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
                    .collect(Collectors.toList());
            result.setPermissions(AdminPermissionConvert.INSTANCE.toDetail(listPermission));
        }
        return ExecutedResult.success(result);
    }

    // 修改密码
    public ExecutedResult<String> changePassword(LoginUserDTO user, ReqChangePassword request) {
        Long adminId = NumericUtil.tryParseLong(user.getUserId(), 0L);
        ExecutedResult<AdminUserPO> check = this.check4Id(adminId);
        if (check.isFailed()) {
            return ExecutedResult.failed(check.getMsg(), check.getMsgCode());
        }
        String oldPass = MD5Util.encrypt(request.getOldPassword() + ConstantFactory.KEY_PASSWORD);
        if (BooleanUtils.isFalse(oldPass.equals(check.getData().getPassword()))) {
            return ExecutedResult.failed("密码校验失败。");
        }
        return this.changePasswordDo(adminId, request.getNewPassword());
    }

    private ExecutedResult<String> changePasswordDo(Long adminId, String password) {
        AdminUserPO item = new AdminUserPO();
        item.setId(adminId);
        // 密码加密
        item.setPassword(MD5Util.encrypt(password + ConstantFactory.KEY_PASSWORD));
        int rowCount = dao.updateById(item);
        if (rowCount == 1) {
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("密码修改失败。");
    }

    // 重置密码
    public ExecutedResult<String> resetPassword(Long adminId) {
        ExecutedResult<AdminUserPO> check = this.check4Id(adminId);
        if (check.isFailed()) {
            return ExecutedResult.failed(check.getMsg(), check.getMsgCode());
        }
        String pass = RandVerifyCode.complexCode(8);
        ExecutedResult<String> changePasswordDo = this.changePasswordDo(adminId, pass);
        if (changePasswordDo.isFailed()) {
            return changePasswordDo;
        }
        return ExecutedResult.success(pass);
    }

    // 分页查询所有管理员
    public ExecutedResult<PagerResult<AdminUserVO>> search(SearchAdminUser request) {
        List<AdminUserVO> result = new ArrayList<>();

        super.dealPager(request);
        request.setLastRowNo((request.getPage() - 1) * NumericUtil.tryParseLong(request.getLimit()));
        // 处理时间范围
        Tuple<String, String> createTimeRange = ParameterUtil.getTimeRange(request.getCreateTimeRange());
        if (StringUtil.isNotNullOrEmpty(createTimeRange.getItem1())) {
            request.setCreateTimeStart(LocalDateTimeUtil.getTimeStamp(createTimeRange.getItem1()).getTime());
        }
        if (StringUtil.isNotNullOrEmpty(createTimeRange.getItem2())) {
            request.setCreateTimeEnd(LocalDateTimeUtil.getTimeStamp(createTimeRange.getItem2()).getTime());
        }

        PagerResult<AdminUserPO> pagerResult = dao.search(request);

        if (NumericUtil.tryParseLong(pagerResult.getTotal()).compareTo(0L) < 1) {
            return ExecutedResult.success(
                    new PagerResult<>(request.getLimit(), request.getPage(), 0L, new ArrayList<>())
            );
        }
        List<AdminUserPO> list = pagerResult.getList();
        Long lastId = 0L;
        if (ListUtil.isNotNullOrEmpty(list)) {
            lastId = list.stream().map(AdminUserPO::getId).min(Comparator.comparing(c -> c)).get();

            list.forEach(item -> {
                AdminUserVO vo = AdminUserConvert.INSTANCE.toVo(item);
                result.add(vo);
            });
        }
        PagerResult<AdminUserVO> view = new PagerResult<>(request.getLimit(), request.getPage(), pagerResult.getTotal(), result);
        view.setLastId(lastId);
        return ExecutedResult.success(view);
    }

    public ExecutedResult<String> stop(Long id) {
        // 验证记录是否存在
        ExecutedResult<AdminUserPO> checkExists = this.check4Id(id);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }
        AdminUserPO item = new AdminUserPO();
        item.setId(id);
        item.setStatus(EState.DISABLED.getValue());

        int rowCount = this.dao.updateById(item);
        if (rowCount == 1) {
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("停用[管理员]失败。");
    }

    public ExecutedResult<String> enable(Long id) {
        // 验证记录是否存在
        ExecutedResult<AdminUserPO> checkExists = this.check4Id(id);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }
        AdminUserPO item = new AdminUserPO();
        item.setId(id);
        item.setStatus(EState.NORMAL.getValue());

        int rowCount = this.dao.updateById(item);
        if (rowCount == 1) {
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("启用[管理员]失败。");
    }

    public ExecutedResult<String> remove(Long adminId) {
        ExecutedResult<AdminUserPO> check = this.check4Id(adminId);
        if (check.isFailed()) {
            return ExecutedResult.failed(check.getMsg(), check.getMsgCode());
        }
        Boolean remove = dao.remove(adminId);
        if (remove) {
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("删除[管理员]失败");
    }

    public ExecutedResult<AdminUserPO> check4Id(Long id) {
        AdminUserPO item = dao.get(id);
        if (Objects.isNull(item)) {
            return ExecutedResult.failed("[管理员]不存在: " + id);
        }
        return ExecutedResult.success(item);
    }

    // 设置管理员的角色列表
    public ExecutedResult<String> setListRole4Admin(ReqSetListRole4Admin request) {
        Long adminId = request.getId();
        ExecutedResult<AdminUserPO> checkExists = this.check4Id(adminId);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }
        AdminUserPO find = checkExists.getData();
        //找到管理员已有的角色列表
        List<AdminRoleRelationPO> listOld = adminRoleRelationDao.list4Admin(adminId);
        listOld = ParameterUtil.dealNull(listOld);

        //现在设置的角色id列表
        List<Long> listRoleId = ParameterUtil.dealNull(request.getListRole());

        //批量新增
        if (BooleanUtils.isFalse(listRoleId.isEmpty())) {
            List<AdminRoleRelationPO> list = listRoleId.stream()
                    .map(c -> {
                        AdminRoleRelationPO item = new AdminRoleRelationPO();
                        item.setAdminId(adminId);
                        item.setRoleId(c);
                        item.setCreateTime(LocalDateTimeUtil.nowTimeStamp());
                        return item;
                    }).collect(Collectors.toList());
            Boolean addList = adminRoleRelationDao.addList(list);
            if (BooleanUtils.isFalse(addList)) {
                return ExecutedResult.failed("给管理员“" + adminId + "”新增角色失败。" + listRoleId);
            }
        }
        //批量删除
        if (BooleanUtils.isFalse(listOld.isEmpty())) {
            List<Long> listId = listOld.stream()
                    .map(AdminRoleRelationPO::getId).collect(Collectors.toList());
            Boolean removeList = adminRoleRelationDao.remove(listId);
            if (BooleanUtils.isFalse(removeList)) {
                return ExecutedResult.failed("删除管理员“" + adminId + "”已有角色失败。" + listId);
            }
        }
        // 删除指定用户的菜单和权限缓存
        adminPowerService.removePower4User(adminId);
        return ExecutedResult.success();
    }

    // 获取管理员的角色列表
    public ExecutedResult<List<AdminRoleVO>> getListRole4Admin(Long id) {
        List<AdminRoleVO> result = new ArrayList<>();

        ExecutedResult<AdminUserPO> checkExists = this.check4Id(id);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }
        AdminUserPO find = checkExists.getData();
        List<AdminRolePO> list;
        if (Objects.equals(find.getUserType(), EUserType.ADMIN.getValue())) {
            list = roleDao.getList();
        } else {
            //找到角色已有的菜单列表
            List<AdminRoleRelationPO> listRole = adminRoleRelationDao.list4Admin(id);
            listRole = ParameterUtil.dealNull(listRole);
            if (ListUtil.isNullOrEmpty(listRole)) {
                return ExecutedResult.success(result);
            }
            List<Long> listRoleId = listRole.stream()
                    .map(AdminRoleRelationPO::getRoleId)
                    .collect(Collectors.toList());
            list = roleDao.getList(listRoleId);
        }
        if (ListUtil.isNotNullOrEmpty(list)) {
            // 筛选状态
            list = list.stream()
                    .filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
                    .collect(Collectors.toList());
            result = AdminRoleConvert.INSTANCE.toVo(list);
        }
        return ExecutedResult.success(result);
    }

    /**
     * 获取指定用户的菜单和权限
     *
     * @param user 用户
     */
    public ResAdminLogin getListPower4Admin(AdminUserPO user) {
        Long adminId = user.getId();

        ResAdminLogin result = new ResAdminLogin();
        result.setId(user.getId());
        result.setUserType(user.getUserType());
        result.setMenus(new ArrayList<>());

        List<AdminMenuPO> listMenu;
        List<AdminPermissionPO> listPermission = null;

        // 管理员从缓存中取有所有权限（普通管理员剔除系统管理部分菜单）
        if (LIST_ADMIN_TYPE.contains(user.getUserType())) {
            listMenu = menusService.listAllWithCache();

            if (Objects.equals(EUserType.ADMIN_USER.getValue(), user.getUserType())) {
                List<Long> listNot = Arrays.asList(10101L, 10102L, 10103L);
                listMenu = listMenu.stream().filter(c -> !listNot.contains(c.getId())).collect(Collectors.toList());
            }

            listPermission = permissionService.listAllWithCache();
        } else {
            //找到角色已有的菜单列表
            List<AdminRoleRelationPO> listRole = adminRoleRelationDao.list4Admin(adminId);
            if (ListUtil.isNullOrEmpty(listRole)) {
                return result;
            }
            List<Long> listRoleId = listRole.stream()
                    .map(AdminRoleRelationPO::getRoleId)
                    .collect(Collectors.toList());

            listMenu = menusService.listUserAllWithCache(user.getId(), listRoleId, adminPowerService::getListMenu4Role);
            listPermission = permissionService.listUserAllWithCache(user.getId(), listRoleId, adminPowerService::getListPermission4Role);
        }
        if (ListUtil.isNotNullOrEmpty(listMenu)) {
            // 筛选状态
            listMenu = listMenu.stream()
                    .filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
                    .collect(Collectors.toList());
            Map<Long, List<AdminPermissionPO>> mapPermission = new HashMap<>();
            // 筛选权限状态
            if (ListUtil.isNotNullOrEmpty(listPermission)) {
                // 筛选状态
                mapPermission = listPermission.stream()
                        .filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
                        .collect(Collectors.groupingBy(AdminPermissionPO::getMenuId));
            }

            List<AdminMenuPO> listRoot = listMenu.stream().filter(c -> Objects.equals(c.getLevel(), 1)).collect(Collectors.toList());
            listRoot = listRoot.stream()
                    .sorted(Comparator.comparing(AdminMenuPO::getSort).reversed())
                    .collect(Collectors.toList());
            if (ListUtil.isNotNullOrEmpty(listRoot)) {
                for (AdminMenuPO item : listRoot) {
                    ResAdminMenuTreeAndPermission view = AdminMenuConvert.INSTANCE.toTreeVo(item);
                    adminPowerService.fillChildMenu(view, listMenu, mapPermission);
                    adminPowerService.fillPermission4Menu(view, mapPermission);
                    result.getMenus().add(view);
                }
            }
        }
        if (ListUtil.isNotNullOrEmpty(listPermission)) {
            // 筛选状态
            List<String> listPermissionSn = listPermission.stream()
                    .filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
                    .sorted(Comparator.comparing(AdminPermissionPO::getMenuId))
                    .map(AdminPermissionPO::getSn)
                    .collect(Collectors.toList());
            result.setListPermission(listPermissionSn);
        }
        return result;
    }
}