package com.zhyc.module.produce.breed.service.impl;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.zhyc.common.utils.DateUtils;
import com.zhyc.common.utils.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.zhyc.module.produce.breed.mapper.ScBreedRecordMapper;
import com.zhyc.module.produce.breed.domain.ScBreedRecord;
import com.zhyc.module.produce.breed.service.IScBreedRecordService;

/**
 * 配种记录Service业务层处理
 *
 * @author ruoyi
 * @date 2025-07-23
 */
@Service
public class ScBreedRecordServiceImpl implements IScBreedRecordService
{
    private static final Logger log = LoggerFactory.getLogger(ScBreedRecordServiceImpl.class);

    @Autowired
    private ScBreedRecordMapper scBreedRecordMapper;

    /**
     * 查询配种记录
     *
     * @param id 配种记录主键
     * @return 配种记录
     */
    @Override
    public ScBreedRecord selectScBreedRecordById(Long id)
    {
        return scBreedRecordMapper.selectScBreedRecordById(id);
    }

    /**
     * 查询配种记录列表
     *
     * @param scBreedRecord 配种记录
     * @return 配种记录
     */
//    @Override
//    public List<ScBreedRecord> selectScBreedRecordList(ScBreedRecord scBreedRecord)
//    {
//        // 如果查询条件中有耳号，需要先转换为ID
//        if (StringUtils.isNotEmpty(scBreedRecord.getEweManageTags()))
//        {
//            Long eweId = scBreedRecordMapper.getSheepIdByManageTags(scBreedRecord.getEweManageTags());
//            if (eweId != null)
//            {
//                scBreedRecord.setEweId(eweId.toString());
//            }
//        }
//
//        if (StringUtils.isNotEmpty(scBreedRecord.getRamManageTags()))
//        {
//            Long ramId = scBreedRecordMapper.getRamIdByManageTags(scBreedRecord.getRamManageTags());
//            if (ramId != null)
//            {
//                scBreedRecord.setRamId(ramId.toString());
//            }
//        }
//
//        return scBreedRecordMapper.selectScBreedRecordList(scBreedRecord);
//    }
    @Override
    public List<ScBreedRecord> selectScBreedRecordList(ScBreedRecord scBreedRecord) {
        // ... (耳号转ID逻辑保持不变) ...
        // 如果查询条件中有耳号，需要先转换为ID (注意：供体母羊/公羊是直接存字符串的，不需要转ID，只有作为受体的eweId需要转)
        if (StringUtils.isNotEmpty(scBreedRecord.getEweManageTags()))
        {
            Long eweId = scBreedRecordMapper.getSheepIdByManageTags(scBreedRecord.getEweManageTags());
            if (eweId != null)
            {
                // 注意：这里仅设置eweId用于查询作为受体的记录
                // 如果用户想搜"供体母羊"是xxx，Mapper XML中的 OR 逻辑会处理
                scBreedRecord.setEweId(eweId.toString());
            }
        }
        // ...
        return scBreedRecordMapper.selectScBreedRecordList(scBreedRecord);
    }
    /**
     * 新增配种记录
     *
     * @param scBreedRecord 配种记录
     * @return 结果
     */
//    @Override
//    public int insertScBreedRecord(ScBreedRecord scBreedRecord)
//    {
//        scBreedRecord.setCreateTime(DateUtils.getNowDate());
//        return scBreedRecordMapper.insertScBreedRecord(scBreedRecord);
//    }

    /**
     * 修改配种记录
     *
     * @param scBreedRecord 配种记录
     * @return 结果
     */
    @Override
    public int updateScBreedRecord(ScBreedRecord scBreedRecord)
    {
        return scBreedRecordMapper.updateScBreedRecord(scBreedRecord);
    }

    /**
     * 批量删除配种记录
     *
     * @param ids 需要删除的配种记录主键
     * @return 结果
     */
    @Override
    public int deleteScBreedRecordByIds(Long[] ids)
    {
        return scBreedRecordMapper.deleteScBreedRecordByIds(ids);
    }

