package org.jeecg.modules.mes.job;

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.util.PasswordUtil;
import org.jeecg.common.util.RestUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.mes.entity.FeishuUser;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.service.ISysUserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
@Slf4j
public class FeishuUserService {

    @Resource
    private ISysUserService sysUserService;

    @Resource
    private RestTemplate restTemplate;  // 新增RestTemplate依赖注入

    @Value("${feishu.appId:}")
    private String appId;

    @Value("${feishu.appSecret:}")
    private String appSecret;

    @Value("${feishu.url:}")
    private String feishuUrl;

    /**
     * 同步飞书部门用户到系统用户表
     * @param departmentId 飞书部门ID
     */
    public void syncFeishuDepartmentUsers(String departmentId) {
        try {
            log.info("开始同步飞书部门用户，部门ID: {}", departmentId);

            // 1. 获取飞书访问令牌
            String accessToken = getFeishuAccessToken();
            if (oConvertUtils.isEmpty(accessToken)) {
                log.error("获取飞书访问令牌失败，终止同步流程");
                return;  // 令牌获取失败直接返回，避免后续无效操作
            }

            // 2. 获取部门下的用户列表
            List<FeishuUser> feishuUsers = getDepartmentUsers(accessToken, departmentId);
            log.info("获取到飞书部门用户数量: {}", feishuUsers.size());

            // 3. 同步到系统用户表
            int successCount = 0;
            int updateCount = 0;
            int addCount = 0;

            for (FeishuUser feishuUser : feishuUsers) {
                try {
                    boolean isUpdated = syncFeishuUserToSystem(feishuUser);
                    successCount++;
                    if (isUpdated) {
                        updateCount++;
                    } else {
                        addCount++;
                    }
                } catch (Exception e) {
                    log.error("同步飞书用户失败，用户ID: {}", feishuUser.getUserId(), e);
                }
            }

            log.info("飞书用户同步完成，总处理: {}，新增: {}，更新: {}", successCount, addCount, updateCount);
        } catch (Exception e) {
            log.error("同步飞书部门用户失败，部门ID: {}", departmentId, e);
            throw new RuntimeException("同步飞书用户失败: " + e.getMessage());
        }
    }

    private String getFeishuAccessToken() {
        try {
            String url = feishuUrl + "open-apis/auth/v3/tenant_access_token/internal";

            log.info("开始获取飞书访问令牌，AppId: {}",
                    appId != null ? appId.substring(0, Math.min(appId.length(), 10)) + "..." : "null");

            JSONObject params = new JSONObject();
            params.put("app_id", appId);
            params.put("app_secret", appSecret);

            log.debug("获取令牌请求参数: {}", params.toJSONString());

            JSONObject result = RestUtil.post(url, params);

            log.info("获取飞书访问令牌响应: {}", result != null ? result.toJSONString() : "null");

            if (result != null && result.getInteger("code") == 0) {
                String accessToken = result.getString("tenant_access_token");
                log.info("成功获取飞书访问令牌，令牌长度: {}", accessToken != null ? accessToken.length() : 0);
                return accessToken;
            } else {
                log.error("获取飞书访问令牌失败，响应: {}", result != null ? result.toJSONString() : "null");
                if (result != null) {
                    log.error("错误码: {}, 错误信息: {}", result.getInteger("code"), result.getString("msg"));
                }
                return null;
            }
        } catch (Exception e) {
            log.error("获取飞书访问令牌异常", e);
            return null;
        }
    }

