package jnpf.tmsService.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
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.TmsPersonTaskEntity;
import jnpf.tmsEntity.TmsPersonTrainEntity;
import jnpf.tmsEntity.TmsTaskEntity;
import jnpf.tmsEntity.trainrecord.TmsTrainRecordCatalogItemVO;
import jnpf.tmsEntity.trainrecord.TmsTrainRecordCatalogVO;
import jnpf.tmsEntity.trainrecord.TmsTrainRecordListVO;
import jnpf.tmsEntity.trainrecord.TmsTrainRecordQuery;
import jnpf.tmsMapper.TmsPersonFileMapper;
import jnpf.tmsMapper.TmsPersonTaskMapper;
import jnpf.tmsMapper.TmsPersonTrainMapper;
import jnpf.tmsMapper.TmsTaskMapper;
import jnpf.tmsService.TmsTrainRecordService;
import jnpf.util.DateUtil;
import jnpf.util.StringUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
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;

@Slf4j
@Service
@RequiredArgsConstructor
public class TmsTrainRecordServiceImpl implements TmsTrainRecordService {

    private static final String DATE_FMT = "yyyy-MM-dd";

    private final TmsPersonFileMapper personFileMapper;
    private final TmsPersonTrainMapper personTrainMapper;
    private final TmsPersonTaskMapper personTaskMapper;
    private final TmsTaskMapper taskMapper;
    private final OrganizeApi organizeApi;
    private final PositionApi positionApi;
    private final UserApi userApi;

    @Override
    public List<TmsTrainRecordListVO> getList(TmsTrainRecordQuery query) {
        LambdaQueryWrapper<TmsPersonFileEntity> qw = new LambdaQueryWrapper<>();
        if (StringUtil.isNotEmpty(query.getArchiveNo()) && !"null".equalsIgnoreCase(query.getArchiveNo())) {
            qw.like(TmsPersonFileEntity::getArchiveNo, query.getArchiveNo().trim());
        }
        if (StringUtil.isNotEmpty(query.getKeyword()) && !"null".equalsIgnoreCase(query.getKeyword())) {
            String kw = query.getKeyword().trim();
            qw.and(w -> w.like(TmsPersonFileEntity::getUserName, kw)
                    .or().like(TmsPersonFileEntity::getArchiveNo, kw)
                    .or().like(TmsPersonFileEntity::getDeptId, kw));
        }
        qw.orderByDesc(TmsPersonFileEntity::getArchiveDate)
                .orderByDesc(TmsPersonFileEntity::getCreatorTime);

        long current = query.getCurrentPage() > 0 ? query.getCurrentPage() : 1;
        long size = query.getPageSize() > 0 ? query.getPageSize() : 20;
        Page<TmsPersonFileEntity> page = personFileMapper.selectPage(new Page<>(current, size), qw);
        List<TmsPersonFileEntity> rows = page.getRecords();
        if (rows == null || rows.isEmpty()) {
            query.setData(Collections.emptyList(), page.getTotal());
            return Collections.emptyList();
        }

        Map<String, String> deptNames = loadDeptNames(rows.stream()
                .map(TmsPersonFileEntity::getDeptId)
                .filter(StringUtil::isNotEmpty)
                .collect(Collectors.toSet()));
        Map<String, String> postNames = loadPostNames(rows);

        List<TmsTrainRecordListVO> list = new ArrayList<>(rows.size());
        for (TmsPersonFileEntity row : rows) {
            list.add(toListVo(row, deptNames, postNames));
        }
        query.setData(list, page.getTotal());
        return list;
    }

    @Override
    public TmsTrainRecordCatalogVO getCatalog(String archiveId, String startDate, String endDate) {
        if (StringUtil.isEmpty(archiveId)) {
            throw new DataException("档案ID不能为空");
        }
        TmsPersonFileEntity file = personFileMapper.selectById(archiveId);
        if (file == null) {
            throw new DataException("个人培训记录不存在");
        }

        List<TmsTrainRecordCatalogItemVO> items = new ArrayList<>();
        Set<String> seenNos = new HashSet<>();

        // 1) 档案目录表（若已同步）
        for (TmsPersonTrainEntity row : loadPersonTrains(file)) {
            TmsTrainRecordCatalogItemVO item = fromPersonTrain(row);
            if (item == null || !inDateRange(item.getTrainDate(), startDate, endDate)) {
                continue;
            }
            if (StringUtil.isNotEmpty(item.getRecordNo())) {
                seenNos.add(item.getRecordNo());
            }
            items.add(item);
        }

        // 2) 个人培训任务（联调/日常主数据源）
        for (TmsTrainRecordCatalogItemVO item : loadFromPersonTasks(file.getUserId())) {
            if (item == null || !inDateRange(item.getTrainDate(), startDate, endDate)) {
                continue;
            }
            if (StringUtil.isNotEmpty(item.getRecordNo()) && seenNos.contains(item.getRecordNo())) {
                continue;
            }
            if (StringUtil.isNotEmpty(item.getRecordNo())) {
                seenNos.add(item.getRecordNo());
            }
            items.add(item);
        }

        items.sort(Comparator.comparing(TmsTrainRecordCatalogItemVO::getTrainDate,
                Comparator.nullsLast(Comparator.reverseOrder())));

        TmsTrainRecordCatalogVO vo = new TmsTrainRecordCatalogVO();
        vo.setId(file.getId());
        vo.setUserName(file.getUserName());
        vo.setArchiveNo(file.getArchiveNo());
        vo.setList(items);
        return vo;
    }

