package com.ruoyi.system.service.impl;

import java.util.Date;
import java.util.List;

import com.ruoyi.common.core.domain.entity.SysUser;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.ruoyi.system.domain.PaidMoneyAdd;
import com.ruoyi.system.domain.SysTask;
import com.ruoyi.system.domain.SysTaskAdditionalFee;
import com.ruoyi.system.domain.SysTaskEmergency;
import com.ruoyi.system.mapper.PaidMoneyAddMapper;
import com.ruoyi.system.mapper.SysTaskAdditionalFeeMapper;
import com.ruoyi.system.mapper.SysTaskEmergencyMapper;
import com.ruoyi.system.mapper.SysTaskMapper;
import com.ruoyi.system.mapper.SysUserMapper;
import com.ruoyi.system.service.IAdditionalFeeSyncService;

/**
 * 附加费用同步Service实现
 * 
 * @author ruoyi
 * @date 2025-01-15
 */
@Service
public class AdditionalFeeSyncServiceImpl implements IAdditionalFeeSyncService {
    
    private static final Logger log = LoggerFactory.getLogger(AdditionalFeeSyncServiceImpl.class);
    
    @Autowired
    private SysTaskAdditionalFeeMapper additionalFeeMapper;
    
    @Autowired
    private PaidMoneyAddMapper paidMoneyAddMapper;
    
    @Autowired
    private SysTaskMapper sysTaskMapper;
    
    @Autowired
    private SysTaskEmergencyMapper sysTaskEmergencyMapper;
    
    @Autowired
    private SysUserMapper sysUserMapper;
    
    /**
     * 附加费用类型映射（新系统 -> 旧系统）
     * 新系统字典值：1-等待费, 2-担架, 3-居家ICU, 4-医疗设备
     * 旧系统AddMoneyType：直接使用字典值
     */
    private Integer convertFeeTypeToLegacy(String feeType) {
        if (feeType == null || feeType.trim().isEmpty()) {
            return 1; // 默认等待费
        }
        try {
            return Integer.parseInt(feeType);
        } catch (NumberFormatException e) {
            log.warn("无效的费用类型: {}", feeType);
            return 1; // 默认等待费
        }
    }
    
    /**
     * 附加费用类型映射（旧系统 -> 新系统）
     */
    private String convertFeeTypeFromLegacy(Integer addMoneyType) {
        if (addMoneyType == null) {
            return "1"; // 默认等待费
        }
        return String.valueOf(addMoneyType);
    }
    
    /**
     * 获取费用类型名称
     */
    private String getFeeTypeName(String feeType) {
        switch (feeType) {
            case "1": return "等待费";
            case "2": return "担架";
            case "3": return "居家ICU";
            case "4": return "医疗设备";
            default: return "其他费用";
        }
    }
    
    @Override
    public boolean syncAdditionalFeeToLegacy(SysTaskAdditionalFee fee) {
        Long feeId= fee.getId();
        try {

            

         // 1. 检查是否已同步
            // 2. 如果已同步过，跳过
            if (fee.getPid() != null && fee.getPid() > 0) {
                log.info("附加费用已同步，feeId: {}, pid: {}", feeId, fee.getPid());
                return true;
            }
            
            // 3. 查询任务信息获取ServiceOrdID和DispatchOrdID
            SysTask task = sysTaskMapper.selectSysTaskByTaskId(fee.getTaskId());
            if (task == null) {
                log.error("任务不存在，taskId: {}", fee.getTaskId());
                return false;
            }
            
            SysTaskEmergency emergency = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(fee.getTaskId());
            if (emergency == null || emergency.getLegacyServiceOrdId() == null || emergency.getLegacyDispatchOrdId() == null) {
                log.error("任务未同步到旧系统或缺少ServiceOrdID/DispatchOrdID，taskId: {}", fee.getTaskId());
                return false;
            }
            
            // 4. 获取创建人OA用户ID
            Integer oaUserId = null;
            try {
                String createdBy = fee.getCreatedBy();
                if (createdBy != null) {
                    SysUser user = sysUserMapper.selectUserByUserName(createdBy);
                    if (user != null) {
                        oaUserId = user.getOaUserId();
                    }
                }
            } catch (Exception e) {
                log.warn("获取创建人OA用户ID失败，使用默认值", e);
            }
            
            // 5. 构建PaidMoneyAdd对象
            PaidMoneyAdd paidMoneyAdd = new PaidMoneyAdd();
            paidMoneyAdd.setToServiceOrdID(emergency.getLegacyServiceOrdId());
            paidMoneyAdd.setToDispatchOrdID(emergency.getLegacyDispatchOrdId());
            paidMoneyAdd.setAddMoneyType(convertFeeTypeToLegacy(fee.getFeeType()));
            paidMoneyAdd.setAddMoney(fee.getTotalAmount());
            paidMoneyAdd.setAddMoneyExplain(fee.getFeeName() + 
                (fee.getRemark() != null && !fee.getRemark().isEmpty() ? "(" + fee.getRemark() + ")" : ""));
            paidMoneyAdd.setAddMoneyTime(fee.getCreatedTime() != null ? fee.getCreatedTime() : new Date());
            paidMoneyAdd.setAddMoneyOAID(oaUserId);
            
            // 6. 插入旧系统PaidMoney_Add表
            int result = paidMoneyAddMapper.insert(paidMoneyAdd);
            if (result > 0) {
                // 7. 更新新系统附加费用记录的同步信息
                additionalFeeMapper.updateSyncInfo(feeId, paidMoneyAdd.getId(), 2, new Date());
                log.info("附加费用同步到旧系统成功，feeId: {}, pid: {}", feeId, paidMoneyAdd.getId());
                return true;
            } else {
                log.error("插入旧系统PaidMoney_Add表失败，feeId: {}", feeId);
                return false;
            }
            
        } catch (Exception e) {
            log.error("同步附加费用到旧系统异常，feeId: {}", feeId, e);
            // 更新同步状态为失败
            try {
                additionalFeeMapper.updateSyncInfo(feeId, null, 3, new Date());
            } catch (Exception ex) {
                log.error("更新同步状态失败", ex);
            }
            return false;
        }
    }

