package com.gkhy.labRiskManage.application.account.service.impl;

import cn.hutool.core.util.ObjectUtil;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.gkhy.labRiskManage.api.controller.account.dto.req.UserSearchReqDTO;
import com.gkhy.labRiskManage.api.controller.account.query.UserQuery;
import com.gkhy.labRiskManage.application.account.converter.UserInfoAppConverter;
import com.gkhy.labRiskManage.application.account.dto.repDto.CreateNewUserAppReqDTO;
import com.gkhy.labRiskManage.application.account.dto.repDto.UpdateUserAppReqDTO;
import com.gkhy.labRiskManage.application.account.dto.respDto.RoleRespDTO;
import com.gkhy.labRiskManage.commons.exception.BusinessException;
import com.gkhy.labRiskManage.commons.model.PageQuery;
import com.gkhy.labRiskManage.domain.account.converter.UserInfoDomainConverter;
import com.gkhy.labRiskManage.application.account.dto.repDto.ChangePasswdReqDto;
import com.gkhy.labRiskManage.application.account.dto.repDto.LoginReqAppDTO;
import com.gkhy.labRiskManage.application.account.dto.respDto.LoginRespDto;
import com.gkhy.labRiskManage.application.account.dto.respDto.TokenInfoDto;
import com.gkhy.labRiskManage.domain.account.converter.UserRoleBindConverter;
import com.gkhy.labRiskManage.domain.account.enums.IdentityStatusEnum;
import com.gkhy.labRiskManage.domain.account.enums.UserStatusEnum;
import com.gkhy.labRiskManage.application.account.service.AccountAppService;
import com.gkhy.labRiskManage.application.account.service.TokenAppService;
import com.gkhy.labRiskManage.commons.domain.Result;
import com.gkhy.labRiskManage.commons.domain.SearchResult;
import com.gkhy.labRiskManage.application.account.dto.respDto.UserInfoAppRespDTO;
import com.gkhy.labRiskManage.commons.enums.ResultCode;
import com.gkhy.labRiskManage.domain.account.model.bo.CreateUserBO;
import com.gkhy.labRiskManage.domain.account.model.bo.UpdateUserBO;

import com.gkhy.labRiskManage.domain.account.model.dto.SysUserRoleBindDomainDTO;
import com.gkhy.labRiskManage.domain.account.service.SysUserIdentityBindDomainService;
import com.gkhy.labRiskManage.domain.account.service.UserDomainService;
import com.gkhy.labRiskManage.domain.account.model.dto.UserInfoDomainDTO;
import com.gkhy.labRiskManage.domain.account.service.UserRoleDomainService;
import org.redisson.api.RedissonClient;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;

@Service
public class AccountAppServiceImpl implements AccountAppService {

    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private ObjectMapper objectMapper;

    @Autowired
    private TokenAppService tokenService;

    @Autowired
    private UserDomainService userDomainService;

    @Autowired
    private UserInfoAppConverter userInfoAppConverter;

    @Autowired
    private UserRoleDomainService userRoleDomainService;

    @Autowired
    private SysUserIdentityBindDomainService identityBindDomainService;

    @Autowired
    private UserRoleBindConverter converter;

    @Override
    public SearchResult<UserInfoAppRespDTO> findUserByLoginName(String loginName){
        SearchResult<UserInfoAppRespDTO> result = new SearchResult<>();
        result.execSuccess();
        if(loginName == null || loginName.isEmpty())
            return result;
        UserInfoDomainDTO userInfoDomainDTO = userDomainService.getUserInfoByName(loginName);
        if(userInfoDomainDTO != null){
            UserInfoAppRespDTO userInfoAppRespDTO = new UserInfoDomainConverter().toUserInfoRespDTO(userInfoDomainDTO);
            result.setCount(1);
            result.setData(userInfoAppRespDTO);
        }
        return result;
    }

