package com.rongyichuang.player.service;

import com.rongyichuang.activity.entity.Activity;
import com.rongyichuang.activity.entity.ActivityPlayerRating;
import com.rongyichuang.activity.repository.ActivityRepository;
import com.rongyichuang.activity.repository.ActivityPlayerRatingRepository;
import com.rongyichuang.common.entity.Media;
import com.rongyichuang.common.repository.MediaRepository;
import com.rongyichuang.message.service.MessageService;
import com.rongyichuang.player.dto.*;
import com.rongyichuang.player.entity.ActivityPlayer;
import com.rongyichuang.player.repository.ActivityPlayerRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 比赛晋级服务类
 */
@Service
public class PromotionService {
    
    @Autowired
    private ActivityRepository activityRepository;
    
    @Autowired
    private ActivityPlayerRepository activityPlayerRepository;
    
    @Autowired
    private ActivityPlayerRatingRepository activityPlayerRatingRepository;
    
    @Autowired
    private MediaRepository mediaRepository;
    
    @Autowired
    private MessageService messageService;
    
    /**
     * 获取比赛晋级列表
     */
    public List<PromotionCompetitionResponse> getPromotionCompetitions(String name, Integer page, Integer size) {
        List<PromotionCompetitionResponse> result = new ArrayList<>();
        
        // 查询所有有效的主比赛（pid = 0）
        List<Activity> competitions = activityRepository.findByPidAndStateOrderByCreateTimeAsc(0L, 1);
        
        // 如果有名称过滤条件，进行过滤
        if (name != null && !name.trim().isEmpty()) {
            competitions = competitions.stream()
                .filter(comp -> comp.getName().contains(name.trim()))
                .collect(Collectors.toList());
        }
        
        // 为每个比赛查询其阶段
        for (Activity competition : competitions) {
            List<Activity> stages = activityRepository.findByPidAndStateOrderByCreateTimeAsc(competition.getId(), 1);
            
            for (Activity stage : stages) {
                // 统计当前阶段的参赛人数
                Long playerCountLong = activityPlayerRepository.countByStageIdAndState(stage.getId(), 1);
                Integer currentCount = playerCountLong != null ? playerCountLong.intValue() : 0;
                
                PromotionCompetitionResponse response = new PromotionCompetitionResponse(competition, stage, currentCount);
                result.add(response);
            }
        }
        
        // 简单分页处理（实际项目中建议使用数据库分页）
        if (page != null && size != null && page > 0 && size > 0) {
            int start = (page - 1) * size;
            int end = Math.min(start + size, result.size());
            if (start < result.size()) {
                result = result.subList(start, end);
            } else {
                result = new ArrayList<>();
            }
        }
        
        return result;
    }
    
    /**
     * 获取比赛参赛人员
     */
    public List<CompetitionParticipantResponse> getCompetitionParticipants(Long competitionId, Integer page, Integer size) {
        // 查询指定阶段的所有参赛者（已审核通过的）
        List<ActivityPlayer> participants = activityPlayerRepository.findByStageIdAndStateWithPlayerOrderByCreateTimeDesc(competitionId, 1);
        
        // 转换为响应对象
        List<CompetitionParticipantResponse> result = participants.stream()
            .map(participant -> {
                // 这里可以添加评分次数的统计逻辑
                Integer ratingCount = 0; // TODO: 从评分表中统计
                return new CompetitionParticipantResponse(participant, ratingCount);
            })
            .collect(Collectors.toList());
        
        // 简单分页处理
        if (page != null && size != null && page > 0 && size > 0) {
            int start = (page - 1) * size;
            int end = Math.min(start + size, result.size());
            if (start < result.size()) {
                result = result.subList(start, end);
            } else {
                result = new ArrayList<>();
            }
        }
        
        return result;
    }
    