    /**
     * 获取部门用户列表（直属员工）
     */
    private List<FeishuUser> getDepartmentUsers(String accessToken, String departmentId) {
        List<FeishuUser> userList = new ArrayList<>();
        try {
            log.info("开始获取飞书部门用户列表，部门ID: {}", departmentId);

            // 验证访问令牌
            if (accessToken == null || accessToken.isEmpty()) {
                log.error("访问令牌为空，无法继续执行");
                return userList;
            }
            log.info("使用的访问令牌前缀: Bearer {}", accessToken.substring(0, Math.min(20, accessToken.length())) + "...");

            // 飞书API端点
            String url = feishuUrl + "open-apis/contact/v3/users/find_by_department";

            String pageToken = null;
            int pageNumber = 1;

            do {
                // 构建请求URL和参数
                StringBuilder urlBuilder = new StringBuilder(url);
                urlBuilder.append("?department_id=").append(departmentId);
                urlBuilder.append("&department_id_type=open_department_id");
                urlBuilder.append("&page_size=50");
                urlBuilder.append("&user_id_type=open_id");

                if (pageToken != null && !pageToken.isEmpty()) {
                    urlBuilder.append("&page_token=").append(pageToken);
                }

                log.info("请求第{}页数据，URL: {}", pageNumber, urlBuilder.toString());

                // 设置请求头 - 关键修复点：使用HttpHeaders确保头信息正确设置
                HttpHeaders headers = new HttpHeaders();
                String authHeader = "Bearer " + accessToken;
                headers.add("Authorization", authHeader);
                headers.add("Content-Type", "application/json; charset=utf-8");
                log.info("设置请求头: Authorization = {}", authHeader.substring(0, Math.min(30, authHeader.length())) + "...");

                // 使用RestTemplate发送请求，确保头信息被正确传递
                HttpEntity<String> requestEntity = new HttpEntity<>(headers);
                ResponseEntity<String> response = restTemplate.exchange(
                        urlBuilder.toString(),
                        HttpMethod.GET,
                        requestEntity,
                        String.class
                );

                // 解析响应
                JSONObject result = JSONObject.parseObject(response.getBody());
                log.debug("第{}页API响应: {}", pageNumber, result != null ? result.toJSONString() : "null");

                if (result != null && result.getInteger("code") == 0) {
                    JSONObject data = result.getJSONObject("data");
                    if (data != null) {
                        // 解析用户列表
                        Object items = data.get("items");
                        log.info("第{}页原始用户数据数量: {}", pageNumber, items instanceof List ? ((List<?>) items).size() : 0);

                        if (items != null) {
                            List<FeishuUser> pageUsers = parseUsers(items);
                            userList.addAll(pageUsers);
                            log.info("第{}页解析后用户数量: {}", pageNumber, pageUsers.size());
                        }

                        // 检查是否有下一页
                        pageToken = data.getString("page_token");
                        boolean hasMore = data.getBooleanValue("has_more");
                        log.info("第{}页has_more: {}, page_token: {}", pageNumber, hasMore, pageToken);
                        pageNumber++;
                    } else {
                        log.warn("第{}页data为空", pageNumber);
                        break;
                    }
                } else {
                    log.error("获取飞书部门用户列表失败，响应: {}", result != null ? result.toJSONString() : "null");
                    if (result != null) {
                        log.error("错误码: {}, 错误信息: {}", result.getInteger("code"), result.getString("msg"));
                    }
                    break;
                }
            } while (pageToken != null && !pageToken.isEmpty());

            log.info("获取飞书部门用户完成，总用户数量: {}", userList.size());

        } catch (Exception e) {
            log.error("获取飞书部门用户列表异常", e);
        }
        return userList;
    }

