package com.rongyichuang.rating.service;

import com.rongyichuang.common.dto.PageRequest;
import com.rongyichuang.common.dto.PageResponse;
import com.rongyichuang.common.exception.BusinessException;
import com.rongyichuang.rating.dto.request.RatingItemInput;
import com.rongyichuang.rating.dto.request.RatingSchemeInput;
import com.rongyichuang.rating.dto.response.RatingSchemeResponse;
import com.rongyichuang.rating.entity.RatingItem;
import com.rongyichuang.rating.entity.RatingScheme;
import com.rongyichuang.rating.repository.RatingItemRepository;
import com.rongyichuang.rating.repository.RatingSchemeRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * 评分模板服务层
 */
@Service
public class RatingSchemeService {

    @Autowired
    private RatingSchemeRepository ratingSchemeRepository;

    @Autowired
    private RatingItemRepository ratingItemRepository;

    /**
     * 分页查询评分模板列表
     */
    public PageResponse<RatingSchemeResponse> getSchemeList(PageRequest pageRequest, String name) {
        Pageable pageable = pageRequest.toPageable();
        Page<RatingScheme> page;
        
        if (StringUtils.hasText(name)) {
            page = ratingSchemeRepository.findByNameContaining(name, pageable);
        } else {
            page = ratingSchemeRepository.findAll(pageable);
        }
        
        List<RatingSchemeResponse> content = page.getContent().stream()
                .map(RatingSchemeResponse::new)
                .collect(Collectors.toList());
        
        return new PageResponse<>(content, page.getTotalElements(), page.getNumber(), page.getSize());
    }

    /**
     * 根据ID获取评分模板详情
     */
    public RatingSchemeResponse getSchemeById(Long id) {
        Optional<RatingScheme> optional = ratingSchemeRepository.findById(id);
        if (optional.isEmpty()) {
            throw new BusinessException("评分模板不存在");
        }
        return new RatingSchemeResponse(optional.get());
    }

    /**
     * 保存评分模板（新增或修改）
     */
    @Transactional
    public RatingSchemeResponse saveScheme(RatingSchemeInput input) {
        RatingScheme scheme;
        
        if (input.getId() == null) {
            // 新增
            scheme = new RatingScheme();
        } else {
            // 修改
            Optional<RatingScheme> optional = ratingSchemeRepository.findById(input.getId());
            if (optional.isEmpty()) {
                throw new BusinessException("评分模板不存在");
            }
            scheme = optional.get();
        }
        
        // 设置基本信息
        scheme.setName(input.getName());
        scheme.setDescription(input.getDescription());
        
        // 保存模板
        scheme = ratingSchemeRepository.save(scheme);
        
        // 处理评分条目
        if (input.getItems() != null) {
            saveRatingItems(scheme, input.getItems());
        }
        
        return new RatingSchemeResponse(scheme);
    }

    /**
     * 删除评分模板
     */
    @Transactional
    public boolean deleteScheme(Long id) {
        Optional<RatingScheme> optional = ratingSchemeRepository.findById(id);
        if (optional.isEmpty()) {
            throw new BusinessException("评分模板不存在");
        }
        
        // 检查是否被比赛使用
        if (ratingSchemeRepository.isUsedByActivity(id)) {
            throw new BusinessException("该评分模板已被比赛使用，无法删除");
        }
        
        RatingScheme scheme = optional.get();
        scheme.setState(0); // 逻辑删除
        ratingSchemeRepository.save(scheme);
        
        return true;
    }

    /**
     * 保存评分条目
     */
    private void saveRatingItems(RatingScheme scheme, List<RatingItemInput> itemInputs) {
        // 获取现有条目
        List<RatingItem> existingItems = ratingItemRepository.findBySchemeIdOrderByOrderNo(scheme.getId());
        
        // 处理新的条目列表
        List<RatingItem> newItems = new ArrayList<>();
        
        for (int i = 0; i < itemInputs.size(); i++) {
            RatingItemInput itemInput = itemInputs.get(i);
            RatingItem item;
            
            if (itemInput.getId() == null) {
                // 新增条目
                item = new RatingItem();
                item.setScheme(scheme);
            } else {
                // 修改条目
                item = existingItems.stream()
                        .filter(existing -> existing.getId().equals(itemInput.getId()))
                        .findFirst()
                        .orElse(new RatingItem());
                if (item.getScheme() == null) {
                    item.setScheme(scheme);
                }
            }
            
            item.setName(itemInput.getName());
            item.setMaxScore(itemInput.getMaxScore());
            item.setOrderNo(itemInput.getOrderNo() != null ? itemInput.getOrderNo() : i + 1);
            
            newItems.add(item);
        }
        
        // 删除不在新列表中的条目
        List<Long> newItemIds = newItems.stream()
                .map(RatingItem::getId)
                .filter(id -> id != null)
                .collect(Collectors.toList());
        
        for (RatingItem existingItem : existingItems) {
            if (!newItemIds.contains(existingItem.getId())) {
                existingItem.setState(0); // 逻辑删除
                ratingItemRepository.save(existingItem);
            }
        }
        
        // 保存新的条目列表
        ratingItemRepository.saveAll(newItems);
    }

    /**
     * 获取所有评分模板（用于下拉选择）
     */
    public List<RatingSchemeResponse> getAllSchemes() {
        List<RatingScheme> schemes = ratingSchemeRepository.findAll();
        return schemes.stream()
                .map(RatingSchemeResponse::new)
                .collect(Collectors.toList());
    }
}