    @Override
    public SearchResult<List<UserInfoAppRespDTO>> findUserByRealName(String name) {
        SearchResult<List<UserInfoAppRespDTO>> result = new SearchResult<>();
        result.setSuccess();
        List<UserInfoDomainDTO> userInfoDomainDTOS = userDomainService.findUserListByRealName(name);
        if(userInfoDomainDTOS != null && !userInfoDomainDTOS.isEmpty()){
            List<UserInfoAppRespDTO> appRespDTOS = userInfoAppConverter.toAppDtoList(userInfoDomainDTOS);
            result.setCount(appRespDTOS.size());
            result.setData(appRespDTOS);
        }
        return result;
    }

    @Override
    public SearchResult<List<UserInfoAppRespDTO>> findUserByRole(Long roleId, boolean usePage, Integer page, Integer pageSize) {
        SearchResult<List<UserInfoAppRespDTO>> searchResult = new SearchResult<>();
        searchResult.setSuccess();
        searchResult.setUsePage(usePage);
        if(usePage){
            searchResult.setPageIndex(page);
            searchResult.setPageSize(pageSize);
        }
        SearchResult<List<UserInfoDomainDTO>> userResult = userDomainService.findUserListByRole(roleId,usePage,page,
                pageSize);
        BeanUtils.copyProperties(userResult,searchResult);
        searchResult.setData(userInfoAppConverter.toAppDtoList((List<UserInfoDomainDTO>) userResult.getData()));
        return searchResult;
    }

    @Override
    public SearchResult<UserInfoAppRespDTO> findUserByUserId(Long userId) {
        SearchResult<UserInfoAppRespDTO> result = new SearchResult<>();
        result.execSuccess();
        if(userId == null || userId < 0)
            return result;
        UserInfoDomainDTO userInfoDomainDTO = userDomainService.getUserInfoById(userId);
        if(userInfoDomainDTO == null){
            result.setCount(1);
            return result;
        }
        UserInfoAppRespDTO respDTO = new UserInfoDomainConverter().toUserInfoRespDTO(userInfoDomainDTO);
        result.setCount(1);
        result.setData(respDTO);
        return result;
    }

    @Override
    public SearchResult<List<UserInfoAppRespDTO>> findUserListByUserIdList(List<Long> userIdList) {
        SearchResult<List<UserInfoAppRespDTO>> result = new SearchResult<>();
        result.execSuccess();
        if(userIdList == null || userIdList.isEmpty())
            return result;
        List<UserInfoDomainDTO> userInfoDomainDTOList = userDomainService.getUserInfoListByIds(userIdList);
        if(userInfoDomainDTOList != null && userInfoDomainDTOList.size() > 0){
            UserInfoDomainConverter userInfoDomainConverter = new UserInfoDomainConverter();
            List<UserInfoAppRespDTO> userInfoAppRespDTOList = new ArrayList<>();
            for(UserInfoDomainDTO userInfoDomainDTO : userInfoDomainDTOList){
                UserInfoAppRespDTO dto = userInfoDomainConverter.toUserInfoRespDTO(userInfoDomainDTO);
                userInfoAppRespDTOList.add(dto);
            }
            result.setCount(userInfoAppRespDTOList.size());
            result.setData(userInfoAppRespDTOList);
        }
        return result;
    }

    @Override
    @Transactional
    public Result updateUserPassword(ChangePasswdReqDto dto) {
        Result result = new Result<>();
        if(userDomainService.updateUserPwd(dto.getUid(),dto.getOldPwd(),dto.getNewPwd()) == true){
            result.setSuccess();
        }else {
            result.setCode(ResultCode.SYSTEM_ERROR.getCode());
            result.setMsg("修改密码失败");
        }
        return result;
    }

    @Override
    @Transactional
    public Result updateUserStatus(Long userId, Byte status) {
        Result result = new Result<>();
        if(userId == null || userId < 1 || status == null){
            result.setCode(ResultCode.PARAM_ERROR_NULL.getCode());
            result.setMsg("参数缺失");
            return result;
        }
        if(UserStatusEnum.prase(status) == null){
            result.setCode(ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode());
            result.setMsg("状态不支持");
            return result;
        }
        if(userDomainService.updateUserStatus(userId,status) == true){
            result.setSuccess();
        }else {
            result.setCode(ResultCode.SYSTEM_ERROR_DATABASE_FAIL.getCode());
            result.setMsg("数据库更新失败");
        }
        return result;
    }

