package com.tcm.training.admin.live.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.tcm.training.admin.live.entity.LiveSession;
import com.tcm.training.admin.live.mapper.LiveSessionMapper;
import com.tcm.training.admin.live.vo.LiveSessionStatusVO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

@Service
public class LiveSessionStatusSyncService {

    private static final Logger log = LoggerFactory.getLogger(LiveSessionStatusSyncService.class);

    private final LiveSessionMapper liveSessionMapper;
    private final LiveSessionAppService liveSessionAppService;

    /**
     * 注入直播场次查询能力与状态流转服务。
     */
    public LiveSessionStatusSyncService(LiveSessionMapper liveSessionMapper,
                                        LiveSessionAppService liveSessionAppService) {
        this.liveSessionMapper = liveSessionMapper;
        this.liveSessionAppService = liveSessionAppService;
    }

    /**
     * 扫描已到开播时间的未开始场次，并自动切换为直播中。
     */
    @Scheduled(fixedDelayString = "${app.live.session-status-sync-interval-ms:5000}")
    public void syncDueSessions() {
        LocalDateTime now = LocalDateTime.now();
        List<LiveSession> dueSessions = liveSessionMapper.selectList(new LambdaQueryWrapper<LiveSession>()
                .eq(LiveSession::getDeleted, 0)
                .eq(LiveSession::getLiveStatus, 0)
                .isNotNull(LiveSession::getStartTime)
                .le(LiveSession::getStartTime, now)
                .orderByAsc(LiveSession::getStartTime)
                .orderByAsc(LiveSession::getId));
        int startedCount = 0;
        if (dueSessions != null && !dueSessions.isEmpty()) {
            List<LiveSession> effectiveDueSessions = pickEffectiveDueSessions(dueSessions);
            for (LiveSession dueSession : effectiveDueSessions) {
                // 定时任务与人工开播共用同一套状态迁移逻辑，避免状态口径分叉。
                LiveSessionStatusVO statusVO = liveSessionAppService.autoStart(dueSession.getId(), now);
                if (statusVO == null) {
                    log.warn("live session auto start skipped, sessionId={}, courseId={}",
                            dueSession.getId(), dueSession.getLiveCourseId());
                    continue;
                }
                startedCount++;
            }

            if (startedCount > 0) {
                log.info("live session auto start finished, scanned={}, effective={}, started={}",
                        dueSessions.size(), effectiveDueSessions.size(), startedCount);
            }
        }

        reconcileLivingCourses(now);
    }

    /**
     * 同一课程只挑一条最应被自动开播的场次，避免历史过期开播记录被批量拉起后又互相收敛。
     */
    private List<LiveSession> pickEffectiveDueSessions(List<LiveSession> dueSessions) {
        if (dueSessions == null || dueSessions.isEmpty()) {
            return dueSessions;
        }
        Map<Long, LiveSession> effectiveSessionMap = new LinkedHashMap<Long, LiveSession>();
        for (LiveSession dueSession : dueSessions) {
            if (dueSession == null || dueSession.getLiveCourseId() == null) {
                continue;
            }
            LiveSession current = effectiveSessionMap.get(dueSession.getLiveCourseId());
            if (current == null || compareDueSession(current, dueSession) < 0) {
                effectiveSessionMap.put(dueSession.getLiveCourseId(), dueSession);
            }
        }
        return new java.util.ArrayList<LiveSession>(effectiveSessionMap.values());
    }

    /**
     * 自动开播候选按计划开播时间排序，时间更晚者优先；同时间取 ID 更大的最新记录。
     */
    private int compareDueSession(LiveSession left, LiveSession right) {
        LocalDateTime leftTime = left == null ? null : left.getStartTime();
        LocalDateTime rightTime = right == null ? null : right.getStartTime();
        if (leftTime == null && rightTime == null) {
            return compareSessionId(left, right);
        }
        if (leftTime == null) {
            return -1;
        }
        if (rightTime == null) {
            return 1;
        }
        int timeCompare = leftTime.compareTo(rightTime);
        if (timeCompare != 0) {
            return timeCompare;
        }
        return compareSessionId(left, right);
    }