    /**
     * 从旧系统同步附加费用
     * @param paidMoneyAdd 旧系统附加费用记录ID
     * @return
     */
    @Override
    public boolean syncAdditionalFeeFromLegacy(PaidMoneyAdd paidMoneyAdd) {
        try {
            Long paidMoneyAddId = paidMoneyAdd.getId();
            log.info("1.开始同步旧系统附加费用，paidMoneyAddId: {}", paidMoneyAddId);
            // 2. 检查是否已同步过
            SysTaskAdditionalFee existFee = additionalFeeMapper.selectByPid(paidMoneyAddId);
            if (existFee != null) {
                log.info("旧系统附加费用记录已同步，paidMoneyAddId: {}, feeId: {}", paidMoneyAddId, existFee.getId());
                return true;
            }
            log.info("2.开始同步旧系统附加费用，paidMoneyAddId: {}", paidMoneyAddId);
            
            // 3. 根据ServiceOrdID查询新系统任务
            if (paidMoneyAdd.getToServiceOrdID() == null) {
                log.warn("旧系统附加费用记录缺少ServiceOrdID，paidMoneyAddId: {}，跳过同步", paidMoneyAddId);
                return false;
            }
            log.info("3.开始同步旧系统附加费用，paidMoneyAddId: {}, ServiceOrdID: {}", paidMoneyAddId, paidMoneyAdd.getToServiceOrdID());
            
            SysTaskEmergency emergency = sysTaskEmergencyMapper.selectByLegacyServiceOrdId(paidMoneyAdd.getToServiceOrdID());
            if (emergency == null) {
                log.warn("4.开始同步旧系统附加费用,未找到对应的转运任务，ServiceOrdID: {}，跳过同步", paidMoneyAdd.getToServiceOrdID());
                return false;
            }

            log.info("4.开始同步旧系统附加费用，paidMoneyAddId: {}, ServiceOrdID: {}, DispatchOrdID: {}", paidMoneyAddId, paidMoneyAdd.getToServiceOrdID(), paidMoneyAdd.getToDispatchOrdID());
            // 4. 验证DispatchOrdID是否匹配
            if (paidMoneyAdd.getToDispatchOrdID() == null) {
                log.warn("旧系统附加费用记录缺少DispatchOrdID，paidMoneyAddId: {}，跳过同步", paidMoneyAddId);
                return false;
            }
            log.info("5.开始同步旧系统附加费用，paidMoneyAddId: {}, ServiceOrdID: {}, DispatchOrdID: {}", paidMoneyAddId, paidMoneyAdd.getToServiceOrdID(), paidMoneyAdd.getToDispatchOrdID());
            if (!paidMoneyAdd.getToDispatchOrdID().equals(emergency.getLegacyDispatchOrdId())) {
                log.warn("5.转运任务DispatchOrdID不匹配，ServiceOrdID: {}, 附加费用DispatchOrdID: {} vs 任务DispatchOrdID: {}，跳过同步",
                    paidMoneyAdd.getToServiceOrdID(), paidMoneyAdd.getToDispatchOrdID(), emergency.getLegacyDispatchOrdId());
                return false;
            }
            
            // 5. 构建SysTaskAdditionalFee对象
            SysTaskAdditionalFee fee = new SysTaskAdditionalFee();
            fee.setTaskId(emergency.getTaskId());
            fee.setFeeType(convertFeeTypeFromLegacy(paidMoneyAdd.getAddMoneyType()));
            fee.setFeeName(getFeeTypeName(fee.getFeeType()));
            fee.setUnitAmount(paidMoneyAdd.getAddMoney());
            fee.setQuantity(1);
            fee.setTotalAmount(paidMoneyAdd.getAddMoney());
            fee.setRemark(paidMoneyAdd.getAddMoneyExplain());
            fee.setCreatedBy("system");
            fee.setCreatedTime(paidMoneyAdd.getAddMoneyTime() != null ? paidMoneyAdd.getAddMoneyTime() : new Date());
            fee.setPid(paidMoneyAddId);
            fee.setSyncStatus(2); // 同步成功
            fee.setSyncTime(new Date());
            log.info("6.开始同步旧系统附加费用，paidMoneyAddId: {}, ServiceOrdID: {}, DispatchOrdID: {}, feeId: {}", paidMoneyAddId, paidMoneyAdd.getToServiceOrdID(), paidMoneyAdd.getToDispatchOrdID(), fee.getId());
            // 6. 插入新系统附加费用记录
            int result = additionalFeeMapper.insert(fee);
            if (result > 0) {
                log.info("6.旧系统附加费用记录同步到新系统成功，paidMoneyAddId: {}, feeId: {}", paidMoneyAddId, fee.getId());
                return true;
            } else {
                log.error("6.插入新系统附加费用记录失败，paidMoneyAddId: {}", paidMoneyAddId);
                return false;
            }
            
        } catch (Exception e) {
            log.error("8.同步旧系统附加费用记录到新系统异常，paidMoneyAddId: {}", paidMoneyAdd.getId(), e);
            return false;
        }
    }
    
