package com.dy.sso.busi;

import com.dy.common.aop.SsoVo;
import com.dy.common.util.MD5;
import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.pmsGlobal.pojoBa.BaUser;
import com.mysql.cj.util.StringUtils;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import java.util.Objects;
import java.util.UUID;

/**
 * 单点登录，
 */
@Slf4j
@RestController
@RequestMapping(path="sso")
@SuppressWarnings("unchecked")//java版本越高，对泛型约束越严，所以配置SuppressWarnings("unchecked")
public class SsoCtrl {

    //在属性上注解@Autowired时，会警告 Field injection is not recommended（不再推荐使用字段注入）
    private SsoSv sv ;

    //@Autowired
    //private CacheManager cacheManager ;

    @Autowired
    public void setSv(SsoSv sv ){
        this.sv = sv ;
    }


    /**
     * 客户端请求用户登录，客户端提交Json数据
     * @param vo 用户登录值对象
     * @param bindingResult 输入验证
     * @return 登录用户值对象
     */
    @PostMapping(path = "login", consumes = MediaType.APPLICATION_JSON_VALUE)//前端提交json数据
    public BaseResponse<UserVo> login(@RequestBody  @Valid LoginVo vo, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }
        return this.doLogin(vo) ;
    }

    /**
     * 客户端请求用户登录，客户端提交form表单
     * @param vo 登录用户form表单对象
     * @return 登录用户值对象
     */
    @PostMapping(path = "loginForm", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)//前端提交form表单数据
    public BaseResponse<UserVo> loginForm(@RequestBody @Valid LoginVo vo, BindingResult bindingResult){
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }
        return this.doLogin(vo) ;
    }


    /**
     * 通过UUID退出登录，因为参数是uuid，所以此调用必须是后端相关代码调用，因为前端得不到cookie中的uuid
     * @param hr HttpServletRequest
     * @return 正常退出登录返回true，否则返回false
     */
    @GetMapping(path = "logout")
    public BaseResponse<Boolean> logout(HttpServletRequest hr){
        String token = hr.getHeader("token") ;
        if(token != null){
            this.sv.logout(token) ;
            return BaseResponseUtils.buildSuccess(true);
        }else{
            return BaseResponseUtils.buildFail("未从header中得到token");
        }
    }

    /**
     * 此方法供子模块系统调用，所以不公开在API接口中
     * 方法功能：得到登录用户id，否则返回null
     * @param token 登录用户token
     * @return 登录用户ID
     */
    @GetMapping(path = "loginUserId")
    public Long loginUserId(String token){
        BaUser userPo = this.sv.getByUuid(token) ;
        return userPo == null ? null : userPo.id ;
    }
    /**
     * 此方法供子模块系统调用，所以不公开在API接口中
     * 方法功能：验证是否已经登录
     * @param token 登录用户token
     * @return SsoVo
     */
    @GetMapping(path = "ssoCheck")
    public SsoVo ssoCheck(String token){
        BaUser userPo = this.sv.getByUuid(token) ;
        SsoVo vo = new SsoVo();
        if(userPo != null){
            vo.logined = true ;
            vo.hasPower = true ;//默认有权限
        }else{
            vo.logined = false ;
            vo.hasPower = true ;//默认有权限
        }
        return vo ;
    }
    /**
     * 此方法供子模块系统调用，所以不公开API接口。
     * 方法功能：验证是否已经登录，如果登录了，再验证权限
     * @param token 登录用户token
     * @param privilege 验证一个权限
     * @param allPrivilege 验证所有权限
     * @param anyPrivilege 验证任何一个权限
     * @return SsoVo
     */
    @GetMapping(path = "ssoPowerCheck")
    public SsoVo ssoPowerCheck(String token, String privilege, String[] allPrivilege, String[] anyPrivilege){
        BaUser userPo = this.sv.getByUuid(token) ;
        SsoVo vo = new SsoVo();
        if(userPo != null){
            vo.logined = true ;
            vo.hasPower = false ;//默认是无权限
            if(userPo.supperAdmin != null && userPo.supperAdmin == 1){
                vo.hasPower = true ;
            }else{
                if(privilege.equals("-1")){
                    //无需权限验证
                    vo.hasPower = true ;
                }else{
                    if(userPo.privileges != null && userPo.privileges.size() > 0){
                        vo.hasPower = this.hasOnePrivilege(privilege, userPo) ;
                        if(!vo.hasPower){
                            vo.hasPower = this.hasAllPrivilege(allPrivilege, userPo) ;
                            if(!vo.hasPower){
                                vo.hasPower = this.hasAnyPrivilege(anyPrivilege, userPo) ;
                            }
                        }
                    }
                }
            }
        }else{
            vo.logined = false ;
            vo.hasPower = false ;
        }
        return vo ;
    }

    /**
     * 获得当前登录用户
     * @param token 登录用户token
     * @return SsoVo
     */
    @GetMapping(path = "ssoCurUser")
    public CurUserVo ssoCurUser(String token){
        BaUser userPo = this.sv.getByUuid(token) ;
        CurUserVo vo = new CurUserVo();
        if(userPo != null){
            vo.id = userPo.id ;
            vo.name = userPo.name;
        }
        return vo ;
    }
    /////////////////////////////////////////////////////////////////
    //
    // 以下私有方法
    //
    /////////////////////////////////////////////////////////////////
    /**
     * 用户登录
     * @param vo 登录用户form表单对象
     * @return 登录用户值对象
     */
    private BaseResponse<UserVo> doLogin(LoginVo vo){
        String uuid ;
        BaUser userPo ;
        try {
            //Boolean flag = cacheManager.getCacheNames().isEmpty() ;
            uuid = UUID.randomUUID().toString();
            if(!StringUtils.isNullOrEmpty(vo.password)){
                /*
                如果前端进行了base64加密
                po.password = new String(Base64.getDecoder().decode(po.password)) ;
                */
                vo.password = MD5.encrypt(vo.password) ;
            }
            userPo = this.sv.login(uuid, vo.phone, vo.password);
        } catch (Exception e) {
            log.error("用户登录异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
        }

        if(userPo != null){
            UserVo uVo = UserVoMapper.INSTANCT.po2vo(userPo);
            uVo.token = uuid ;
            return BaseResponseUtils.buildSuccess(uVo);
        }else{
            return BaseResponseUtils.buildFail("登录失败");
        }
    }
    /**
     * 判断登录用户是否拥有指定的一个权限
     * @param privilege 指定的一个权限
     * @param userPo 当前登录用户
     * @return 是否有权限
     */
    private boolean hasOnePrivilege(String privilege, BaUser userPo){
        boolean hasPrivilege  = false ;
        if (privilege != null && !privilege.trim().equals("")) {
            int intPri = Integer.parseInt(privilege);
            for (Integer pri : userPo.privileges) {
                if (pri == intPri) {
                    hasPrivilege = true;
                    break;
                }
            }
        }
        return hasPrivilege ;
    }

    /**
     * 判断登录用户是否拥有指定的多个权限
     * @param allPrivilege 指定的多个权限
     * @param userPo 当前登录用户
     * @return 是否有权限
     */
    private boolean hasAllPrivilege(String[] allPrivilege, BaUser userPo){
        boolean hasPrivilege  = false ;
        if(allPrivilege != null && allPrivilege.length > 0){
            int intPri ;
            int count = 0 ;
            for(String strPri : allPrivilege){
                intPri = Integer.parseInt(strPri) ;
                for(Integer pri : userPo.privileges){
                    if(pri == intPri){
                        count++ ;
                        break ;
                    }
                }
            }
            if(count  == allPrivilege.length){
                hasPrivilege = true ;
            }
        }
        return hasPrivilege ;
    }


    /**
     * 判断登录用户是否拥有指定的某个权限
     * @param anyPrivilege 指定的多个权限
     * @param userPo 当前登录用户
     * @return 是否有权限
     */
    private boolean hasAnyPrivilege(String[] anyPrivilege, BaUser userPo){
        boolean hasPrivilege  = false ;
        int intPri ;
        if(anyPrivilege != null && anyPrivilege.length > 0){
            for(String strPri : anyPrivilege){
                intPri = Integer.parseInt(strPri) ;
                for(Integer pri : userPo.privileges){
                    if(pri == intPri){
                        hasPrivilege = true ;
                        break ;
                    }
                }
                if(hasPrivilege){
                    break ;
                }
            }
        }
        return hasPrivilege ;
    }


}