    private List<TmsPersonTrainEntity> loadPersonTrains(TmsPersonFileEntity file) {
        LambdaQueryWrapper<TmsPersonTrainEntity> qw = new LambdaQueryWrapper<>();
        qw.and(w -> w.eq(TmsPersonTrainEntity::getArchiveId, file.getId())
                .or()
                .eq(TmsPersonTrainEntity::getUserId, file.getUserId()));
        qw.orderByDesc(TmsPersonTrainEntity::getStartTime);
        List<TmsPersonTrainEntity> rows = personTrainMapper.selectList(qw);
        if (rows == null || rows.isEmpty()) {
            return Collections.emptyList();
        }
        return new ArrayList<>(rows.stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toMap(TmsPersonTrainEntity::getId, r -> r, (a, b) -> a, LinkedHashMap::new))
                .values());
    }

    private List<TmsTrainRecordCatalogItemVO> loadFromPersonTasks(String userId) {
        if (StringUtil.isEmpty(userId)) {
            return Collections.emptyList();
        }
        LambdaQueryWrapper<TmsPersonTaskEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsPersonTaskEntity::getUserId, userId);
        qw.ne(TmsPersonTaskEntity::getBizStatus, "cancelled");
        qw.orderByDesc(TmsPersonTaskEntity::getCreatorTime);
        List<TmsPersonTaskEntity> pts = personTaskMapper.selectList(qw);
        if (pts == null || pts.isEmpty()) {
            return Collections.emptyList();
        }

        Set<String> taskIds = pts.stream()
                .map(TmsPersonTaskEntity::getTaskId)
                .filter(StringUtil::isNotEmpty)
                .collect(Collectors.toSet());
        Map<String, TmsTaskEntity> taskMap = new HashMap<>();
        if (!taskIds.isEmpty()) {
            for (TmsTaskEntity t : taskMapper.selectBatchIds(taskIds)) {
                if (t != null) {
                    taskMap.put(t.getId(), t);
                }
            }
        }

        Set<String> teacherIds = taskMap.values().stream()
                .map(TmsTaskEntity::getTeacherId)
                .filter(StringUtil::isNotEmpty)
                .flatMap(s -> splitIds(s).stream())
                .collect(Collectors.toSet());
        Map<String, String> teacherNames = loadUserNames(teacherIds);

        List<TmsTrainRecordCatalogItemVO> list = new ArrayList<>(pts.size());
        for (TmsPersonTaskEntity pt : pts) {
            TmsTaskEntity task = taskMap.get(pt.getTaskId());
            TmsTrainRecordCatalogItemVO item = new TmsTrainRecordCatalogItemVO();
            item.setId(pt.getId());
            item.setRecordNo(StringUtil.isNotEmpty(pt.getTaskNo())
                    ? pt.getTaskNo()
                    : (task == null ? "" : task.getTaskNo()));
            if (task != null) {
                item.setTrainType(labelCategory(firstNonEmpty(task.getCategory(), task.getTrainType())));
                item.setTrainContent(task.getSubject());
                item.setTrainMode(labelTrainMode(task.getTrainMode()));
                item.setEvalMode(labelEvalMode(task.getEvalMode()));
                item.setTrainerName(resolveTeacherNames(task.getTeacherId(), teacherNames));
                item.setTrainDate(fmtDate(task.getStartTime()));
            } else {
                item.setTrainType("");
                item.setTrainContent(pt.getTaskNo());
                item.setTrainMode("");
                item.setEvalMode("");
                item.setTrainerName("");
                item.setTrainDate(fmtDate(pt.getSignTime() != null ? pt.getSignTime() : pt.getCreatorTime()));
            }
            if (pt.getExamScore() != null) {
                item.setTrainResult(pt.getExamScore().stripTrailingZeros());
            } else {
                item.setTrainResult("");
            }
            item.setPassFlag(pt.getPassFlag() == null ? "" : pt.getPassFlag());
            list.add(item);
        }
        return list;
    }

    private TmsTrainRecordCatalogItemVO fromPersonTrain(TmsPersonTrainEntity row) {
        TmsTrainRecordCatalogItemVO item = new TmsTrainRecordCatalogItemVO();
        item.setId(row.getId());
        item.setRecordNo(row.getRecordNo());
        item.setTrainType(labelCategory(row.getCategory()));
        item.setTrainContent(row.getSubject());
        item.setTrainMode(labelTrainMode(row.getTrainMode()));
        item.setEvalMode(labelEvalMode(row.getEvalMode()));
        item.setTrainerName(row.getTeacherId());
        item.setTrainResult("");
        item.setPassFlag(row.getPassFlag() == null ? "" : row.getPassFlag());
        item.setTrainDate(fmtDate(row.getStartTime()));
        return item;
    }

    private TmsTrainRecordListVO toListVo(TmsPersonFileEntity row,
                                          Map<String, String> deptNames,
                                          Map<String, String> postNames) {
        TmsTrainRecordListVO vo = new TmsTrainRecordListVO();
        vo.setId(row.getId());
        vo.setArchiveNo(row.getArchiveNo());
        Date post = row.getHireDate() != null ? row.getHireDate() : row.getArchiveDate();
        vo.setPostDate(fmtDate(post));
        vo.setUserName(row.getUserName());
        vo.setDeptName(deptNames.getOrDefault(row.getDeptId(), ""));
        vo.setPostName(postNames.getOrDefault(row.getMainPostId(), ""));
        vo.setPartPostName(postNames.getOrDefault(row.getPartPostId(), ""));
        vo.setMajor("");
        vo.setEducation("");
        vo.setTechTitle("");
        vo.setHireDate(fmtDate(row.getHireDate()));
        vo.setLeaveDate(fmtDate(row.getLeaveDate()));
        return vo;
    }

    private Map<String, String> loadDeptNames(Set<String> deptIds) {
        Map<String, String> map = new HashMap<>();
        if (deptIds == null || deptIds.isEmpty()) {
            return map;
        }
        for (String id : deptIds) {
            try {
                OrganizeEntity org = organizeApi.getInfoById(id);
                if (org != null && StringUtil.isNotEmpty(org.getFullName())) {
                    map.put(id, org.getFullName());
                }
            } catch (Exception e) {
                log.debug("resolve dept failed: {}", e.getMessage());
            }
        }
        return map;
    }

    private Map<String, String> loadPostNames(List<TmsPersonFileEntity> rows) {
        Set<String> ids = new HashSet<>();
        for (TmsPersonFileEntity row : rows) {
            if (StringUtil.isNotEmpty(row.getMainPostId())) {
                ids.add(row.getMainPostId());
            }
            if (StringUtil.isNotEmpty(row.getPartPostId())) {
                ids.add(row.getPartPostId());
            }
        }
        Map<String, String> map = new HashMap<>();
        if (ids.isEmpty()) {
            return map;
        }
        try {
            List<PositionEntity> list = positionApi.getListByIds(new ArrayList<>(ids));
            if (list != null) {
                for (PositionEntity p : list) {
                    if (p != null && StringUtil.isNotEmpty(p.getId())) {
                        map.put(p.getId(), p.getFullName());
                    }
                }
            }
        } catch (Exception e) {
            log.debug("resolve posts failed: {}", e.getMessage());
            for (String id : ids) {
                try {
                    PositionEntity p = positionApi.queryInfoById(id);
                    if (p != null) {
                        map.put(id, p.getFullName());
                    }
                } catch (Exception ignored) {
                    // ignore
                }
            }
        }
        return map;
    }

    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);
    }

    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;
    }

    private boolean inDateRange(String trainDate, String startDate, String endDate) {
        if (StringUtil.isEmpty(trainDate)) {
            return StringUtil.isEmpty(startDate) && StringUtil.isEmpty(endDate);
        }
        if (StringUtil.isNotEmpty(startDate) && trainDate.compareTo(startDate) < 0) {
            return false;
        }
        if (StringUtil.isNotEmpty(endDate) && trainDate.compareTo(endDate) > 0) {
            return false;
        }
        return true;
    }

    private String fmtDate(Date date) {
        return date == null ? null : DateUtil.dateToString(date, DATE_FMT);
    }

    private String firstNonEmpty(String a, String b) {
        if (StringUtil.isNotEmpty(a)) {
            return a;
        }
        return b == null ? "" : b;
    }

    private String labelCategory(String code) {
        if (StringUtil.isEmpty(code)) {
            return "";
        }
        switch (code) {
            case "annual_plan":
            case "annual":
                return "年度培训";
            case "temp":
            case "temporary":
                return "临时培训";
            case "post":
                return "岗位培训";
            default:
                return code;
        }
    }

    private String labelTrainMode(String code) {
        if (StringUtil.isEmpty(code)) {
            return "";
        }
        switch (code.toLowerCase()) {
            case "online":
                return "在线学习";
            case "onsite":
                return "集中授课";
            case "practice":
                return "实操培训";
            default:
                return code;
        }
    }

    private String labelEvalMode(String code) {
        if (StringUtil.isEmpty(code)) {
            return "";
        }
        switch (code.toLowerCase()) {
            case "exam":
                return "在线考试";
            case "none":
                return "无需考核";
            case "quiz":
                return "随堂测验";
            case "practice":
                return "实操考核";
            default:
                return code;
        }
    }
}