package jnpf.tmsService.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import jnpf.exception.DataException;
import jnpf.permission.UserApi;
import jnpf.permission.entity.UserEntity;
import jnpf.tmsEntity.TmsMaterialEntity;
import jnpf.tmsEntity.TmsPersonTaskEntity;
import jnpf.tmsEntity.TmsRecordEntity;
import jnpf.tmsEntity.TmsTaskEntity;
import jnpf.tmsEntity.TmsTaskFileEntity;
import jnpf.tmsEntity.record.TmsRecordAttachmentForm;
import jnpf.tmsEntity.record.TmsRecordForm;
import jnpf.tmsEntity.record.TmsRecordParticipantForm;
import jnpf.tmsEntity.record.TmsRecordQuery;
import jnpf.tmsEntity.record.TmsRecordSignForm;
import jnpf.tmsMapper.TmsMaterialMapper;
import jnpf.tmsMapper.TmsPersonTaskMapper;
import jnpf.tmsMapper.TmsRecordMapper;
import jnpf.tmsMapper.TmsTaskFileMapper;
import jnpf.tmsMapper.TmsTaskMapper;
import jnpf.tmsService.TmsRecordService;
import jnpf.util.DateUtil;
import jnpf.util.StringUtil;
import jnpf.util.UserProvider;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class TmsRecordServiceImpl implements TmsRecordService {

    private static final String FMT = "yyyy-MM-dd HH:mm:ss";
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    private final TmsRecordMapper recordMapper;
    private final TmsTaskMapper taskMapper;
    private final TmsTaskFileMapper taskFileMapper;
    private final TmsMaterialMapper materialMapper;
    private final TmsPersonTaskMapper personTaskMapper;
    private final UserApi userApi;

    @Override
    public List<TmsRecordForm> getList(TmsRecordQuery query) {
        LambdaQueryWrapper<TmsRecordEntity> qw = new LambdaQueryWrapper<>();
        applyListMode(qw, query);

        if (StringUtil.isNotEmpty(query.getRecordNo())) {
            qw.like(TmsRecordEntity::getRecordNo, query.getRecordNo().trim());
        }
        if (StringUtil.isNotEmpty(query.getCategory())) {
            qw.like(TmsRecordEntity::getCategory, query.getCategory().trim());
        }
        if (StringUtil.isNotEmpty(query.getKeyword()) && !"null".equalsIgnoreCase(query.getKeyword())) {
            String kw = query.getKeyword().trim();
            qw.and(w -> w.like(TmsRecordEntity::getRecordNo, kw)
                    .or().like(TmsRecordEntity::getSubject, kw));
        }
        qw.orderByDesc(TmsRecordEntity::getStartTime).orderByDesc(TmsRecordEntity::getCreatorTime);

        long current = query.getCurrentPage() > 0 ? query.getCurrentPage() : 1;
        long size = query.getPageSize() > 0 ? query.getPageSize() : 20;
        Page<TmsRecordEntity> page = recordMapper.selectPage(new Page<>(current, size), qw);

        List<TmsRecordEntity> rows = page.getRecords();
        Map<String, String> names = loadUserNames(rows.stream()
                .map(TmsRecordEntity::getTeacherId)
                .filter(StringUtil::isNotEmpty)
                .distinct()
                .collect(Collectors.toList()));

        List<TmsRecordForm> list = new ArrayList<>(rows.size());
        String trainerFilter = StringUtil.isNotEmpty(query.getTrainerName()) ? query.getTrainerName().trim() : null;
        for (TmsRecordEntity row : rows) {
            TmsRecordForm form = toListForm(row, names);
            if (trainerFilter != null) {
                String name = form.getTrainerName() == null ? "" : form.getTrainerName();
                if (!name.contains(trainerFilter)) {
                    continue;
                }
            }
            list.add(form);
        }
        query.setData(list, page.getTotal());
        return list;
    }

    @Override
    public TmsRecordForm getInfo(String id) {
        TmsRecordEntity entity = requireOne(id);
        Map<String, String> teacherNames = loadUserNames(
                StringUtil.isEmpty(entity.getTeacherId())
                        ? Collections.emptyList()
                        : Collections.singletonList(entity.getTeacherId()));
        TmsRecordForm form = toListForm(entity, teacherNames);

        TmsTaskEntity task = StringUtil.isEmpty(entity.getTaskId()) ? null : taskMapper.selectById(entity.getTaskId());
        if (task != null) {
            form.setKeyPoints(task.getKeyPoints());
            form.setPlaceName(task.getPlaceName());
            if (StringUtil.isEmpty(form.getTrainType()) && StringUtil.isNotEmpty(task.getTrainType())) {
                form.setTrainType(task.getTrainType());
            }
            if (StringUtil.isEmpty(form.getTrainMode()) && StringUtil.isNotEmpty(task.getTrainMode())) {
                form.setTrainMode(task.getTrainMode());
            }
        }

        List<TmsPersonTaskEntity> persons = StringUtil.isEmpty(entity.getTaskId())
                ? Collections.emptyList()
                : personTaskMapper.selectList(new LambdaQueryWrapper<TmsPersonTaskEntity>()
                .eq(TmsPersonTaskEntity::getTaskId, entity.getTaskId())
                .orderByAsc(TmsPersonTaskEntity::getCreatorTime));

        Map<String, String> userNames = loadUserNames(persons.stream()
                .map(TmsPersonTaskEntity::getUserId)
                .filter(StringUtil::isNotEmpty)
                .distinct()
                .collect(Collectors.toList()));

        List<TmsRecordParticipantForm> participants = new ArrayList<>(persons.size());
        List<TmsRecordSignForm> signs = new ArrayList<>();
        List<String> traineeNames = new ArrayList<>();
        for (TmsPersonTaskEntity p : persons) {
            String userName = userNames.getOrDefault(p.getUserId(), p.getUserId());
            traineeNames.add(userName);

            TmsRecordParticipantForm pf = new TmsRecordParticipantForm();
            pf.setId(p.getId());
            pf.setUserId(p.getUserId());
            pf.setUserName(userName);
            pf.setSignDate(formatDate(p.getSignTime()));
            pf.setExamScore(p.getExamScore());
            pf.setPassFlag(p.getPassFlag());
            participants.add(pf);

            if (p.getSignTime() != null) {
                TmsRecordSignForm sf = new TmsRecordSignForm();
                sf.setId(p.getId());
                sf.setUserName(userName);
                sf.setSignTime(formatDate(p.getSignTime()));
                sf.setSignMode(p.getSignMode());
                sf.setGuestFlag(p.getGuestFlag());
                signs.add(sf);
            }
        }
        form.setParticipants(participants);
        form.setSignList(signs);
        form.setTrainees(String.join(",", traineeNames));
        form.setAttachments(loadAttachments(entity.getTaskId()));
        form.setRemark(entity.getRemark());
        return form;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void update(String id, TmsRecordForm form) {
        TmsRecordEntity entity = requireOne(id);
        if (form == null) {
            throw new DataException("表单不能为空");
        }
        if (StringUtil.isNotEmpty(form.getSubject())) {
            entity.setSubject(form.getSubject().trim());
        }
        if (form.getCategory() != null) {
            entity.setCategory(form.getCategory());
        }
        if (form.getTrainType() != null) {
            entity.setTrainType(form.getTrainType());
        }
        if (form.getTrainMode() != null) {
            entity.setTrainMode(form.getTrainMode());
        }
        if (form.getEvalMode() != null) {
            entity.setEvalMode(form.getEvalMode());
        }
        entity.setRemark(form.getRemark());
        entity.setLastModifyUserId(UserProvider.getLoginUserId());
        entity.setLastModifyTime(new Date());
        recordMapper.updateById(entity);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int archive(List<String> ids) {
        if (ids == null || ids.isEmpty()) {
            throw new DataException("请选择要归档的记录");
        }
        int count = 0;
        Date now = new Date();
        String userId = UserProvider.getLoginUserId();
        for (String id : ids) {
            if (StringUtil.isEmpty(id)) {
                continue;
            }
            TmsRecordEntity entity = recordMapper.selectById(id);
            if (entity == null) {
                continue;
            }
            entity.setArchiveStatus("archived");
            entity.setLastModifyUserId(userId);
            entity.setLastModifyTime(now);
            recordMapper.updateById(entity);
            count++;
        }
        return count;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delete(List<String> ids) {
        if (ids == null || ids.isEmpty()) {
            throw new DataException("请选择要删除的记录");
        }
        for (String id : ids) {
            if (StringUtil.isEmpty(id)) {
                continue;
            }
            recordMapper.deleteById(id);
        }
    }

    private void applyListMode(LambdaQueryWrapper<TmsRecordEntity> qw, TmsRecordQuery query) {
        String archiveStatus = query.getArchiveStatus();
        if (StringUtil.isNotEmpty(archiveStatus)) {
            qw.eq(TmsRecordEntity::getArchiveStatus, archiveStatus);
            return;
        }
        String mode = query.getListMode();
        if ("ready".equals(mode)) {
            qw.eq(TmsRecordEntity::getArchiveStatus, "ready");
        } else if ("archived".equals(mode)) {
            qw.eq(TmsRecordEntity::getArchiveStatus, "archived");
        } else {
            // 主列表：待归档 / 进行中
            qw.and(w -> w.eq(TmsRecordEntity::getArchiveStatus, "pending")
                    .or().isNull(TmsRecordEntity::getArchiveStatus));
        }
    }

    private TmsRecordForm toListForm(TmsRecordEntity entity, Map<String, String> names) {
        TmsRecordForm form = new TmsRecordForm();
        form.setId(entity.getId());
        form.setRecordNo(entity.getRecordNo());
        form.setTaskId(entity.getTaskId());
        form.setTaskNo(entity.getTaskNo());
        form.setCategory(entity.getCategory());
        form.setSubject(entity.getSubject());
        form.setTeacherId(entity.getTeacherId());
        form.setTrainerName(names.getOrDefault(entity.getTeacherId(),
                StringUtil.isEmpty(entity.getTeacherId()) ? "-" : entity.getTeacherId()));
        form.setTrainType(StringUtil.isNotEmpty(entity.getTrainType())
                ? entity.getTrainType()
                : entity.getTrainMode());
        form.setTrainMode(entity.getTrainMode());
        form.setEvalMode(entity.getEvalMode());
        form.setStartTime(formatDate(entity.getStartTime()));
        form.setEndTime(formatDate(entity.getEndTime()));
        form.setCloseTime(formatDate(entity.getCloseTime()));
        form.setArchiveStatus(entity.getArchiveStatus());
        form.setSignRate(entity.getSignRate());
        form.setPassRate(entity.getPassRate());
        form.setRemark(entity.getRemark());
        return form;
    }

    private List<TmsRecordAttachmentForm> loadAttachments(String taskId) {
        if (StringUtil.isEmpty(taskId)) {
            return Collections.emptyList();
        }
        List<TmsTaskFileEntity> files = taskFileMapper.selectList(
                new LambdaQueryWrapper<TmsTaskFileEntity>()
                        .eq(TmsTaskFileEntity::getForeignId, taskId)
                        .orderByAsc(TmsTaskFileEntity::getCreatorTime));
        if (files.isEmpty()) {
            return Collections.emptyList();
        }

        List<String> materialIds = files.stream()
                .map(TmsTaskFileEntity::getMaterialId)
                .filter(StringUtil::isNotEmpty)
                .distinct()
                .collect(Collectors.toList());
        Map<String, TmsMaterialEntity> materialMap = new HashMap<>();
        if (!materialIds.isEmpty()) {
            for (TmsMaterialEntity material : materialMapper.selectBatchIds(materialIds)) {
                materialMap.put(material.getId(), material);
            }
        }

        List<TmsRecordAttachmentForm> list = new ArrayList<>();
        for (TmsTaskFileEntity file : files) {
            String url = extractUrl(file.getFileJson());
            if (StringUtil.isEmpty(url) && StringUtil.isNotEmpty(file.getMaterialId())) {
                TmsMaterialEntity material = materialMap.get(file.getMaterialId());
                if (material != null) {
                    url = extractUrl(material.getFileJson());
                }
            }
            TmsRecordAttachmentForm item = new TmsRecordAttachmentForm();
            item.setId(file.getId());
            item.setName(file.getFileName());
            item.setUrl(url);
            list.add(item);
        }
        return list;
    }

    private String extractUrl(String fileJson) {
        if (StringUtil.isEmpty(fileJson)) {
            return null;
        }
        try {
            String text = fileJson.trim();
            if (text.startsWith("[")) {
                List<Map<String, Object>> arr = OBJECT_MAPPER.readValue(text,
                        new TypeReference<List<Map<String, Object>>>() {
                        });
                if (arr == null || arr.isEmpty()) {
                    return null;
                }
                Object url = arr.get(0).get("url");
                return url == null ? null : String.valueOf(url);
            }
            Map<String, Object> map = OBJECT_MAPPER.readValue(text, new TypeReference<Map<String, Object>>() {
            });
            Object url = map.get("url");
            return url == null ? null : String.valueOf(url);
        } catch (Exception ex) {
            return null;
        }
    }

    private Map<String, String> loadUserNames(List<String> userIds) {
        if (userIds == null || userIds.isEmpty()) {
            return Collections.emptyMap();
        }
        List<String> ids = userIds.stream().filter(StringUtil::isNotEmpty).distinct().collect(Collectors.toList());
        if (ids.isEmpty()) {
            return Collections.emptyMap();
        }
        try {
            List<UserEntity> users = userApi.getUserName(ids);
            if (users == null || users.isEmpty()) {
                return Collections.emptyMap();
            }
            Map<String, String> map = new LinkedHashMap<>();
            for (UserEntity user : users) {
                if (user == null || StringUtil.isEmpty(user.getId())) {
                    continue;
                }
                String name = StringUtil.isNotEmpty(user.getRealName()) ? user.getRealName() : user.getAccount();
                map.put(user.getId(), name);
            }
            return map;
        } catch (Exception ex) {
            return Collections.emptyMap();
        }
    }

    private TmsRecordEntity requireOne(String id) {
        if (StringUtil.isEmpty(id)) {
            throw new DataException("记录ID不能为空");
        }
        TmsRecordEntity entity = recordMapper.selectById(id);
        if (entity == null) {
            throw new DataException("培训记录不存在");
        }
        return entity;
    }

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