    @Override
    @Transactional
    public Result updateUserRole(Long userId, List<Long> roleIds) {
        Result result = new Result<>();
        if(userId == null || userId < 1 || roleIds == null ||  roleIds.size() == 0){
            result.setCode(ResultCode.PARAM_ERROR_NULL.getCode());
            result.setMsg("参数缺失");
            return result;
        }
        userRoleDomainService.updateUserRole(userId,roleIds);
        result.setSuccess();
        return result;
    }

    @Override
    public Result login(LoginReqAppDTO loginReqAppDTO) {
        Result result = new Result<>();
        //1、参数校验
        if(loginReqAppDTO == null || loginReqAppDTO.getName() == null || loginReqAppDTO.getPwd() == null){
            result.setCode(ResultCode.PARAM_ERROR_NULL.getCode());
            result.setMsg("用户名或密码不全");
            return result;
        }
        //2、密码校验
        UserInfoDomainDTO userInfoDomainDTO = userDomainService.getUserInfoByName(loginReqAppDTO.getName());
        if(userInfoDomainDTO == null){
            result.setCode(ResultCode.BUSINESS_ERROR_ACCOUNT_NOT_EXIST.getCode());
            result.setMsg("用户不存在");
            return result;
        }

        if(!userDomainService.checkPassword(loginReqAppDTO.getPwd(), userInfoDomainDTO.getHash(), userInfoDomainDTO.getSalt())){
            result.setCode(ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode());
            result.setMsg("密码错误");
            return result;
        }
        //检查用户状态
        if(userInfoDomainDTO.getStatus().equals(UserStatusEnum.STATUS_FROZEN.getStatus())){
            result.setCode(ResultCode.BUSINESS_ERROR_ACCOUNT_STATU_ABNORMAL.getCode());
            result.setMsg("该账号已被冻结");
            return result;
        }
        if(userInfoDomainDTO.getStatus().equals(UserStatusEnum.STATUS_DELETE.getStatus())){
            result.setCode(ResultCode.BUSINESS_ERROR_ACCOUNT_STATU_ABNORMAL.getCode());
            result.setMsg("账号无效");
            return result;
        }
        //设置token
        Result<TokenInfoDto> setTokenResult = tokenService.setToken(userInfoDomainDTO.getId());
        if(!setTokenResult.isSuccess()){
            result.setCode(ResultCode.BUSINESS_ERROR.getCode());
            result.setMsg("系统出错");
            return result;
        }
        TokenInfoDto tokenInfoDto = (TokenInfoDto) setTokenResult.getData();
        if(tokenInfoDto == null || tokenInfoDto.getTk() == null || tokenInfoDto.getTk().isEmpty()){
            result.setCode(ResultCode.BUSINESS_ERROR.getCode());
            result.setMsg("系统出错");
            return result;
        }
        LoginRespDto loginRespDto = new LoginRespDto();
        loginRespDto.setUid(userInfoDomainDTO.getId());
        loginRespDto.setName(userInfoDomainDTO.getName());
        loginRespDto.setRealName(userInfoDomainDTO.getRealName());
        loginRespDto.setTk(tokenInfoDto.getTk());
        loginRespDto.setRoles(converter.userRoleBindConverter(userInfoDomainDTO.getRoles()));
        //todo:获取其他需返回的信息

        result.setSuccess();
        result.setData(loginRespDto);

        return result;
    }

    @Override
    public Result logout(Long userId) {
        Result result = new Result<>();
        if(userId == null){
            result.setCode(ResultCode.PARAM_ERROR_NULL);
            return result;
        }
        result = tokenService.removeToken(userId);
        return result;
    }

