package com.example.cattletends.service.impl;

import com.example.cattletends.entity.CattleBreed;
import com.example.cattletends.repository.CattleBreedRepository;
import com.example.cattletends.service.CattleBreedService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Optional;

/**
 * 品种服务实现类
 */
@Service
public class CattleBreedServiceImpl implements CattleBreedService {
    
    @Autowired
    private CattleBreedRepository cattleBreedRepository;
    
    @Override
    @Transactional
    public CattleBreed createOrGetBreed(String breedName) {
        if (breedName == null || breedName.trim().isEmpty()) {
            return null;
        }
        
        String trimmedName = breedName.trim();
        
        // 先查询是否已存在
        Optional<CattleBreed> existing = cattleBreedRepository.findByBreedName(trimmedName);
        if (existing.isPresent()) {
            CattleBreed breed = existing.get();
            // 如果品种被标记为删除，恢复它（设置为未删除）
            if (breed.getIsDelet() != null && breed.getIsDelet() == 1) {
                breed.setIsDelet(0);
                breed = cattleBreedRepository.save(breed);
                System.out.println("恢复已删除的品种: " + trimmedName);
            } else {
                System.out.println("品种已存在: " + trimmedName);
            }
            return breed;
        }
        
        // 不存在则创建
        CattleBreed breed = new CattleBreed();
        breed.setBreedName(trimmedName);
        breed.setIsDelet(0); // 新创建的品种默认为未删除
        CattleBreed saved = cattleBreedRepository.save(breed);
        System.out.println("创建新品种: " + trimmedName + " (ID: " + saved.getId() + ")");
        return saved;
    }
    
    @Override
    @Transactional
    public List<CattleBreed> getAllBreeds() {
        // 只查询未删除的品种（is_delet=0）
        List<CattleBreed> dataList = cattleBreedRepository.findAllNotDeleted();
        
        // 去重处理：如果同一个品种名称有多条记录，保留最新的一条（up_time最大），更新其他记录
        if (dataList != null && !dataList.isEmpty()) {
            System.out.println("========== 开始品种去重处理 ==========");
            System.out.println("去重前记录数: " + dataList.size());
            
            // 按品种名称分组，找出每个品种的最新记录
            java.util.Map<String, CattleBreed> breedMap = new java.util.HashMap<>();
            java.util.List<CattleBreed> duplicatesToUpdate = new java.util.ArrayList<>();
            
            for (CattleBreed item : dataList) {
                String breedName = item.getBreedName();
                if (breedName == null || breedName.trim().isEmpty()) {
                    continue;
                }
                
                String trimmedName = breedName.trim();
                
                if (!breedMap.containsKey(trimmedName)) {
                    // 第一次遇到该品种，直接添加
                    breedMap.put(trimmedName, item);
                } else {
                    // 已存在该品种，比较更新时间，保留最新的
                    CattleBreed existing = breedMap.get(trimmedName);
                    if (item.getUpTime() != null && existing.getUpTime() != null) {
                        if (item.getUpTime().isAfter(existing.getUpTime())) {
                            // 当前记录更新，标记旧记录需要更新
                            duplicatesToUpdate.add(existing);
                            breedMap.put(trimmedName, item);
                        } else {
                            // 现有记录更新，标记当前记录需要更新
                            duplicatesToUpdate.add(item);
                        }
                    } else if (item.getUpTime() != null) {
                        // 当前记录有更新时间，保留它
                        duplicatesToUpdate.add(existing);
                        breedMap.put(trimmedName, item);
                    } else if (existing.getUpTime() != null) {
                        // 现有记录有更新时间，保留现有记录
                        duplicatesToUpdate.add(item);
                    } else {
                        // 都没有更新时间，保留ID较小的（通常是最早创建的）
                        if (item.getId() < existing.getId()) {
                            duplicatesToUpdate.add(existing);
                            breedMap.put(trimmedName, item);
                        } else {
                            duplicatesToUpdate.add(item);
                        }
                    }
                }
            }
            
            // 更新重复记录：将旧记录的数据更新为最新记录的数据（实际上品种只有名称，所以只需要更新 up_time）
            int updatedCount = 0;
            for (CattleBreed duplicate : duplicatesToUpdate) {
                CattleBreed latest = breedMap.get(duplicate.getBreedName().trim());
                if (latest != null && !latest.getId().equals(duplicate.getId())) {
                    // 更新旧记录的 up_time 为最新记录的 up_time
                    duplicate.setUpTime(latest.getUpTime());
                    cattleBreedRepository.save(duplicate);
                    updatedCount++;
                }
            }
            
            // 如果更新了重复记录，重新查询
            if (updatedCount > 0) {
                System.out.println("更新了 " + updatedCount + " 条重复品种记录");
                dataList = cattleBreedRepository.findAll();
            }
            
            // 最终去重：按品种名称去重，每个品种只保留一条（保留最新的）
            java.util.Map<String, CattleBreed> finalMap = new java.util.LinkedHashMap<>();
            for (CattleBreed item : dataList) {
                String breedName = item.getBreedName();
                if (breedName == null || breedName.trim().isEmpty()) {
                    continue;
                }
                
                String trimmedName = breedName.trim();
                
                if (!finalMap.containsKey(trimmedName)) {
                    finalMap.put(trimmedName, item);
                } else {
                    CattleBreed existing = finalMap.get(trimmedName);
                    if (item.getUpTime() != null && existing.getUpTime() != null) {
                        if (item.getUpTime().isAfter(existing.getUpTime())) {
                            finalMap.put(trimmedName, item);
                        }
                    } else if (item.getUpTime() != null) {
                        finalMap.put(trimmedName, item);
                    } else if (existing.getUpTime() != null) {
                        // 保持现有记录
                    } else {
                        // 都没有更新时间，保留ID较小的
                        if (item.getId() < existing.getId()) {
                            finalMap.put(trimmedName, item);
                        }
                    }
                }
            }
            
            dataList = new java.util.ArrayList<>(finalMap.values());
            System.out.println("去重后记录数: " + dataList.size());
            System.out.println("========== 品种去重处理完成 ==========");
        }
        
        return dataList;
    }
    
