package com.qianwen.smartman.modules.sync.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.stream.Collectors;

import org.jeewx.api.mp.aes.AesException;
import org.jeewx.api.mp.aes.WXBizMsgCrypt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.jeecg.qywx.api.department.vo.Department;
import com.qianwen.smartman.common.constant.CommonConstant;
import com.qianwen.smartman.common.enums.CommonGroupTypeEnum;
import com.qianwen.smartman.modules.cps.entity.CommonGroup;
import com.qianwen.smartman.modules.cps.entity.CommonGroupOfItem;
import com.qianwen.smartman.modules.cps.entity.Employee;
import com.qianwen.smartman.modules.cps.entity.EmployeePost;
import com.qianwen.smartman.modules.cps.mapper.CommonGroupMapper;
import com.qianwen.smartman.modules.cps.service.IEmployeePostService;
import com.qianwen.smartman.modules.cps.service.impl.CommonGroupOfItemServiceImpl;
import com.qianwen.smartman.modules.cps.service.impl.CommonGroupServiceImpl;
import com.qianwen.smartman.modules.cps.service.impl.EmployeeServiceImpl;
import com.qianwen.smartman.modules.sync.api.QyWechatApi;
import com.qianwen.smartman.modules.sync.constant.OuterAppConfigConstant;
import com.qianwen.smartman.modules.sync.constant.QyWechatConstant;
import com.qianwen.smartman.modules.sync.entity.OuterAppConfig;
import com.qianwen.smartman.modules.sync.entity.QyTag;
import com.qianwen.smartman.modules.sync.entity.QyUser;
import com.qianwen.smartman.modules.sync.enums.WechatEventEnum;
import com.qianwen.smartman.modules.sync.service.IOuterAppConfigService;
import com.qianwen.smartman.modules.sync.service.IWechatCallbackService;
import com.qianwen.smartman.modules.sync.vo.WechatCallbackVO;
import com.qianwen.smartman.modules.system.entity.Post;
import com.qianwen.smartman.modules.system.entity.UserOauth;
import com.qianwen.smartman.modules.system.service.impl.PostServiceImpl;
import com.qianwen.smartman.modules.system.service.impl.UserOauthServiceImpl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.core.util.XmlUtil;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/sync/service/impl/WechatCallbackServiceImpl.class */
public class WechatCallbackServiceImpl implements IWechatCallbackService {
    private static final Logger log = LoggerFactory.getLogger(WechatCallbackServiceImpl.class);
    private final Map<WechatEventEnum, Consumer<String>> xmlParseMap = new HashMap<>();
    private final WechatSyncServiceImpl wechatSyncService;
    private final PostServiceImpl postService;
    private final IEmployeePostService employeePostService;
    private final UserOauthServiceImpl userOauthService;
    private final CommonGroupServiceImpl commonGroupService;
    private final CommonGroupOfItemServiceImpl commonGroupOfItemService;
    private final EmployeeServiceImpl employeeService;
    private final CommonGroupMapper commonGroupMapper;
    private final IOuterAppConfigService outerAppConfigService;


    public WechatCallbackServiceImpl(final WechatSyncServiceImpl wechatSyncService, final PostServiceImpl postService, final IEmployeePostService employeePostService, final UserOauthServiceImpl userOauthService, final CommonGroupServiceImpl commonGroupService, final CommonGroupOfItemServiceImpl commonGroupOfItemService, final EmployeeServiceImpl employeeService, final CommonGroupMapper commonGroupMapper, final IOuterAppConfigService outerAppConfigService) {
        this.xmlParseMap.put(WechatEventEnum.USER_ADD_EVENT, this::parseUserAddEvent);
        this.xmlParseMap.put(WechatEventEnum.USER_REMOVE_EVENT, this::parseUserRemoveEvent);
        this.xmlParseMap.put(WechatEventEnum.DEPT_ADD_EVENT, this::parseDeptAddEvent);
        this.xmlParseMap.put(WechatEventEnum.DEPT_REMOVE_EVENT, this::parseDeptRemoveEvent);
        this.xmlParseMap.put(WechatEventEnum.TAG_UPDATE_EVENT, this::parseTagModifyEvent);
        this.wechatSyncService = wechatSyncService;
        this.postService = postService;
        this.employeePostService = employeePostService;
        this.userOauthService = userOauthService;
        this.commonGroupService = commonGroupService;
        this.commonGroupOfItemService = commonGroupOfItemService;
        this.employeeService = employeeService;
        this.commonGroupMapper = commonGroupMapper;
        this.outerAppConfigService = outerAppConfigService;
    }

