package com.rongyichuang.judge.service;

import com.rongyichuang.judge.dto.request.JudgeInput;
import com.rongyichuang.judge.dto.response.JudgeResponse;
import com.rongyichuang.judge.entity.Judge;
import com.rongyichuang.judge.entity.Tag;
import com.rongyichuang.judge.repository.JudgeRepository;
import com.rongyichuang.common.entity.Media;
import com.rongyichuang.common.repository.MediaRepository;
import com.rongyichuang.common.dto.request.MediaInput;
import com.rongyichuang.common.dto.response.MediaResponse;
import com.rongyichuang.common.service.MediaService;
import com.rongyichuang.judge.repository.TagRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class JudgeService {

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

    private final JudgeRepository judgeRepository;
    private final TagRepository tagRepository;
    private final MediaRepository mediaRepository;
    private final MediaService mediaService;

    public JudgeService(JudgeRepository judgeRepository, TagRepository tagRepository, 
                       MediaRepository mediaRepository, MediaService mediaService) {
        this.judgeRepository = judgeRepository;
        this.tagRepository = tagRepository;
        this.mediaRepository = mediaRepository;
        this.mediaService = mediaService;
    }

    public List<JudgeResponse> findAll() {
        return judgeRepository.findAll(Sort.by(Sort.Direction.DESC, "updateTime")).stream()
                .map(this::convertToResponse)
                .collect(Collectors.toList());
    }

    public List<JudgeResponse> findByName(String name) {
        return judgeRepository.findByNameContaining(name).stream()
                .map(this::convertToResponse)
                .collect(Collectors.toList());
    }

    public JudgeResponse findById(Long id) {
        return judgeRepository.findById(id)
                .map(this::convertToResponse)
                .orElse(null);
    }

    @Transactional
    public JudgeResponse save(JudgeInput input) {
        Judge judge;
        if (input.getId() != null) {
            judge = judgeRepository.findById(input.getId())
                    .orElseThrow(() -> new RuntimeException("评委不存在"));
        } else {
            judge = new Judge();
            // 新增评委时检查手机号是否已存在
            if (judgeRepository.existsByPhone(input.getPhone())) {
                throw new RuntimeException("手机号码已存在，请使用其他手机号码");
            }
        }

        judge.setName(input.getName());
        judge.setPhone(input.getPhone());
        judge.setGender(input.getGender());
        judge.setDescription(input.getDescription());

        // 头像处理已移除，因为数据库表结构中没有avatar_media_id字段
        // 头像信息通过t_media表的target_type和target_id关联

        // 设置专业标签
        if (input.getMajorIds() != null && !input.getMajorIds().isEmpty()) {
            List<Tag> specialties = tagRepository.findAllById(input.getMajorIds());
            judge.setSpecialties(specialties);
        } else {
            judge.setSpecialties(Collections.emptyList());
        }

        Judge savedJudge = judgeRepository.save(judge);
        return convertToResponse(savedJudge);
    }

    @Transactional
    public void delete(Long id) {
        Judge judge = judgeRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("评委不存在"));
        judgeRepository.delete(judge);
    }

    private JudgeResponse convertToResponse(Judge judge) {
        log.info("=== convertToResponse called for judge: {} (ID: {})", judge.getName(), judge.getId());
        
        JudgeResponse response = new JudgeResponse();
        response.setId(judge.getId());
        response.setName(judge.getName());
        response.setPhone(judge.getPhone());
        response.setGender(judge.getGender());
        response.setDescription(judge.getDescription());
        
        // 查询头像信息：target_type=1表示评委，target_id为评委ID
        log.info("=== Querying media for judge ID: {}", judge.getId());
        List<Media> avatarMedias = mediaRepository.findByTargetTypeAndTargetIdAndState(1, judge.getId(), 1);
        log.info("=== Found {} media records", avatarMedias.size());
        
        if (!avatarMedias.isEmpty()) {
            // 取第一个媒体作为头像
            Media avatarMedia = avatarMedias.get(0);
            String avatarUrl = avatarMedia.getPath();
            log.info("=== Setting avatarUrl: {}", avatarUrl);
            response.setAvatarUrl(avatarUrl);
        } else {
            log.info("=== No media found, avatarUrl will be null");
        }

        if (judge.getSpecialties() != null) {
            response.setSpecialties(judge.getSpecialties().stream()
                    .map(tag -> {
                        JudgeResponse.TagResponse tagResponse = new JudgeResponse.TagResponse();
                        tagResponse.setId(tag.getId());
                        tagResponse.setName(tag.getName());
                        tagResponse.setCode(tag.getCode());
                        return tagResponse;
                    })
                    .collect(Collectors.toList()));
        }

        return response;
    }

    /**
     * 保存媒体信息
     */
    public MediaResponse saveMediaInfo(MediaInput input) {
        Media media = mediaService.saveMedia(
            input.getName(),
            input.getPath(),
            input.getFileSize(),
            input.getFileExt(),
            input.getMediaType(),
            input.getTargetType(),
            input.getTargetId()
        );
        
        MediaResponse response = new MediaResponse();
        response.setId(media.getId());
        response.setName(media.getName());
        response.setPath(media.getPath());
        response.setFileSize(media.getFileSize());
        response.setFileExt(media.getFileExt());
        response.setMediaType(media.getMediaType());
        response.setTargetType(media.getTargetType());
        response.setTargetId(media.getTargetId());
        
        return response;
    }
}