    /**
     * 删除配种记录信息
     *
     * @param id 配种记录主键
     * @return 结果
     */
    @Override
    public int deleteScBreedRecordById(Long id)
    {
        return scBreedRecordMapper.deleteScBreedRecordById(id);
    }

    /**
     * 根据耳号查询羊只ID
     *
     * @param manageTags 管理耳号
     * @return 羊只ID
     */
    @Override
    public Long getSheepIdByTags(String manageTags)
    {
        return scBreedRecordMapper.getSheepIdByManageTags(manageTags);
    }

    /**
     * 根据公羊耳号查询羊只ID
     *
     * @param manageTags 管理耳号
     * @return 羊只ID
     */
    @Override
    public Long getRamIdByTags(String manageTags)
    {
        return scBreedRecordMapper.getRamIdByManageTags(manageTags);
    }

    /**
     * 根据耳号查询羊只详细信息
     *
     * @param manageTags 管理耳号
     * @return 羊只信息
     */
    @Override
    public Map<String, Object> getSheepInfoByTags(String manageTags)
    {
        return scBreedRecordMapper.getSheepInfoByTags(manageTags);
    }

    /**
     * 根据母羊耳号获取配种计划信息
     *
     * @param manageTags 母羊管理耳号
     * @return 配种计划信息
     */
    @Override
    public Map<String, Object> getBreedPlanByEweTags(String manageTags)
    {
        return scBreedRecordMapper.getBreedPlanByEweTags(manageTags);
    }

    /**
     * 根据母羊耳号获取最新的配种计划信息（优先从配种计划生成表获取）
     *
     * @param manageTags 母羊管理耳号
     * @return 配种计划信息
     */
//    @Override
//    public Map<String, Object> getLatestBreedPlanByEweTags(String manageTags)
//    {
//        try {
//            // 优先从配种计划生成表获取最新计划
//            Map<String, Object> latestPlan = scBreedRecordMapper.getLatestBreedPlanByEweTags(manageTags);
//
//            if (latestPlan != null && !latestPlan.isEmpty()) {
//                log.info("从配种计划生成表获取到配种计划: {}", latestPlan);
//                return latestPlan;
//            }
//
//            // 如果生成表中没有，则从普通配种计划表获取
//            Map<String, Object> normalPlan = scBreedRecordMapper.getBreedPlanByEweTags(manageTags);
//            if (normalPlan != null && !normalPlan.isEmpty()) {
//                log.info("从配种计划表获取到配种计划: {}", normalPlan);
//                return normalPlan;
//            }
//
//            log.warn("未找到母羊耳号 {} 的配种计划信息", manageTags);
//            return null;
//
//        } catch (Exception e) {
//            log.error("获取配种计划信息时发生异常，母羊耳号: {}", manageTags, e);
//            return null;
//        }
//    }
    /**
     * 简化后的获取配种计划方法：移除冲胚记录自动关联
     */
    @Override
    public Map<String, Object> getLatestBreedPlanByEweTags(String manageTags) {
        try {
            // 1. 仅从配种计划生成表获取（本交、人工授精等普通计划）
            Map<String, Object> latestPlan = scBreedRecordMapper.getLatestBreedPlanByEweTags(manageTags);
            if (latestPlan != null && !latestPlan.isEmpty()) {
                return latestPlan;
            }

            // 2. 从普通配种计划表获取
            Map<String, Object> normalPlan = scBreedRecordMapper.getBreedPlanByEweTags(manageTags);
            if (normalPlan != null && !normalPlan.isEmpty()) {
                return normalPlan;
            }

            // 胚胎移植逻辑已移至前端手动输入，此处不再查询 sc_embryo_flush
            log.info("未找到母羊 {} 的普通配种计划", manageTags);
            return null;
        } catch (Exception e) {
            log.error("获取配种计划异常", e);
            return null;
        }
    }
    /**
     * 同步孕检结果到配种记录
     *
     * @param pregnancyRecordId 孕检记录ID
     * @param sheepId 羊只ID
     * @param pregnancyCheckDate 孕检日期
     * @return 结果
     */
    @Override
    public int syncPregnancyResult(Long pregnancyRecordId, Long sheepId, String pregnancyCheckDate)
    {
        try {
            // 查找孕检日期前最近的配种记录
            List<ScBreedRecord> breedRecords = scBreedRecordMapper.selectBreedRecordByMatingTime(
                    sheepId, null, pregnancyCheckDate);

            if (breedRecords != null && !breedRecords.isEmpty()) {
                // 取最近的一次配种记录
                ScBreedRecord latestBreedRecord = breedRecords.get(0);

                // 更新配种记录中的孕检信息
                return scBreedRecordMapper.updatePregnancyInfo(latestBreedRecord.getId(), pregnancyRecordId);
            } else {
                log.warn("未找到羊只ID {} 在孕检日期 {} 前的配种记录", sheepId, pregnancyCheckDate);
                return 0;
            }
        } catch (Exception e) {
            log.error("同步孕检结果到配种记录时发生异常", e);
            return 0;
        }
    }