    /**
     * 获取可晋级的参赛者列表
     */
    public PromotableParticipantsResponse getPromotableParticipants(Long currentStageId) {
        try {
            // 查询当前阶段信息
            Activity currentStage = activityRepository.findById(currentStageId).orElse(null);
            if (currentStage == null) {
                return new PromotableParticipantsResponse(new ArrayList<>(), 0, 0, "", "");
            }
            
            // 查找上一个阶段
            Activity previousStage = findPreviousStage(currentStage);
            if (previousStage == null) {
                return new PromotableParticipantsResponse(new ArrayList<>(), 0, 0, "", currentStage.getName());
            }
            
            // 查询上一阶段的所有有效参赛者
            List<ActivityPlayer> previousParticipants = activityPlayerRepository
                .findByStageIdAndStateWithPlayerOrderByCreateTimeDesc(previousStage.getId(), 1);
            
            // 查询当前阶段已有的参赛者ID列表
            List<ActivityPlayer> currentParticipants = activityPlayerRepository
                .findByStageIdAndStateWithPlayerOrderByCreateTimeDesc(currentStageId, 1);
            List<Long> currentPlayerIds = currentParticipants.stream()
                .map(ActivityPlayer::getPlayerId)
                .collect(Collectors.toList());
            
            // 过滤掉已经在当前阶段的参赛者，并计算平均分
            List<PromotableParticipantResponse> promotableList = new ArrayList<>();
            
            for (ActivityPlayer participant : previousParticipants) {
                // 排除已经在当前阶段的参赛者
                if (!currentPlayerIds.contains(participant.getPlayerId())) {
                    // 计算平均分
                    BigDecimal averageScore = calculateAverageScore(participant.getId());
                    
                    // 只包含有评分的参赛者
                    if (averageScore != null && averageScore.compareTo(BigDecimal.ZERO) > 0) {
                        // 统计评分次数
                        long ratingCount = activityPlayerRatingRepository
                            .countCompletedRatingsByActivityPlayerId(participant.getId());
                        
                        PromotableParticipantResponse response = new PromotableParticipantResponse(
                            participant, averageScore, (int) ratingCount);
                        promotableList.add(response);
                    }
                }
            }
            
            // 按平均分降序排序
            promotableList.sort((a, b) -> {
                if (a.getAverageScore() == null && b.getAverageScore() == null) return 0;
                if (a.getAverageScore() == null) return 1;
                if (b.getAverageScore() == null) return -1;
                return b.getAverageScore().compareTo(a.getAverageScore());
            });
            
            // 计算可选择人数（当前阶段最大人数 - 当前阶段已有人数）
            Integer maxParticipants = currentStage.getPlayerMax() != null ? currentStage.getPlayerMax() : 0;
            Integer selectableCount = Math.max(0, maxParticipants - currentParticipants.size());
            
            return new PromotableParticipantsResponse(
                promotableList, 
                selectableCount, 
                promotableList.size(),
                previousStage.getName(),
                currentStage.getName()
            );
            
        } catch (Exception e) {
            return new PromotableParticipantsResponse(new ArrayList<>(), 0, 0, "", "");
        }
    }
    
    /**
     * 计算参赛者的平均分
     */
    private BigDecimal calculateAverageScore(Long activityPlayerId) {
        List<ActivityPlayerRating> ratings = activityPlayerRatingRepository
            .findCompletedRatingsByActivityPlayerId(activityPlayerId);
        
        if (ratings.isEmpty()) {
            return null;
        }
        
        BigDecimal totalScore = BigDecimal.ZERO;
        int count = 0;
        
        for (ActivityPlayerRating rating : ratings) {
            if (rating.getTotalScore() != null) {
                totalScore = totalScore.add(rating.getTotalScore());
                count++;
            }
        }
        
        if (count == 0) {
            return null;
        }
        
        return totalScore.divide(BigDecimal.valueOf(count), 2, RoundingMode.HALF_UP);
    }
    
    /**
     * 查找上一个阶段
     */
    private Activity findPreviousStage(Activity currentStage) {
        // 查询同一比赛下的所有阶段，按排序顺序
        List<Activity> stages = activityRepository.findByPidAndStateOrderBySortOrderAsc(currentStage.getPid(), 1);
        
        // 找到当前阶段的位置，返回上一个阶段
        for (int i = 0; i < stages.size(); i++) {
            if (stages.get(i).getId().equals(currentStage.getId()) && i > 0) {
                return stages.get(i - 1);
            }
        }
        
        return null; // 没有上一个阶段
    }
    