    private int compareSessionId(LiveSession left, LiveSession right) {
        Long leftId = left == null ? null : left.getId();
        Long rightId = right == null ? null : right.getId();
        if (leftId == null && rightId == null) {
            return 0;
        }
        if (leftId == null) {
            return -1;
        }
        if (rightId == null) {
            return 1;
        }
        return leftId.compareTo(rightId);
    }

    /**
     * 定时收敛历史残留的直播中场次，避免同课程出现多条或过期直播中状态。
     */
    private void reconcileLivingCourses(LocalDateTime now) {
        List<LiveSession> livingSessions = liveSessionMapper.selectList(new LambdaQueryWrapper<LiveSession>()
                .eq(LiveSession::getDeleted, 0)
                .eq(LiveSession::getLiveStatus, 1)
                .orderByAsc(LiveSession::getLiveCourseId)
                .orderByAsc(LiveSession::getId));
        if (livingSessions == null || livingSessions.isEmpty()) {
            return;
        }

        int endedCount = autoEndExpiredLivingSessions(livingSessions, now);
        if (endedCount > 0) {
            livingSessions = liveSessionMapper.selectList(new LambdaQueryWrapper<LiveSession>()
                    .eq(LiveSession::getDeleted, 0)
                    .eq(LiveSession::getLiveStatus, 1)
                    .orderByAsc(LiveSession::getLiveCourseId)
                    .orderByAsc(LiveSession::getId));
            if (livingSessions == null || livingSessions.isEmpty()) {
                return;
            }
        }

        Set<Long> courseIds = new LinkedHashSet<Long>();
        for (LiveSession livingSession : livingSessions) {
            if (livingSession == null || livingSession.getLiveCourseId() == null) {
                continue;
            }
            courseIds.add(livingSession.getLiveCourseId());
        }

        int repairedCount = 0;
        for (Long courseId : courseIds) {
            repairedCount += liveSessionAppService.reconcileCourseLivingSessions(courseId, now);
        }
        if (repairedCount > 0) {
            log.info("live session reconcile finished, livingCourses={}, repaired={}", courseIds.size(), repairedCount);
        }
    }

    /**
     * 自动结束已超过配置时长的直播中场次。
     */
    private int autoEndExpiredLivingSessions(List<LiveSession> livingSessions, LocalDateTime now) {
        if (livingSessions == null || livingSessions.isEmpty()) {
            return 0;
        }
        int endedCount = 0;
        int skippedCount = 0;
        for (LiveSession livingSession : livingSessions) {
            if (!shouldAutoEnd(livingSession, now)) {
                if (livingSession == null
                        || livingSession.getDurationSeconds() == null
                        || livingSession.getDurationSeconds().intValue() <= 0
                        || resolveSessionStartTime(livingSession) == null) {
                    skippedCount++;
                }
                continue;
            }
            LiveSessionStatusVO statusVO = liveSessionAppService.autoEnd(livingSession.getId(), now);
            if (statusVO != null) {
                endedCount++;
            }
        }
        if (endedCount > 0 || skippedCount > 0) {
            log.info("live session auto end finished, scanned={}, ended={}, skipped={}",
                    livingSessions.size(), endedCount, skippedCount);
        }
        return endedCount;
    }

    /**
     * 判断直播中场次是否已到自动结束时间。
     */
    private boolean shouldAutoEnd(LiveSession session, LocalDateTime now) {
        if (session == null) {
            return false;
        }
        Integer durationSeconds = session.getDurationSeconds();
        if (durationSeconds == null || durationSeconds.intValue() <= 0) {
            return false;
        }
        LocalDateTime startTime = resolveSessionStartTime(session);
        if (startTime == null) {
            return false;
        }
        return !startTime.plusSeconds(durationSeconds.longValue()).isAfter(now);
    }

    /**
     * 优先使用实际开播时间，没有时回退到计划开播时间。
     */
    private LocalDateTime resolveSessionStartTime(LiveSession session) {
        if (session == null) {
            return null;
        }
        if (session.getActualStartTime() != null) {
            return session.getActualStartTime();
        }
        return session.getStartTime();
    }
}