    /**
     * 根据羊只ID和时间范围查询配种记录
     *
     * @param sheepId 羊只ID
     * @param startDate 开始时间
     * @param endDate 结束时间
     * @return 配种记录集合
     */
    @Override
    public List<ScBreedRecord> getBreedRecordsByTimeRange(Long sheepId, String startDate, String endDate)
    {
        return scBreedRecordMapper.selectBreedRecordByMatingTime(sheepId, startDate, endDate);
    }

    /**
     * 新增配种记录
     */
    @Override
    public int insertScBreedRecord(ScBreedRecord scBreedRecord)
    {
        scBreedRecord.setCreateTime(DateUtils.getNowDate());

        // 如果是胚胎移植(5)，且前端没有传移胚数等信息，可以在这里做一次兜底查询
        // 但通常前端 form 表单提交时应该已经通过 getLatestBreedPlanByEweTags 填好了

        // 插入记录
        int result = scBreedRecordMapper.insertScBreedRecord(scBreedRecord);

        // 同步更新羊只的基础信息（配种次数、配种日期）
        if (result > 0 && scBreedRecord.getEweId() != null) {
            try {
                Long eweId = Long.parseLong(scBreedRecord.getEweId());
                scBreedRecordMapper.incrementSheepMatingCount(
                        eweId,
                        scBreedRecord.getCreateTime(),
                        scBreedRecord.getCreateBy()
                );
            } catch (Exception e) {
                log.error("同步更新羊只配种日期失败", e);
            }
        }
        return result;
    }
    @Override
    public ScBreedRecord getAutomaticBreedMatch(String manageTags) {
        // 1. 尝试从配种计划获取 (breed_type: 1, 2, 3, 4)
        Map<String, Object> plan = scBreedRecordMapper.getLatestBreedPlanByEweTags(manageTags);
        if (plan != null) {
            ScBreedRecord record = new ScBreedRecord();
            record.setBreedType(Integer.parseInt(plan.get("breed_type").toString()));
            record.setRamManageTags((String) plan.get("ram_manage_tags"));
            return record;
        }

        // 2. 尝试从冲胚记录获取
        Map<String, Object> flushRecord = scBreedRecordMapper.getFlushRecordByEweNo(manageTags);
        if (flushRecord != null) {
            ScBreedRecord record = new ScBreedRecord();
            record.setBreedType(5); // 设定 5 为胚胎移植（您可根据实际调整枚举）
            record.setEmbryoCount(Integer.parseInt(flushRecord.get("transferred").toString()));
            record.setDonorEweNo((String) flushRecord.get("donor_female_no"));
            record.setDonorRamNo((String) flushRecord.get("donor_male_no"));
            // 根据冲胚记录的存储方式和类型拼接“配种子类型”
            record.setEmbryoSubType(flushRecord.get("embryo_type") + " " + flushRecord.get("storage_method"));
            return record;
        }

        return null; // 均未找到
    }
}