    @Override // org.springblade.modules.sync.service.IWechatCallbackService
    public String callbackVerifyUrl(WechatCallbackVO callbackVO) {
        OuterAppConfig appConfig = this.outerAppConfigService.getAppConfig(OuterAppConfigConstant.QY_WECHAT);
        if (Objects.isNull(appConfig) || !appConfig.getStatus().equals(CommonConstant.ENABLE)) {
            log.info("[企业微信回调事件].[callbackVerifyUrl 配置为空或未启用配置]");
            return QyWechatConstant.CALLBACK_RESULT_NULL;
        }
        try {
            WXBizMsgCrypt wxBizMsgCrypt = new WXBizMsgCrypt(appConfig.getWxCallbackToken(), appConfig.getWxAesKey(), appConfig.getWxCorpId());
            return wxBizMsgCrypt.verifyUrl(callbackVO.getMsg_signature(), callbackVO.getTimestamp(), callbackVO.getNonce(), callbackVO.getEchostr());
        } catch (AesException e) {
            log.error("[企业微信回调配置校验].[callbackVerifyUrl params={}]", callbackVO, e);
            return QyWechatConstant.CALLBACK_ERROR;
        }
    }

    @Override // org.springblade.modules.sync.service.IWechatCallbackService
    @Transactional(rollbackFor = {Exception.class})
    public String callbackEvent(WechatCallbackVO callbackVO, String xmlData) {
        OuterAppConfig appConfig = this.outerAppConfigService.getAppConfig(OuterAppConfigConstant.QY_WECHAT);
        if (Objects.isNull(appConfig) || !appConfig.getStatus().equals(CommonConstant.ENABLE)) {
            log.info("[企业微信回调事件].[callbackEvent 配置为空或未启用配置]");
            return QyWechatConstant.CALLBACK_RESULT_NULL;
        }
        try {
            WXBizMsgCrypt wxBizMsgCrypt = new WXBizMsgCrypt(appConfig.getWxCallbackToken(), appConfig.getWxAesKey(), appConfig.getWxCorpId());
            String msg = wxBizMsgCrypt.decryptMsg(callbackVO.getMsg_signature(), callbackVO.getTimestamp(), callbackVO.getNonce(), xmlData);
            WechatEventEnum eventType = getEventType(msg);
            execSyncCallback(eventType, msg);
            return QyWechatConstant.CALLBACK_RESULT;
        } catch (Exception e) {
            log.error("[企业微信回调事件].[WechatCallbackVO error params={}]", callbackVO, e);
            return QyWechatConstant.CALLBACK_RESULT;
        }
    }

    private WechatEventEnum getEventType(String xmlData) {
        Document document = XmlUtil.parseXml(xmlData);
        Element root = document.getDocumentElement();
        String type = XmlUtil.elementText(root, QyWechatConstant.EVENT_TYPE);
        if (StrUtil.isNotEmpty(type)) {
            return WechatEventEnum.getWechatEventType(type);
        }
        return WechatEventEnum.DEFAULT;
    }

    private String getUserId(String xmlData) {
        Document document = XmlUtil.parseXml(xmlData);
        Element root = document.getDocumentElement();
        String userId = XmlUtil.elementText(root, QyWechatConstant.USER_ID);
        if (StrUtil.isEmpty(userId)) {
            return "";
        }
        return userId;
    }

    private String getDeptId(String xmlData) {
        Document document = XmlUtil.parseXml(xmlData);
        Element root = document.getDocumentElement();
        String deptId = XmlUtil.elementText(root, QyWechatConstant.DEPT_ID);
        if (StrUtil.isEmpty(deptId)) {
            return "";
        }
        return deptId;
    }

