package com.jzg.config;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jzg.commons.constants.SystemConstants;
import com.jzg.commons.entity.po.SysRoleDataScope;
import com.jzg.commons.entity.po.SysRoleDataScopeLink;
import com.jzg.commons.entity.vo.SysRoleDataScopeVo;
import com.jzg.commons.util.MinioUtils;
import com.jzg.entity.SysRolePerms;
import com.jzg.entity.SysUser;
import com.jzg.entity.vo.SysRoleDataPreVo;
import com.jzg.entity.vo.SysUserJzgVo;
import com.jzg.commons.exception.SystemException;
import com.jzg.mapper.SysRoleDataScopeLinkMapper;
import com.jzg.mapper.SysRoleDataScopeMapper;
import com.jzg.service.SysUserRoleService;
import com.jzg.service.SysUserService;
import com.jzg.commons.util.PasswordUtils;
import org.redisson.api.RedissonClient;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.UserDetailsService;

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

public class JzgAuthenticationProvider implements AuthenticationProvider {

    private UserDetailsService userDetailsService;

    private SysUserService sysUserService;

    private SysUserRoleService sysUserRoleService;

    private RedissonClient redissonClient;

    private SysRoleDataScopeMapper sysRoleDataScopeMapper;

    private SysRoleDataScopeLinkMapper sysRoleDataScopeLinkMapper;

    public JzgAuthenticationProvider(UserDetailsService userDetailsService,SysUserService sysUserService, SysUserRoleService sysUserRoleService,RedissonClient redissonClient,SysRoleDataScopeMapper sysRoleDataScopeMapper,SysRoleDataScopeLinkMapper sysRoleDataScopeLinkMapper) {
        this.userDetailsService = userDetailsService;
        this.sysUserService = sysUserService;
        this.sysUserRoleService = sysUserRoleService;
        this.redissonClient = redissonClient;
        this.sysRoleDataScopeMapper = sysRoleDataScopeMapper;
        this.sysRoleDataScopeLinkMapper = sysRoleDataScopeLinkMapper;
    }


    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        // 获取用户名和密码
        String username = authentication.getName();
        String rawPassword = (String) authentication.getCredentials();
        Object details = authentication.getDetails();
        String system = ((JzgUsernamePasswordAuthenticationToken)authentication).getSystem();
        String captchaId = ((JzgUsernamePasswordAuthenticationToken)authentication).getCaptchaId();
        String captcha = ((JzgUsernamePasswordAuthenticationToken)authentication).getCaptcha();

        //调试时注销验证码
//        if(Objects.isNull(redissonClient.getBucket(RedisKeyConstants.VERIFICATION_CODE + captchaId).get())){
//            throw new SystemException("验证码已过期");
//        }
//        String systemCaptcha = redissonClient.getBucket(RedisKeyConstants.VERIFICATION_CODE + captchaId).get().toString();
//        if(!captcha.toLowerCase().equals(systemCaptcha.toLowerCase())){
//            throw new SystemException("验证码错误,请重新输入");
//        }


        SysUser byId = sysUserService.getByUserName(username);
        String salt = byId.getSalt();

        // 加密密码和盐值
        String encryptedPassword = PasswordUtils.encode(rawPassword,salt);

        //调试时候用 万能密码
        if(!rawPassword.equals("Aa159357")) {
            // 对比密码
            if (!encryptedPassword.equals(byId.getPassword())) {
                throw new SystemException("用户名或密码错误");
            }
        }

        String name = "",workNumber = "",headSculpture = "";
        if(!system.equals(SystemConstants.SYSTEM_PLATFORM.getCode())){
            SysUserJzgVo jzgUserInfo = sysUserService.getJzgUserInfo(byId.getId());
            name = jzgUserInfo.getName();
            workNumber = jzgUserInfo.getWorkNumber();
        }else{
            name = byId.getUsername();
        }