    @Override
    @Transactional
    public Result createNewUser(CreateNewUserAppReqDTO createNewUserAppReqDTO) {
        Result result = new Result();
        //校验参数
        if(createNewUserAppReqDTO == null || createNewUserAppReqDTO.getName() == null || createNewUserAppReqDTO.getName().isEmpty()
                || createNewUserAppReqDTO.getRealName() == null || createNewUserAppReqDTO.getRealName().isEmpty()
                || createNewUserAppReqDTO.getRoleIds() == null || createNewUserAppReqDTO.getRoleIds().size() == 0 || createNewUserAppReqDTO.getIdentityStatus() == null){
            throw new BusinessException(this.getClass(),ResultCode.PARAM_ERROR.getCode(),"用户信息不全");
        }
        if(IdentityStatusEnum.prase(createNewUserAppReqDTO.getIdentityStatus()) == null){
            throw new BusinessException(this.getClass(),ResultCode.PARAM_ERROR_ILLEGAL.getCode(),"用户用户身份不合法");
        }
        if(createNewUserAppReqDTO.getIdentityStatus().equals(IdentityStatusEnum.EXPERT.getStatus()) && createNewUserAppReqDTO.getIdentityIds() == null){
            throw new BusinessException(this.getClass(),ResultCode.PARAM_ERROR_NULL.getCode(),"请选择用户身份！");
        }
        //校验角色信息
        CreateUserBO createUserBO = new CreateUserBO();
        createUserBO.setName(createNewUserAppReqDTO.getName());
        createUserBO.setRealName(createNewUserAppReqDTO.getRealName());
        //如果没有提供密码，初始密码为“123456”
        if(createNewUserAppReqDTO.getPwd() == null || createNewUserAppReqDTO.getPwd().isEmpty()){
            createNewUserAppReqDTO.setPwd("123456");
        }
        createUserBO.setPwd(createNewUserAppReqDTO.getPwd());
        createUserBO.setPhone(createNewUserAppReqDTO.getPhone());
        createUserBO.setIdType(createNewUserAppReqDTO.getIdType());
        createUserBO.setIdSerial(createNewUserAppReqDTO.getIdSerial());
        createUserBO.setDepId(createNewUserAppReqDTO.getDepId());
        createUserBO.setIdentityStatus(createNewUserAppReqDTO.getIdentityStatus());
        createUserBO.setQualificationAttId(createNewUserAppReqDTO.getQualificationAttId());
        UserInfoDomainDTO userInfoDomainDTO = userDomainService.newUser(createUserBO);
        //绑定角色
        List<SysUserRoleBindDomainDTO> sysUserRoleBindDomainDTOS = userRoleDomainService.insertBatchUserBindRole(createNewUserAppReqDTO.getRoleIds(), userInfoDomainDTO.getId());
        //绑定身份
        if(createNewUserAppReqDTO.getIdentityStatus().equals(IdentityStatusEnum.EXPERT.getStatus()) && ObjectUtil.isNotEmpty(createNewUserAppReqDTO.getIdentityIds())){
            identityBindDomainService.insertBatchUserIndentityBind(createNewUserAppReqDTO.getIdentityIds(), userInfoDomainDTO.getId());
        }

        if(userInfoDomainDTO != null){
            result.setSuccess();
            result.setCount(1);
            UserInfoAppRespDTO userInfoAppRespDTO = new UserInfoDomainConverter().toUserInfoRespDTO(userInfoDomainDTO);
            userInfoAppRespDTO.setRoles(converter.userRoleBindAppConverter(sysUserRoleBindDomainDTOS));
            result.setData(userInfoAppRespDTO);
        }else {
            throw new BusinessException(this.getClass(),ResultCode.BUSINESS_ERROR.getCode(),"创建新用户失败");
        }
        return result;
    }