    private TagModifyBody getTagBody(String xmlData) {
        Document document = XmlUtil.parseXml(xmlData);
        Element root = document.getDocumentElement();
        String tagId = XmlUtil.elementText(root, QyWechatConstant.TAG_ID);
        String addUserList = XmlUtil.elementText(root, QyWechatConstant.TAG_ADD_USER);
        List<String> addUserIds = parseCallbackStr(addUserList);
        String deleteUserList = XmlUtil.elementText(root, QyWechatConstant.TAG_DELETE_USER);
        List<String> delUserIds = parseCallbackStr(deleteUserList);
        String tagName = getTagName(tagId);
        return TagModifyBody.builder().tagId(tagId).addUserList(addUserIds).deleteList(delUserIds).tagName(tagName).build();
    }

    private List<String> parseCallbackStr(String callbackData) {
        if (StrUtil.isEmpty(callbackData)) {
            return new ArrayList<>();
        }
        String[] dataArr = callbackData.split(",");
        return ListUtil.toList(dataArr);
    }

    private String getTagName(String tagId) {
        List<QyTag> tags = QyWechatApi.getTags();
        for (QyTag tag : tags) {
            if (tag.getTagid().equals(tagId)) {
                return tag.getTagname();
            }
        }
        return "";
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/sync/service/impl/WechatCallbackServiceImpl$TagModifyBody.class */
    public static class TagModifyBody {
        String tagId;
        String tagName;
        List<String> addUserList;
        List<String> deleteList;

        public void setTagId(final String tagId) {
            this.tagId = tagId;
        }

        public void setTagName(final String tagName) {
            this.tagName = tagName;
        }

        public void setAddUserList(final List<String> addUserList) {
            this.addUserList = addUserList;
        }

        public void setDeleteList(final List<String> deleteList) {
            this.deleteList = deleteList;
        }

        public TagModifyBody(final String tagId, final String tagName, final List<String> addUserList, final List<String> deleteList) {
            this.tagId = tagId;
            this.tagName = tagName;
            this.addUserList = addUserList;
            this.deleteList = deleteList;
        }

        /* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/sync/service/impl/WechatCallbackServiceImpl$TagModifyBody$TagModifyBodyBuilder.class */
        public static class TagModifyBodyBuilder {
            private String tagId;
            private String tagName;
            private List<String> addUserList;
            private List<String> deleteList;

            TagModifyBodyBuilder() {
            }

            public TagModifyBodyBuilder tagId(final String tagId) {
                this.tagId = tagId;
                return this;
            }

            public TagModifyBodyBuilder tagName(final String tagName) {
                this.tagName = tagName;
                return this;
            }

            public TagModifyBodyBuilder addUserList(final List<String> addUserList) {
                this.addUserList = addUserList;
                return this;
            }

            public TagModifyBodyBuilder deleteList(final List<String> deleteList) {
                this.deleteList = deleteList;
                return this;
            }

            public TagModifyBody build() {
                return new TagModifyBody(this.tagId, this.tagName, this.addUserList, this.deleteList);
            }

            public String toString() {
                return "WechatCallbackServiceImpl.TagModifyBody.TagModifyBodyBuilder(tagId=" + this.tagId + ", tagName=" + this.tagName + ", addUserList=" + this.addUserList + ", deleteList=" + this.deleteList + ")";
            }
        }

        public TagModifyBody() {
        }

        public static TagModifyBodyBuilder builder() {
            return new TagModifyBodyBuilder();
        }

        public String getTagId() {
            return this.tagId;
        }

        public String getTagName() {
            return this.tagName;
        }

        public List<String> getAddUserList() {
            return this.addUserList;
        }

        public List<String> getDeleteList() {
            return this.deleteList;
        }
    }

    private void parseUserAddEvent(String xmlData) {
        String userId = getUserId(xmlData);
        if (StrUtil.isEmpty(userId)) {
            return;
        }
        QyUser qyUser = QyWechatApi.getUserById(userId);
        UserOauth userOauth = this.userOauthService.getOne(Wrappers.<UserOauth>lambdaQuery().eq(UserOauth::getUuid, userId)
        		.eq(UserOauth::getSource, "WECHAT_ENTERPRISE_WEB"), Boolean.TRUE.booleanValue());
        /*
        UserOauth userOauth = (UserOauth) this.userOauthService.getOne((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getUuid();
        }, userId)).eq((v0) -> {
            return v0.getSource();
        }, QyWechatConstant.QY_SOURCE), Boolean.TRUE.booleanValue());*/
        this.wechatSyncService.createOrModifyEmployee(qyUser, userOauth);
    }

    private void parseUserRemoveEvent(String xmlData) {
        String userId = getUserId(xmlData);
        if (StrUtil.isEmpty(userId)) {
            return;
        }
        UserOauth userOauth = this.userOauthService.getOne(Wrappers.<UserOauth>lambdaQuery().eq(UserOauth::getUuid, userId));
        /*
        UserOauth userOauth = (UserOauth) this.userOauthService.getOne((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getUuid();
        }, userId));*/
        if (Objects.isNull(userOauth)) {
            return;
        }
        this.userOauthService.removeById(userOauth.getId());
        Employee employee = (Employee) this.employeeService.getById(userOauth.getUserId());
        if (Objects.isNull(employee)) {
            return;
        }
        this.employeeService.removeById(employee);
        this.commonGroupOfItemService.remove(Wrappers.<CommonGroupOfItem>lambdaQuery()
                .eq(CommonGroupOfItem::getGroupId, employee.getOrganizationId())
                .eq(CommonGroupOfItem::getItemId, employee.getId()));
        /*
        this.commonGroupOfItemService.remove((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getGroupId();
        }, employee.getOrganizationId())).eq((v0) -> {
            return v0.getItemId();
        }, employee.getId()));*/
        this.employeePostService.remove(Wrappers.<EmployeePost>lambdaQuery()
                .eq(EmployeePost::getPostId, employee.getPostId())
                .eq(EmployeePost::getEmployeeId, employee.getId()));
        /*
        this.employeePostService.remove((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getPostId();
        }, employee.getPostId())).eq((v0) -> {
            return v0.getEmployeeId();
        }, employee.getId()));*/
    }

    private void parseDeptAddEvent(String xmlBody) {
        String deptId = getDeptId(xmlBody);
        if (StrUtil.isEmpty(deptId)) {
            return;
        }
        saveCommonGroup(deptId);
    }

    private void saveCommonGroup(String deptId) {
        Department department = QyWechatApi.getDeptById(deptId);
        CommonGroup commonGroup = this.wechatSyncService.setCommonGroup(department);
        this.commonGroupService.insert(commonGroup);
    }

    private void parseDeptRemoveEvent(String xmlBody) {
        String deptId = getDeptId(xmlBody);
        if (StrUtil.isEmpty(deptId)) {
            return;
        }
        String localDeptId = QyWechatConstant.ID_SALT + deptId;
        long count = this.employeeService.count(Wrappers.<Employee>lambdaQuery().eq(Employee::getOrganizationId, localDeptId));
        /*
        long count = this.employeeService.count((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getOrganizationId();
        }, localDeptId));*/
        if (count > 0) {
            log.warn("[部门删除回调事件].[当前部门下有{}个员工，无法删除]", Long.valueOf(count));
            return;
        }
        this.commonGroupMapper.removeOrgByIds(ListUtil.of(new String[]{localDeptId}));
        this.commonGroupOfItemService.remove(Wrappers.<CommonGroupOfItem>lambdaQuery()
                .eq(CommonGroupOfItem::getGroupId, localDeptId).eq(CommonGroupOfItem::getGroupType, CommonGroupTypeEnum.ORGANIZATION.getName()));
        /*
        this.commonGroupOfItemService.remove((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getGroupId();
        }, localDeptId)).eq((v0) -> {
            return v0.getGroupType();
        }, CommonGroupTypeEnum.ORGANIZATION.getName()));*/
    }

    private void parseTagModifyEvent(String xmlBody) {
        TagModifyBody tagBody = getTagBody(xmlBody);
        Post post = (Post) this.postService.getById(tagBody.getTagId());
        if (Objects.isNull(post)) {
            this.postService.save(this.wechatSyncService.setPost(tagBody.getTagName(), tagBody.getTagId()));
        }
        addUsersByTag(tagBody);
        delUsersByTag(tagBody);
    }

    private void delUsersByTag(TagModifyBody tagBody) {
        if (CollectionUtil.isNotEmpty(tagBody.getDeleteList())) {
            log.info("[企业微信标签回调事件].[标签删除用户 userList={}]", tagBody.getDeleteList());
            List<Employee> employees = getEmpList(tagBody.getDeleteList());
            employees.forEach(emp -> {
                String handlerPostId = handlerPostId(Boolean.TRUE, emp.getPostId(), tagBody.getTagId());
                this.employeePostService.remove(Wrappers.<EmployeePost>lambdaQuery().eq(EmployeePost::getPostId, tagBody.getTagId())
                		.eq(EmployeePost::getEmployeeId, emp.getId()));
                /*
                this.employeePostService.remove((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
                    return v0.getPostId();
                }, tagBody.getTagId())).eq((v0) -> {
                    return v0.getEmployeeId();
                }, emp.getId()));*/
                emp.setPostId(handlerPostId);
            });
            this.employeeService.updateBatchById(employees);
        }
    }

    private String handlerPostId(Boolean isDel, String sourcePostId, String tagPostId) {
        ArrayList<String> postList;
        if (StrUtil.isEmpty(sourcePostId)) {
            postList = new ArrayList<>();
        } else {
            String[] postIds = sourcePostId.split(",");
            postList = ListUtil.toList(postIds);
        }
        if (isDel.booleanValue()) {
            postList.removeIf(id -> {
                return id.equals(tagPostId);
            });
        } else {
            postList.add(tagPostId);
        }
        return CollectionUtil.join(postList, ",");
    }

    private void addUsersByTag(TagModifyBody tagBody) {
        if (CollectionUtil.isNotEmpty(tagBody.getAddUserList())) {
            log.info("[企业微信标签回调事件].[标签新增用户 userList={}]", tagBody.getAddUserList());
            List<Employee> employees = getEmpList(tagBody.getAddUserList());
            List<EmployeePost> employeePosts = new ArrayList<>();
            employees.forEach(emp -> {
                String handlerPostId = handlerPostId(Boolean.FALSE, emp.getPostId(), tagBody.getTagId());
                employeePosts.add(this.wechatSyncService.setEmployeePost(tagBody.getTagId(), String.valueOf(emp.getId())));
                emp.setPostId(handlerPostId);
            });
            if (CollectionUtil.isNotEmpty(employeePosts)) {
                this.employeePostService.saveBatch(employeePosts);
            }
            this.employeeService.updateBatchById(employees);
        }
    }

    private List<Employee> getEmpList(List<String> userIds) {
    	List<UserOauth> auths = this.userOauthService.list(Wrappers.<UserOauth>lambdaQuery().in(UserOauth::getUuid, userIds));
    	/*
        List<UserOauth> auths = this.userOauthService.list((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getUuid();
        }, userIds));*/
        if (CollectionUtil.isEmpty(auths)) {
            return new ArrayList<>();
        }
        List<Long> empIds = auths.parallelStream().map((v0) -> {
            return v0.getUserId();
        }).collect(Collectors.toList());
        return this.employeeService.listByIds(empIds);
    }

    private void execSyncCallback(WechatEventEnum wechatEventEnum, String xmlData) {
        Consumer<String> parseMethod = this.xmlParseMap.get(wechatEventEnum);
        if (parseMethod != null) {
            parseMethod.accept(xmlData);
            log.info("[企业微信{}回调事件].[execSyncCallback 解析回调数据，进行同步]", wechatEventEnum.getDesc());
        }
    }
}