package com.doumee.service.business.impl;

import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.model.LoginUserInfo;
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.MemberMapper;
import com.doumee.dao.business.OrgsMapper;
import com.doumee.dao.business.join.OrgsJoinMapper;
import com.doumee.dao.business.model.Activity;
import com.doumee.dao.business.model.Creation;
import com.doumee.dao.business.model.Member;
import com.doumee.dao.business.model.Orgs;
import com.doumee.dao.system.model.SystemUser;
import com.doumee.dao.system.model.SystemUserRole;
import com.doumee.dao.web.dto.CreateSystemUserDTO;
import com.doumee.dao.web.dto.OrgDTO;
import com.doumee.service.business.OrgsService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.doumee.service.system.SystemUserRoleService;
import com.doumee.service.system.SystemUserService;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
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.Date;
import java.util.List;
import java.util.Objects;

/**
 * 机构信息表Service实现
 * @author 江蹄蹄
 * @date 2023/03/21 15:48
 */
@Service
public class OrgsServiceImpl implements OrgsService {

    @Autowired
    private OrgsMapper orgsMapper;

    @Autowired
    private OrgsJoinMapper orgsJoinMapper;

    @Autowired
    private SystemDictDataBiz systemDictDataBiz;

    @Autowired
    private SystemUserService systemUserService;


    @Autowired
    private SystemUserRoleService systemUserRoleService;


    @Autowired
    private MemberMapper memberMapper;

    @Override
    @Transactional(rollbackFor = {BusinessException.class, Exception.class})
    public Integer create(Orgs orgs) {
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();

        checkParam(orgs);
        orgs.setCreateDate(new Date());
        orgs.setCreator(user.getId());
        orgs.setIsdeleted(Constants.ZERO);
        orgs.setStatus(Constants.ZERO);
        Integer userid = createSystemUser(orgs, user);
        orgs.setUserId(userid);
        orgsMapper.insert(orgs);
        return orgs.getId();
    }