    @Override
    public int batchSyncAdditionalFeeToLegacy() {
        int successCount = 0;
        try {
            // 查询未同步的附加费用记录
            List<SysTaskAdditionalFee> unsyncedFees = additionalFeeMapper.selectUnsyncedFees();
            
            log.info("开始批量同步附加费用到旧系统，待同步记录数: {}", unsyncedFees.size());
            
            for (SysTaskAdditionalFee fee : unsyncedFees) {
                try {
                    if (syncAdditionalFeeToLegacy(fee)) {
                        successCount++;
                    }
                    // 每条记录间隔1秒，避免过于频繁
                    Thread.sleep(1000);
                } catch (Exception e) {
                    log.error("同步附加费用失败，feeId: {}", fee.getId(), e);
                }
            }
            
            log.info("批量同步附加费用到旧系统完成，成功: {}, 总数: {}", successCount, unsyncedFees.size());
            
        } catch (Exception e) {
            log.error("批量同步附加费用到旧系统异常", e);
        }
        
        return successCount;
    }
    
   @Override
    public int batchSyncAdditionalFeeFromLegacy(Integer hours) {
        int successCount = 0;
        try {
            if (hours == null || hours <= 0) {
                hours = 24; // 默认24小时
            }
            
            // 查询最近N小时的附加费用记录
            List<PaidMoneyAdd> recentRecords = paidMoneyAddMapper.selectRecentRecords(hours);
            
            log.info("开始批量同步旧系统附加费用到新系统，最近{}小时记录数: {}", hours, recentRecords.size());
            
            for (PaidMoneyAdd paidMoneyAdd : recentRecords) {
                try {
                    if (syncAdditionalFeeFromLegacy(paidMoneyAdd)) {
                        successCount++;
                    }
                    // 每条记录间隔1秒，避免过于频繁
                    Thread.sleep(1000);
                } catch (Exception e) {
                    log.error("同步旧系统附加费用失败，paidMoneyAddId: {}", paidMoneyAdd.getId(), e);
                }
            }
            
            log.info("批量同步旧系统附加费用到新系统完成，成功: {}, 总数: {}", successCount, recentRecords.size());
            
        } catch (Exception e) {
            log.error("批量同步旧系统附加费用到新系统异常", e);
        }
        
        return successCount;
    }
}