    @Override
    public CattleBreed getBreedByName(String breedName) {
        if (breedName == null || breedName.trim().isEmpty()) {
            return null;
        }
        return cattleBreedRepository.findByBreedName(breedName.trim())
                .orElse(null);
    }
    
    @Override
    @Transactional
    public void updateBreedDeleteStatus(java.util.Set<String> breedNamesInExcel) {
        System.out.println("========== 开始更新品种逻辑删除状态 ==========");
        
        // 获取所有品种（包括已删除的）
        List<CattleBreed> allBreeds = cattleBreedRepository.findAll();
        System.out.println("数据库中总品种数: " + (allBreeds != null ? allBreeds.size() : 0));
        System.out.println("Excel中的品种: " + (breedNamesInExcel != null ? breedNamesInExcel.size() : 0) + " 个");
        
        if (allBreeds == null || allBreeds.isEmpty()) {
            System.out.println("数据库中没有品种数据，跳过逻辑删除状态更新");
            return;
        }
        
        int restoredCount = 0;  // 恢复的品种数（从已删除改为未删除）
        int deletedCount = 0;   // 标记为删除的品种数
        
        // 遍历所有品种，更新逻辑删除状态
        for (CattleBreed breed : allBreeds) {
            if (breed == null || breed.getBreedName() == null) {
                continue;
            }
            
            String breedName = breed.getBreedName().trim();
            boolean existsInExcel = breedNamesInExcel != null && breedNamesInExcel.contains(breedName);
            
            Integer currentIsDelet = breed.getIsDelet();
            if (currentIsDelet == null) {
                currentIsDelet = 0;
            }
            
            if (existsInExcel) {
                // Excel中存在该品种，确保is_delet=0（未删除）
                if (currentIsDelet != 0) {
                    breed.setIsDelet(0);
                    cattleBreedRepository.save(breed);
                    restoredCount++;
                    System.out.println("✓ 恢复品种: " + breedName + " (从已删除改为未删除)");
                } else {
                    System.out.println("○ 品种已存在且未删除: " + breedName);
                }
            } else {
                // Excel中不存在该品种，设置is_delet=1（已删除）
                if (currentIsDelet != 1) {
                    breed.setIsDelet(1);
                    cattleBreedRepository.save(breed);
                    deletedCount++;
                    System.out.println("✗ 标记品种为已删除: " + breedName);
                } else {
                    System.out.println("○ 品种已标记为删除: " + breedName);
                }
            }
        }
        
        System.out.println("品种逻辑删除状态更新完成: 恢复 " + restoredCount + " 个，标记删除 " + deletedCount + " 个");
        System.out.println("========== 品种逻辑删除状态更新完成 ==========");
    }
}

