package jnpf.tmsService.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import jnpf.base.UserInfo;
import jnpf.exception.DataException;
import jnpf.permission.OrganizeApi;
import jnpf.permission.PositionApi;
import jnpf.permission.UserApi;
import jnpf.permission.entity.OrganizeEntity;
import jnpf.permission.entity.PositionEntity;
import jnpf.permission.entity.UserEntity;
import jnpf.tmsEntity.TmsPersonFileEntity;
import jnpf.tmsEntity.TmsPersonTrainEntity;
import jnpf.tmsEntity.TmsPersonWorkEntity;
import jnpf.tmsEntity.archive.TmsTrainArchiveCatalogVO;
import jnpf.tmsEntity.archive.TmsTrainArchiveDetailVO;
import jnpf.tmsEntity.archive.TmsTrainArchiveProfileVO;
import jnpf.tmsEntity.archive.TmsTrainArchiveWorkVO;
import jnpf.tmsMapper.TmsPersonFileMapper;
import jnpf.tmsMapper.TmsPersonTrainMapper;
import jnpf.tmsMapper.TmsPersonWorkMapper;
import jnpf.tmsService.TmsTrainArchiveService;
import jnpf.tmsEntity.enums.TmsPassFlag;
import jnpf.tmsEntity.enums.TmsTaskSourceType;
import jnpf.tmsEntity.enums.TmsTrainMode;
import jnpf.tmsEntity.enums.TmsTaskCategory;
import jnpf.tmsEntity.enums.TmsEvalMode;
import jnpf.tmsEntity.enums.TmsValidRevoked;
import jnpf.util.DateUtil;
import jnpf.util.RandomUtil;
import jnpf.util.StringUtil;
import jnpf.util.UserProvider;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 学员「我的个人培训档案」：主档 {@code tms_person_file} + 履历 + 培训目录。
 *
 * <p>培训目录 {@code catalogList} 只读 {@code tms_person_train}，
 * 数据来自培训记录归档（{@link TmsRecordServiceImpl#upsertPersonTrain}），非实时学习写入。</p>
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class TmsTrainArchiveServiceImpl implements TmsTrainArchiveService {

    private final TmsPersonFileMapper personFileMapper;
    private final TmsPersonWorkMapper personWorkMapper;
    private final TmsPersonTrainMapper personTrainMapper;
    private final OrganizeApi organizeApi;
    private final PositionApi positionApi;
    private final UserApi userApi;

    /**
     * 当前登录人档案；无主档则自动建档。
     * catalogList ← {@link #loadCatalogList} ← tms_person_train。
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public TmsTrainArchiveDetailVO getMine() {
        UserInfo user = UserProvider.getUser();
        if (user == null || StringUtil.isEmpty(user.getUserId())) {
            throw new DataException("未获取到登录用户");
        }
        String userId = user.getUserId();
        TmsPersonFileEntity file = findByUserId(userId);
        if (file == null) {
            file = createArchive(user);
        }

        TmsTrainArchiveDetailVO detail = new TmsTrainArchiveDetailVO();
        detail.setProfile(toProfile(file, user));
        detail.setWorkList(loadWorkList(file.getId()));
        detail.setCatalogList(loadCatalogList(file.getId(), userId));
        return detail;
    }

    /**
     * 按用户 ID 查找档案主档
     */
    private TmsPersonFileEntity findByUserId(String userId) {
        LambdaQueryWrapper<TmsPersonFileEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsPersonFileEntity::getUserId, userId);
        qw.last("LIMIT 1");
        return personFileMapper.selectOne(qw);
    }

    /**
     * 创建个人培训档案主档
     */
    private TmsPersonFileEntity createArchive(UserInfo user) {
        Date now = new Date();
        TmsPersonFileEntity entity = new TmsPersonFileEntity();
        entity.setId(RandomUtil.uuId());
        entity.setArchiveNo(nextArchiveNo());
        entity.setArchiveDate(now);
        entity.setUserId(user.getUserId());
        entity.setUserName(user.getUserName());
        entity.setDeptId(user.getOrganizeId());
        List<String> positionIds = normalizeIds(user.getPositionIds());
        if (!positionIds.isEmpty()) {
            entity.setMainPostId(positionIds.get(0));
            if (positionIds.size() > 1) {
                entity.setPartPostId(positionIds.get(1));
            }
        }
        entity.setBizStatus(TmsValidRevoked.VALID.getCode());
        entity.setCreatorUserId(user.getUserId());
        entity.setCreatorTime(now);
        personFileMapper.insert(entity);
        return entity;
    }

    /**
     * 规范化 ID 列表
     */
    private List<String> normalizeIds(Object raw) {
        if (raw == null) {
            return Collections.emptyList();
        }
        if (raw instanceof List) {
            List<?> list = (List<?>) raw;
            List<String> out = new ArrayList<>();
            for (Object o : list) {
                if (o != null && StringUtil.isNotEmpty(String.valueOf(o))) {
                    out.add(String.valueOf(o));
                }
            }
            return out;
        }
        if (raw instanceof String[]) {
            List<String> out = new ArrayList<>();
            for (String s : (String[]) raw) {
                if (StringUtil.isNotEmpty(s)) {
                    out.add(s);
                }
            }
            return out;
        }
        if (raw instanceof String && StringUtil.isNotEmpty((String) raw)) {
            return Collections.singletonList((String) raw);
        }
        return Collections.emptyList();
    }

    /** 档案编号：AR + 年份 + 4 位流水 */
    private String nextArchiveNo() {
        int year = Calendar.getInstance().get(Calendar.YEAR);
        String prefix = "AR" + year;
        LambdaQueryWrapper<TmsPersonFileEntity> qw = new LambdaQueryWrapper<>();
        qw.likeRight(TmsPersonFileEntity::getArchiveNo, prefix);
        qw.orderByDesc(TmsPersonFileEntity::getArchiveNo);
        qw.last("LIMIT 1");
        TmsPersonFileEntity last = personFileMapper.selectOne(qw);
        int seq = 1;
        if (last != null && StringUtil.isNotEmpty(last.getArchiveNo()) && last.getArchiveNo().length() >= prefix.length() + 4) {
            try {
                seq = Integer.parseInt(last.getArchiveNo().substring(prefix.length())) + 1;
            } catch (NumberFormatException ignored) {
                seq = 1;
            }
        }
        return prefix + String.format("%04d", Math.min(seq, 9999));
    }

    /**
     * 转为档案基本信息 VO
     */
    private TmsTrainArchiveProfileVO toProfile(TmsPersonFileEntity file, UserInfo user) {
        TmsTrainArchiveProfileVO vo = new TmsTrainArchiveProfileVO();
        vo.setId(file.getId());
        vo.setArchiveNo(file.getArchiveNo());
        vo.setArchiveDate(file.getArchiveDate() == null ? null : DateUtil.dateToString(file.getArchiveDate(), "yyyy-MM-dd"));
        vo.setUserId(file.getUserId());
        vo.setUserName(StringUtil.isNotEmpty(file.getUserName()) ? file.getUserName() : user.getUserName());
        vo.setDeptName(resolveDeptName(file.getDeptId(), user));
        vo.setMainPostName(resolvePostName(file.getMainPostId(), user, true));
        vo.setPartPostName(resolvePostName(file.getPartPostId(), user, false));
        return vo;
    }

    /**
     * 解析部门名称
     */
    private String resolveDeptName(String deptId, UserInfo user) {
        if (StringUtil.isNotEmpty(deptId)) {
            try {
                OrganizeEntity org = organizeApi.getInfoById(deptId);
                if (org != null && StringUtil.isNotEmpty(org.getFullName())) {
                    return org.getFullName();
                }
            } catch (Exception e) {
                log.debug("resolve dept name failed: {}", e.getMessage());
            }
        }
        if (user != null && StringUtil.isNotEmpty(user.getOrganize())) {
            return user.getOrganize();
        }
        return "无";
    }

    /**
     * 解析岗位名称
     */
    private String resolvePostName(String postId, UserInfo user, boolean main) {
        if (StringUtil.isNotEmpty(postId)) {
            try {
                PositionEntity pos = positionApi.queryInfoById(postId);
                if (pos != null && StringUtil.isNotEmpty(pos.getFullName())) {
                    return pos.getFullName();
                }
            } catch (Exception e) {
                log.debug("resolve post name failed: {}", e.getMessage());
            }
        }
        if (main && user != null) {
            List<String> positionIds = normalizeIds(user.getPositionIds());
            if (!positionIds.isEmpty()) {
                try {
                    List<PositionEntity> list = positionApi.getListByIds(positionIds);
                    if (list != null && !list.isEmpty() && StringUtil.isNotEmpty(list.get(0).getFullName())) {
                        return list.get(0).getFullName();
                    }
                } catch (Exception e) {
                    log.debug("resolve main post from user failed: {}", e.getMessage());
                }
            }
        }
        return "无";
    }

        /**
         * 加载工作履历
         */
        private List<TmsTrainArchiveWorkVO> loadWorkList(String archiveId) {
        LambdaQueryWrapper<TmsPersonWorkEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsPersonWorkEntity::getForeignId, archiveId);
        qw.orderByAsc(TmsPersonWorkEntity::getHireDate);
        List<TmsPersonWorkEntity> rows = personWorkMapper.selectList(qw);
        if (rows == null || rows.isEmpty()) {
            return Collections.emptyList();
        }
        List<TmsTrainArchiveWorkVO> list = new ArrayList<>(rows.size());
        for (TmsPersonWorkEntity row : rows) {
            TmsTrainArchiveWorkVO vo = new TmsTrainArchiveWorkVO();
            vo.setId(row.getId());
            vo.setCompanyName(row.getCompanyName());
            vo.setPostName(row.getPostName());
            vo.setHireDate(row.getHireDate() == null ? null : DateUtil.dateToString(row.getHireDate(), "yyyy-MM-dd"));
            vo.setLeaveDate(row.getLeaveDate() == null ? null : DateUtil.dateToString(row.getLeaveDate(), "yyyy-MM-dd"));
            list.add(vo);
        }
        return list;
    }

    /** 按档案/用户加载培训目录（已归档写入的 person_train）。 */
    private List<TmsTrainArchiveCatalogVO> loadCatalogList(String archiveId, String userId) {
        LambdaQueryWrapper<TmsPersonTrainEntity> qw = new LambdaQueryWrapper<>();
        qw.and(w -> w.eq(TmsPersonTrainEntity::getArchiveId, archiveId)
                .or()
                .eq(TmsPersonTrainEntity::getUserId, userId));
        qw.orderByDesc(TmsPersonTrainEntity::getStartTime);
        List<TmsPersonTrainEntity> rows = personTrainMapper.selectList(qw);
        if (rows == null || rows.isEmpty()) {
            return Collections.emptyList();
        }
        // 去重：同一 id 只保留一条
        List<TmsPersonTrainEntity> distinct = new ArrayList<>(rows.stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toMap(TmsPersonTrainEntity::getId, r -> r, (a, b) -> a, LinkedHashMap::new))
                .values());
        distinct.sort((a, b) -> {
            Date ta = a.getStartTime();
            Date tb = b.getStartTime();
            if (ta == null && tb == null) return 0;
            if (ta == null) return 1;
            if (tb == null) return -1;
            return tb.compareTo(ta);
        });

        Set<String> teacherIds = new HashSet<>();
        for (TmsPersonTrainEntity row : distinct) {
            teacherIds.addAll(splitIds(row.getTeacherId()));
        }
        Map<String, String> teacherNames = loadUserNames(teacherIds);

        List<TmsTrainArchiveCatalogVO> list = new ArrayList<>(distinct.size());
        for (TmsPersonTrainEntity row : distinct) {
            list.add(toCatalog(row, teacherNames));
        }
        return list;
    }

    /**
     * 转为档案目录项 VO
     */
    private TmsTrainArchiveCatalogVO toCatalog(TmsPersonTrainEntity row, Map<String, String> teacherNames) {
        TmsTrainArchiveCatalogVO vo = new TmsTrainArchiveCatalogVO();
        vo.setId(row.getId());
        vo.setRecordNo(row.getRecordNo());
        vo.setTrainType(labelCategory(row.getCategory()));
        vo.setTrainContent(row.getSubject());
        vo.setTrainMode(labelTrainMode(row.getTrainMode()));
        vo.setTrainerName(resolveTeacherNames(row.getTeacherId(), teacherNames));
        vo.setEvalMode(labelEvalMode(row.getEvalMode()));
        vo.setPassFlag(normalizePassFlag(row.getPassFlag()));
        vo.setTrainStart(row.getStartTime() == null ? null : DateUtil.dateToString(row.getStartTime(), "yyyy-MM-dd HH:mm"));
        vo.setTrainEnd(row.getEndTime() == null ? null : DateUtil.dateToString(row.getEndTime(), "yyyy-MM-dd HH:mm"));
        return vo;
    }

    /**
     * 批量加载用户姓名
     */
    private Map<String, String> loadUserNames(Set<String> userIds) {
        Map<String, String> map = new HashMap<>();
        if (userIds == null || userIds.isEmpty()) {
            return map;
        }
        try {
            List<UserEntity> users = userApi.getUserName(new ArrayList<>(userIds));
            if (users != null) {
                for (UserEntity u : users) {
                    if (u != null && StringUtil.isNotEmpty(u.getId())) {
                        map.put(u.getId(), StringUtil.isNotEmpty(u.getRealName()) ? u.getRealName() : u.getId());
                    }
                }
            }
        } catch (Exception e) {
            log.debug("resolve users failed: {}", e.getMessage());
        }
        return map;
    }

    /**
     * 解析讲师姓名（可多人）
     */
    private String resolveTeacherNames(String teacherId, Map<String, String> nameMap) {
        if (StringUtil.isEmpty(teacherId)) {
            return "";
        }
        List<String> ids = splitIds(teacherId);
        if (ids.isEmpty()) {
            return teacherId;
        }
        List<String> names = new ArrayList<>();
        for (String id : ids) {
            names.add(nameMap.getOrDefault(id, id));
        }
        return String.join("、", names);
    }

    /**
     * 拆分 ID 字符串
     */
    private List<String> splitIds(String raw) {
        if (StringUtil.isEmpty(raw)) {
            return Collections.emptyList();
        }
        String[] parts = raw.split("[,，;；\\s]+");
        List<String> out = new ArrayList<>();
        for (String p : parts) {
            if (StringUtil.isNotEmpty(p)) {
                out.add(p.trim());
            }
        }
        return out;
    }

    /** 归一为 tmsPassFlag：pass/fail/absent/na；兼容历史 1/0 */
    private String normalizePassFlag(String raw) {
        String n = TmsPassFlag.normalize(raw);
        return n == null ? "" : n;
    }

    /**
     * 培训类别标签
     */
    private String labelCategory(String code) {
        if (StringUtil.isEmpty(code)) {
            return "";
        }
        TmsTaskCategory category = TmsTaskCategory.of(code);
        if (category != null) {
            return category == TmsTaskCategory.OUT_TRAIN ? "外派培训" : category.getLabel();
        }
        TmsTaskSourceType source = TmsTaskSourceType.of(code);
        if (source != null) {
            return source.getLabel();
        }
        if ("temporary".equals(code)) {
            return TmsTaskCategory.TEMP.getLabel();
        }
        return code;
    }

    /**
     * 培训方式标签
     */
    private String labelTrainMode(String code) {
        if (StringUtil.isEmpty(code)) {
            return "";
        }
        TmsTrainMode mode = TmsTrainMode.of(code.toLowerCase());
        if (mode == null) {
            return code;
        }
        switch (mode) {
            case ONLINE:
                return "在线学习";
            case ONSITE:
                return "集中授课";
            case PRACTICE:
                return "操作授课";
            default:
                return mode.getLabel();
        }
    }

    /**
     * 评估方式标签
     */
    private String labelEvalMode(String code) {
        if (StringUtil.isEmpty(code)) {
            return "";
        }
        TmsEvalMode mode = TmsEvalMode.of(code.toLowerCase());
        if (mode == null) {
            return code;
        }
        switch (mode) {
            case EXAM:
                return "在线考试";
            case NONE:
                return "无需考核";
            case QUIZ:
                return "现场提问";
            case PRACTICE:
                return "实操考核";
            default:
                return mode.getLabel();
        }
    }
}