    /**
     * 执行晋级操作
     */
    @Transactional
    public PromotionResult promoteParticipants(PromotionInput input) {
        try {
            if (input.getParticipantIds() == null || input.getParticipantIds().isEmpty()) {
                return PromotionResult.failure("请选择要晋级的参赛者");
            }
            
            // 查询目标晋级阶段信息（用户点击的阶段就是要晋级到的阶段）
            Activity targetStage = activityRepository.findById(input.getCompetitionId()).orElse(null);
            if (targetStage == null) {
                return PromotionResult.failure("目标晋级阶段不存在");
            }
            
            // 查询要晋级的参赛者
            List<ActivityPlayer> participants = activityPlayerRepository.findAllById(input.getParticipantIds());
            if (participants.isEmpty()) {
                return PromotionResult.failure("没有找到要晋级的参赛者");
            }
            
            int promotedCount = 0;
            
            // 为每个参赛者创建目标阶段的报名记录
            for (ActivityPlayer participant : participants) {
                // 检查是否已经在目标阶段报名
                boolean alreadyPromoted = activityPlayerRepository.existsByStageIdAndPlayerId(targetStage.getId(), participant.getPlayerId());
                if (!alreadyPromoted) {
                    // 创建新的报名记录
                    ActivityPlayer newParticipant = new ActivityPlayer();
                    newParticipant.setActivityId(targetStage.getPid()); // 主比赛ID
                    newParticipant.setStageId(targetStage.getId()); // 目标阶段ID
                    newParticipant.setPlayerId(participant.getPlayerId());
                    newParticipant.setRegionId(participant.getRegionId());
                    newParticipant.setProjectName(participant.getProjectName());
                    newParticipant.setDescription(participant.getDescription());
                    newParticipant.setState(1); // 直接设为审核通过
                    
                    ActivityPlayer savedParticipant = activityPlayerRepository.save(newParticipant);
                    
                    // 复制媒体文件
                    copyMediaFiles(participant.getId(), savedParticipant.getId());
                    
                    // 创建晋级消息
                    messageService.createPromotionMessage(
                        savedParticipant.getId(), 
                        savedParticipant.getPlayerId(), 
                        savedParticipant.getProjectName()
                    );
                    
                    promotedCount++;
                }
            }
            
            return PromotionResult.success(
                String.format("成功晋级 %d 名参赛者到 %s", promotedCount, targetStage.getName()),
                promotedCount
            );
            
        } catch (Exception e) {
            return PromotionResult.failure("晋级操作失败：" + e.getMessage());
        }
    }
    
    /**
     * 复制媒体文件
     */
    private void copyMediaFiles(Long sourceActivityPlayerId, Long targetActivityPlayerId) {
        try {
            // 获取源参赛者的所有媒体文件 (targetType=5 表示 ACTIVITY_PLAYER)
            List<Media> sourceMediaFiles = mediaRepository.findByTargetTypeAndTargetIdAndState(5, sourceActivityPlayerId, 1);
            
            for (Media sourceMedia : sourceMediaFiles) {
                // 创建新的媒体记录
                Media newMedia = new Media();
                newMedia.setName(sourceMedia.getName());
                newMedia.setPath(sourceMedia.getPath());
                newMedia.setFileSize(sourceMedia.getFileSize());
                newMedia.setFileExt(sourceMedia.getFileExt());
                newMedia.setMediaType(sourceMedia.getMediaType());
                newMedia.setTargetType(5); // ACTIVITY_PLAYER
                newMedia.setTargetId(targetActivityPlayerId);
                newMedia.setThumbPath(sourceMedia.getThumbPath());
                newMedia.setDuration(sourceMedia.getDuration());
                newMedia.setDescription(sourceMedia.getDescription());
                
                // 保存新的媒体记录
                mediaRepository.save(newMedia);
            }
        } catch (Exception e) {
            // 记录错误但不中断晋级流程
            System.err.println("复制媒体文件失败: " + e.getMessage());
        }
    }

    /**
     * 查找下一个阶段
     */

}