    /**
     * 解析用户数据
     */
    /**
     * 解析用户数据
     */
    @SuppressWarnings("unchecked")
    private List<FeishuUser> parseUsers(Object items) {
        Logger log = LoggerFactory.getLogger(FeishuUserService.class);
        List<FeishuUser> userList = new ArrayList<>();
        if (!(items instanceof List)) {
            log.warn("解析用户数据失败，items不是列表类型: {}", items);
            return userList;
        }
        List<?> userItems = (List<?>) items;
        log.info("开始解析飞书用户列表，共{}条记录", userItems.size());
        for (Object item : userItems) {
            if (item == null || !(item instanceof Map)) {
                log.warn("跳过无效用户数据项，类型不匹配: {}", item != null ? item.getClass() : "null");
                continue;
            }
            Map<String, Object> userMap = (Map<String, Object>) item;
            FeishuUser user = new FeishuUser();
            // 解析open_id
            user.setOpenId((String) userMap.getOrDefault("open_id", ""));
            // 解析name并拆分
            String name = (String) userMap.getOrDefault("name", "");
            if (name.contains(" ")) {
                String[] parts = name.split(" ");
                if (parts.length == 2) {
                    user.setUsername(parts[0].trim()); // 工号部分存到username
                    user.setRealname(parts[1].trim()); // 姓名部分存到realname
                    user.setWorkNo(parts[0].trim());   // 工号也存到workNo
                } else {
                    // 拆分异常时，默认处理
                    user.setUsername(name);
                    user.setRealname(name);
                    user.setWorkNo("");
                    log.warn("飞书用户name字段格式异常，无法拆分，原始值：{}", name);
                }
            } else {
                user.setUsername(name);
                user.setRealname(name);
                user.setWorkNo("");
                log.warn("飞书用户name字段无空格分隔，无法拆分，原始值：{}", name);
            }
            // 解析其他基本信息
            user.setEnName((String) userMap.getOrDefault("en_name", ""));
            user.setDescription((String) userMap.getOrDefault("description", ""));
            Object mobileVisibleObj = userMap.get("mobile_visible");
            user.setMobileVisible(mobileVisibleObj instanceof Boolean ? (Boolean) mobileVisibleObj : false);
            // 解析头像信息
            Object avatarObj = userMap.get("avatar");
            if (avatarObj instanceof Map) {
                Map<String, Object> avatarMap = (Map<String, Object>) avatarObj;
                user.setAvatar240((String) avatarMap.getOrDefault("avatar_240", ""));
                user.setAvatar640((String) avatarMap.getOrDefault("avatar_640", ""));
                user.setAvatar72((String) avatarMap.getOrDefault("avatar_72", ""));
                user.setAvatarOrigin((String) avatarMap.getOrDefault("avatar_origin", ""));
            } else {
                log.info("用户[{}]未设置头像或头像格式异常", user.getRealname());
            }
            // 设置默认加密密码（这里假设密码是简单加密存储，实际建议用更安全的加密方式）
            user.setPassword("123456"); // 你要求的默认密码
            // 将open_id存到对应的字段（根据你的用户表结构，假设用户表有open_id字段）
            user.setOpenId((String) userMap.getOrDefault("open_id", ""));
            userList.add(user);
        }

        return userList;
    }

    /**
     * 同步单个飞书用户到系统
     * @param feishuUser 飞书用户
     * @return true表示更新，false表示新增
     *
     * 后期增加： 用户同步对比，飞书离职员工需要在本地用户表里面将该用户状态禁用
     */
    private boolean syncFeishuUserToSystem(FeishuUser feishuUser) {
        // 这里根据拆分后的username（工号）去查询系统用户
        String username = feishuUser.getUsername();
        SysUser existUser = sysUserService.getUserByName(username);
        SysUser sysUser = new SysUser();
        sysUser.setUsername(username);
        sysUser.setStatus(1);
        sysUser.setDelFlag(0);
        sysUser.setAvatar(feishuUser.getAvatar640());
        sysUser.setRealname(feishuUser.getRealname());
        sysUser.setWorkNo(feishuUser.getWorkNo());
        String password = "123456", salt = oConvertUtils.randomGen(8);
        String passwordEncode = PasswordUtil.encrypt(sysUser.getUsername(), password, salt);
        sysUser.setSalt(salt);
        sysUser.setPassword(passwordEncode);
        sysUser.setOpenId(feishuUser.getOpenId());

        if (existUser == null) {

            sysUserService.addUserWithRole(sysUser, "5");
            log.info("新增用户: {}", username);
            return false;
        } else {
            sysUser.setId(existUser.getId());
            sysUserService.editUser(sysUser);
            log.info("更新用户: {}", username);
            return true;
        }
    }
}