    @Transactional
    @Override
    public Result updateUser(UpdateUserAppReqDTO updateUserAppReqDTO) {
        Result result = new Result<>();
        if(updateUserAppReqDTO == null){
            throw new BusinessException(this.getClass(),ResultCode.PARAM_ERROR.getCode(),"参数缺失");
        }
        if(IdentityStatusEnum.prase(updateUserAppReqDTO.getIdentityStatus()) == null){
            throw new BusinessException(this.getClass(),ResultCode.PARAM_ERROR_ILLEGAL.getCode(),"用户用户身份不合法");
        }
        if(updateUserAppReqDTO.getIdentityStatus().equals(IdentityStatusEnum.EXPERT.getStatus()) && CollectionUtils.isEmpty(updateUserAppReqDTO.getIdentityIds())){
            throw new BusinessException(this.getClass(),ResultCode.PARAM_ERROR_NULL.getCode(),"请选择用户身份！");
        }
        UpdateUserBO bo = new UpdateUserBO();
        bo.setId(updateUserAppReqDTO.getId());
        bo.setName(updateUserAppReqDTO.getName());
        bo.setRealName(updateUserAppReqDTO.getRealName());
        bo.setIdType(updateUserAppReqDTO.getIdType());
        bo.setIdSerial(updateUserAppReqDTO.getIdSerial());
        bo.setPhone(updateUserAppReqDTO.getPhone());
        bo.setDepId(updateUserAppReqDTO.getDepId());
        bo.setIdentityStatus(updateUserAppReqDTO.getIdentityStatus());
        bo.setQualificationAttId(updateUserAppReqDTO.getQualificationAttId());
        UserInfoDomainDTO updateRs = userDomainService.updateUserInfo(bo);
        //修改用户绑定角色
        userRoleDomainService.updateUserRole(updateUserAppReqDTO.getId(), updateUserAppReqDTO.getRoleIds());
        //绑定身份
        if(updateUserAppReqDTO.getIdentityStatus().equals(IdentityStatusEnum.EXPERT.getStatus())){
            identityBindDomainService.updateBatchUserIndentityBind(updateUserAppReqDTO.getIdentityIds(), updateUserAppReqDTO.getId());
        }
        if(updateUserAppReqDTO.getIdentityStatus().equals(IdentityStatusEnum.NOT_EXPERT.getStatus())){
            identityBindDomainService.deleteByUser(updateUserAppReqDTO.getId());
        }

        if(updateRs != null){
            result.setSuccess();
            result.setCount(1);
            result.setData(updateRs);
        }else {
            result.setCode(ResultCode.BUSINESS_ERROR);
        }
        return result;
    }

    @Transactional
    @Override
    public Result deleteUser(Long userId) {
        Result result = new Result<>();
        if(userId == null){
            result.setCode(ResultCode.PARAM_ERROR_NULL.getCode());
            result.setMsg("参数缺失");
            return result;
        }
        if(userDomainService.deleteUser(userId) == true && userRoleDomainService.deleteByUser(userId) == true && identityBindDomainService.deleteByUser(userId) == true){
            result.setCode(ResultCode.OK);
            result.setMsg("数据库更新成功");
        }else {
            result.setCode(ResultCode.SYSTEM_ERROR_DATABASE_FAIL.getCode());
            result.setMsg("数据库更新失败");
        }
        return result;
    }

    @Override
    public SearchResult<List<UserInfoAppRespDTO>> findUser(PageQuery<UserQuery> pageQuery) {
        SearchResult<List<UserInfoAppRespDTO>> searchResult = new SearchResult<>();
        searchResult.setSuccess();
        SearchResult<List<UserInfoDomainDTO>> userResult = userDomainService.findUserList(pageQuery);
        BeanUtils.copyProperties(userResult,searchResult);
        searchResult.setData(userInfoAppConverter.toAppDtoList((List<UserInfoDomainDTO>) userResult.getData()));
        return searchResult;
    }

    @Override
    public SearchResult<List<UserInfoAppRespDTO>> findExpert(PageQuery<UserQuery> pageQuery) {
        SearchResult<List<UserInfoAppRespDTO>> searchResult = new SearchResult<>();
        searchResult.setSuccess();
        SearchResult<List<UserInfoDomainDTO>> userResult = userDomainService.findExpertList(pageQuery);
        BeanUtils.copyProperties(userResult,searchResult);
        searchResult.setData(userInfoAppConverter.toAppDtoList((List<UserInfoDomainDTO>) userResult.getData()));
        return searchResult;
    }


}