    public void checkParam(Orgs orgs) {
        if (StringUtils.isBlank(orgs.getLoginname())
                || StringUtils.isBlank(orgs.getName())
                || StringUtils.isBlank(orgs.getImgurl())
                || orgs.getMemberId() == null
        ) {
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), ResponseStatus.BAD_REQUEST.getMessage());
        }
        Member member = memberMapper.selectById(orgs.getMemberId());
        if (Objects.isNull(member)) {
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "关联用户不存在");
        }
        Orgs query=new Orgs();
        query.setMemberId(member.getId());
        query.setIsdeleted(Constants.ZERO);
        List<Orgs> list=orgsMapper.selectList(new QueryWrapper<>(query));
        if(org.apache.commons.collections.CollectionUtils.isNotEmpty(list)){
            if(orgs.getId()!=null){
                if(!Constants.equalsInteger(list.get(0).getId(),orgs.getId())){
                    throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "关联用户已存在，不允许操作");
                }
            }else {
                if(list.size()>0){
                    throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "关联用户已存在，不允许操作");
                }
            }
        }

    }

    public Integer createSystemUser(Orgs result, LoginUserInfo user) {

        CreateSystemUserDTO systemUser = new CreateSystemUserDTO();
        systemUser.setMemberId(result.getMemberId());
        systemUser.setUsername(result.getLoginname());
        // 验证用户名
        SystemUser queryUserDto = new SystemUser();
        queryUserDto.setUsername(systemUser.getUsername());
        queryUserDto.setDeleted(Boolean.FALSE);
        SystemUser queryuser = systemUserService.findOne(queryUserDto);
        if (queryuser != null) {
            throw new BusinessException(ResponseStatus.DATA_EXISTS.getCode(), "登录用户已存在");
        }

    /*    SystemUser queryUserDto2 = new SystemUser();
        queryUserDto2.setMemberId(result.getMemberId());
        queryUserDto2.setDeleted(Boolean.FALSE);
        SystemUser queryuser2 = systemUserService.findOne(queryUserDto2);
        if (queryuser2 != null) {
            throw new BusinessException(ResponseStatus.DATA_EXISTS.getCode(), "登录关联用户已存在");
        }*/
        //初始密码
        String initialPassword = systemDictDataBiz.queryByCode(Constants.SYSTEM, Constants.INITIAL_PASSWORD).getCode();
        // 生成密码盐
        String salt = RandomStringUtils.randomAlphabetic(6);
        // 生成密码
        systemUser.setPassword(Utils.Secure.encryptPassword(initialPassword, salt));
        systemUser.setSalt(salt);
        // 创建用户记录
        systemUser.setRealname(result.getName());
        systemUser.setMobile(result.getPhone());
        systemUser.setCreateUser(user.getId());
        systemUser.setCreateTime(new Date());
        systemUser.setType(Constants.UserType.ORG.getKey());
        Integer userId = systemUserService.create(systemUser);

        String initialRoles = systemDictDataBiz.queryByCode(Constants.SYSTEM, Constants.ORG_ROLE).getCode();
        // 新增新的角色
        SystemUserRole newUserRole = new SystemUserRole();
        newUserRole.setUserId(userId);
        newUserRole.setRoleId(Integer.valueOf(initialRoles));
        systemUserRoleService.create(newUserRole);
        return userId;
    }



    @Override
    public void deleteById(Integer id) {
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        Orgs orgs=new Orgs();
        orgs.setId(id);
        orgs.setEditor(user.getId());
        orgs.setEditDate(new Date());
        orgs.setIsdeleted(Constants.ONE);
        orgsMapper.updateById(orgs);

        Orgs query=    orgsMapper.selectById(orgs.getId());
        SystemUser systemUser=new SystemUser();
        systemUser.setId(query.getUserId());
        systemUser.setDeleted(Boolean.TRUE);
        systemUserService.updateById(systemUser);
    }

    @Override
    public void delete(Orgs orgs) {
        UpdateWrapper<Orgs> deleteWrapper = new UpdateWrapper<>(orgs);
        orgsMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        orgsMapper.deleteBatchIds(ids);
    }

    @Override
    @Transactional(rollbackFor = {BusinessException.class, Exception.class})
    public void updateById(Orgs orgs) {
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        Orgs query=    orgsMapper.selectById(orgs.getId());
        checkParam(orgs);
       // checkSystemuser(query,orgs);

        orgs.setEditDate(new Date());
        orgs.setEditor(user.getId());
        orgs.setLoginname(null);
        orgsMapper.updateById(orgs);

        SystemUser systemUser=new SystemUser();
        systemUser.setId(query.getUserId());
        systemUser.setMemberId(orgs.getMemberId());
        systemUser.setRealname(orgs.getName());
         systemUserService.updateById(systemUser);
    }

    public void checkSystemuser(Orgs query,Orgs orgs){


        SystemUser queryUserDto2 = new SystemUser();
        queryUserDto2.setMemberId(orgs.getMemberId());
     //   queryUserDto2.setId(query.getUserId());
        queryUserDto2.setDeleted(Boolean.FALSE);
        List<SystemUser> queryuser2 = systemUserService.findList(queryUserDto2);
        if (queryuser2 != null&&queryuser2.size()>0&&!Constants.equalsInteger(queryuser2.get(0).getId(),query.getUserId())) {
            throw new BusinessException(ResponseStatus.DATA_EXISTS.getCode(), "登录关联用户已存在");
        }

    }

    @Override
    public void updateStatusById(Orgs orgs) {
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        orgs.setEditor(user.getId());
        orgs.setEditDate(new Date());
        orgsMapper.updateById(orgs);
    }

    @Override
    public void updateByIdInBatch(List<Orgs> orgss) {
        if (CollectionUtils.isEmpty(orgss)) {
            return;
        }
        for (Orgs orgs: orgss) {
            this.updateById(orgs);
        }
    }

    @Override
    public Orgs findById(Integer id) {
        String path = systemDictDataBiz.queryByCode(Constants.OSS, Constants.RESOURCE_PATH).getCode() + systemDictDataBiz.queryByCode(Constants.OSS, Constants.MEMBER_FILE).getCode();
        Orgs orgs=  orgsMapper.selectById(id);
        if(Objects.nonNull(orgs)){
            orgs.setImgFullUrl(path);
        }
        return orgs;
    }

    @Override
    public OrgDTO findOrgDTOById(Integer id) {
        Orgs orgs = orgsMapper.selectById(id);
        OrgDTO dto = new OrgDTO();
        BeanUtils.copyProperties(orgs,dto);
        return dto;
    }

    @Override
    public Orgs findOne(Orgs orgs) {
        QueryWrapper<Orgs> wrapper = new QueryWrapper<>(orgs);
        return orgsMapper.selectOne(wrapper);
    }

    @Override
    public List<Orgs> findList(Orgs orgs) {
        QueryWrapper<Orgs> wrapper = new QueryWrapper<>(orgs);
        return orgsMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<Orgs> findPage(PageWrap<Orgs> pageWrap) {
        IPage<Orgs> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        MPJLambdaWrapper<Orgs> queryWrapper = new MPJLambdaWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());

        queryWrapper.selectAll(Orgs.class);
        queryWrapper.selectAs(Member::getNickname,Orgs::getNikeName);
        queryWrapper.selectAs(Member::getPhone,Orgs::getPhone);

        queryWrapper.leftJoin(Member.class, Member::getId,Orgs::getMemberId);

        queryWrapper.eq(Orgs::getIsdeleted, Constants.ZERO);
        queryWrapper.like(StringUtils.isNotBlank( pageWrap.getModel().getName()),Orgs::getName, pageWrap.getModel().getName());
        IPage<Orgs> result = orgsJoinMapper.selectJoinPage(page, Orgs.class, queryWrapper);

        String path = systemDictDataBiz.queryByCode(Constants.OSS, Constants.RESOURCE_PATH).getCode() + systemDictDataBiz.queryByCode(Constants.OSS, Constants.MEMBER_FILE).getCode();
        for(Orgs model:result.getRecords()){
            model.setImgFullUrl(path);
        }
        return PageData.from(result);
    }

    @Override
    public long count(Orgs orgs) {
        QueryWrapper<Orgs> wrapper = new QueryWrapper<>(orgs);
        return orgsMapper.selectCount(wrapper);
    }
}