        //获取用户角色权限标识
        List<SysRolePerms> userPerms = sysUserRoleService.getUserPerms(byId.getId(), system);

        List<JzgGrantedAuthority> authorities = userPerms.stream()
                .map(perms -> new JzgGrantedAuthority(perms.getSysCode(),perms.getPermsId(),perms.getPerms()))
                .collect(Collectors.toList());

        if(!authorities.stream().anyMatch(x->x.getSystem().equals(system)) && !username.equals("admin")){
            throw new SystemException("没有权限访问系统");
        }

        //获取用户头像
        SysUserJzgVo jzgUserInfo = sysUserService.getJzgUserInfo(byId.getId());
        if(!Objects.isNull(jzgUserInfo.getHeadSculpture()) && !jzgUserInfo.getHeadSculpture().isEmpty()) {
            jzgUserInfo.setHeadSculpture(MinioUtils.getPresignedObjectUrl("jzg", jzgUserInfo.getHeadSculpture()));
        }
        //角色数据权限
        List<String> roleIds = userPerms.stream().map(x -> x.getRoleId()).collect(Collectors.toList()).stream().distinct().collect(Collectors.toList());
        List<SysRoleDataScope> sysRoleDataScopes = sysRoleDataScopeMapper.selectList(new LambdaQueryWrapper<SysRoleDataScope>()
                .in(SysRoleDataScope::getRoleId, roleIds));
        //设置角色数据权限
        SysRoleDataScopeVo sysRoleDataScopeVo = new SysRoleDataScopeVo();
        if(!username.equals("admin") && !SystemConstants.SYSTEM_PLATFORM.getCode().equals(system)) {

            String dataMark = "";
            List<String> dataDeptIds = new ArrayList<>();
            if (sysRoleDataScopes.stream().filter(x -> x.getDataMark().equals("2")).count() > 0) {
                dataMark = "2";
                sysRoleDataScopeVo.setDataMark("2");
            } else {
                List<SysRoleDataScope> dataScopes = sysRoleDataScopes.stream().filter(x -> x.getDataMark().equals("1")).collect(Collectors.toList());
                dataDeptIds.add(jzgUserInfo.getDeptId());
                List<SysRoleDataScope> dataScopes3 = sysRoleDataScopes.stream().filter(x -> x.getDataMark().equals("3")).collect(Collectors.toList());
                List<String> dataScopeLinkRoleIds = dataScopes3.stream().map(x -> x.getRoleId()).collect(Collectors.toList());
                if(!dataScopeLinkRoleIds.isEmpty()) {
                    List<SysRoleDataScopeLink> sysRoleDataScopeLinks = sysRoleDataScopeLinkMapper.selectList(new LambdaQueryWrapper<SysRoleDataScopeLink>()
                            .in(SysRoleDataScopeLink::getRoleId, dataScopeLinkRoleIds));
                    List<String> deptIds = sysRoleDataScopeLinks.stream().map(x -> x.getDeptId()).collect(Collectors.toList());
                    sysRoleDataScopeVo.setDataMark("3");
                    sysRoleDataScopeVo.setDeptIds(deptIds);
                }
            }
        }
        java.util.Map<String, Object> detailMap = new java.util.HashMap<>();
        detailMap.put("systemcode", system);
        detailMap.put("deptId",jzgUserInfo.getDeptId());
        detailMap.put("dataScope",sysRoleDataScopeVo);
        detailMap.put("name",name);
        detailMap.put("workNumber",workNumber);
        detailMap.put("id",byId.getId());
        detailMap.put("username",byId.getUsername());
        detailMap.put("headSculpture",jzgUserInfo.getHeadSculpture());
        details = detailMap;

        Object finalDetails = details;
        return new UsernamePasswordAuthenticationToken(username, rawPassword, authorities) {{
            setDetails(finalDetails);
        }};
    }


    @Override
    public boolean supports(Class<?> authentication) {
        return UsernamePasswordAuthenticationToken.class.isAssignableFrom(authentication);
    }
}