package com.ruoyi.system.service.impl;

import java.math.BigDecimal;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.ruoyi.common.annotation.DataSource;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.enums.DataSourceType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.system.domain.PaidMoney;
import com.ruoyi.system.domain.SysTask;
import com.ruoyi.system.domain.SysTaskEmergency;
import com.ruoyi.system.domain.SysTaskPayment;
import com.ruoyi.system.mapper.PaidMoneyMapper;
import com.ruoyi.system.mapper.SysTaskEmergencyMapper;
import com.ruoyi.system.mapper.SysTaskMapper;
import com.ruoyi.system.mapper.SysTaskPaymentMapper;
import com.ruoyi.system.mapper.SysUserMapper;
import com.ruoyi.system.service.IPaymentSyncService;

/**
 * 支付信息同步Service实现
 * 
 * @author ruoyi
 * @date 2025-01-15
 */
@Service
public class PaymentSyncServiceImpl implements IPaymentSyncService {
    
    private static final Logger log = LoggerFactory.getLogger(PaymentSyncServiceImpl.class);
    
    @Autowired
    private SysTaskPaymentMapper sysTaskPaymentMapper;
    
    @Autowired
    private PaidMoneyMapper paidMoneyMapper;
    
    @Autowired
    private SysTaskMapper sysTaskMapper;
    
    @Autowired
    private SysTaskEmergencyMapper sysTaskEmergencyMapper;
    
    @Autowired
    private SysUserMapper sysUserMapper;
    
    /**
     * 支付方式映射（新系统 -> 旧系统）
     * 新系统：CASH现金, ON_ACCOUNT挂账, WECHAT微信, ALIPAY支付宝
     * 旧系统：1-现金, 2-银行转账, 3-微信支付, 4-支付宝, 5-POS收款, 6-挂账, 7-易医通挂账
     */
    private Integer convertPaymentMethodToLegacy(String paymentMethod) {
        return Integer.valueOf(paymentMethod); // 直接转换，假设paymentMethod已经是正确的 legacy 值
    }
    
    /**
     * 支付方式映射（旧系统 -> 新系统）
     */
    private String convertPaymentMethodFromLegacy(Integer paidMoneyType) {
       return paidMoneyType.toString(); // 直接转换，假设paidMoneyType已经是正确的 paymentMethod 值
    }
    
    /**
     * 将新系统支付记录同步到旧系统PaidMoney表
     */
    @Override
    public boolean syncPaymentToLegacy(SysTaskPayment payment) {
        Long paymentId = payment.getId();
        try {


            // 2. 如果已同步过，跳过
            if (payment.getPid() != null && payment.getPid() > 0) {
                log.info("支付记录已同步，paymentId: {}, pid: {}", payment.getId(), payment.getPid());
                return true;
            }
            
            // 3. 查询任务信息获取ServiceOrdIDDt和DispatchOrdIDDt
            SysTask task = sysTaskMapper.selectSysTaskByTaskId(payment.getTaskId());
            if (task == null) {
                log.error("任务不存在，taskId: {}", payment.getTaskId());
                return false;
            }
            
            SysTaskEmergency emergency = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(payment.getTaskId());
            if (emergency == null || emergency.getLegacyServiceOrdId() == null || emergency.getLegacyDispatchOrdId() == null) {
                log.error("任务未同步到旧系统或缺少ServiceOrdID/DispatchOrdID，taskId: {}", payment.getTaskId());
                return false;
            }
            
            // 4. 获取支付人OA用户ID
            Integer oaUserId = null;
            try {
                String createdBy = payment.getCreatedBy();
                if (createdBy != null) {
                    SysUser user = sysUserMapper.selectUserByUserName(createdBy);
                    if (user != null) {
                        oaUserId = user.getOaUserId();
                    }
                }
            } catch (Exception e) {
                log.warn("获取支付人OA用户ID失败，使用默认值", e);
            }
            
            // 5. 构建PaidMoney对象
            PaidMoney paidMoney = new PaidMoney();
            paidMoney.setPaidMoneyClass("FI"); // 默认FI
            paidMoney.setServiceOrdIDDt(emergency.getLegacyServiceOrdId());
            if(emergency.getLegacyDispatchOrdId()!=null) {
                paidMoney.setDispatchOrdIDDt(emergency.getLegacyDispatchOrdId());
            }
            paidMoney.setPaidMoney(payment.getSettlementAmount());
            paidMoney.setPaidMoneyType(convertPaymentMethodToLegacy(payment.getPaymentMethod()));
            paidMoney.setPaidMoneyMono(payment.getTradeNo() != null ? payment.getTradeNo() : payment.getOutTradeNo());
            paidMoney.setPaidMoneyTime(payment.getPayTime() != null ? payment.getPayTime() : new Date());
            paidMoney.setPaidMoneyOaID(oaUserId);
            paidMoney.setPaidMoneyUnitID(0); // 默认为0
            paidMoney.setPaidMoneyAPCheck(0); // 已确认
            paidMoney.setPaidMoneyAPTime(new Date());
            paidMoney.setPaidMoneyTimestamp(String.valueOf(System.currentTimeMillis()));

            // 6. 插入旧系统PaidMoney表
            int result = paidMoneyMapper.insert(paidMoney);
            if (result > 0) {
                // 7. 更新新系统支付记录的同步信息
                sysTaskPaymentMapper.updateSyncInfo(paymentId, paidMoney.getId(), 2, new Date());
                log.info("支付记录同步到旧系统成功，paymentId: {}, pid: {}", paymentId, paidMoney.getId());
                return true;
            } else {
                log.error("插入旧系统PaidMoney表失败，paymentId: {}", paymentId);
                return false;
            }
            
        } catch (Exception e) {
            log.error("同步支付记录到旧系统异常，paymentId: {}", paymentId, e);
            // 更新同步状态为失败
            try {
                sysTaskPaymentMapper.updateSyncInfo(paymentId, null, 3, new Date());
            } catch (Exception ex) {
                log.error("更新同步状态失败", ex);
            }
            return false;
        }
    }
    
    /**
     * 将旧系统PaidMoney记录同步到新系统
     */
    @Override    
    public boolean syncPaymentFromLegacy(PaidMoney paidMoney) {
        Long paidMoneyId = paidMoney.getId();
        try {
           
            
            // 2. 检查是否已同步过
            SysTaskPayment existPayment = sysTaskPaymentMapper.selectByPid(paidMoney.getId());
            if (existPayment != null) {
                log.info("旧系统支付记录已同步，paidMoneyId: {}, paymentId: {}", paidMoney.getId(), existPayment.getId());
                return true;
            }
            
            // 3. 根据ServiceOrdIDDt查询新系统任务
            if (paidMoney.getServiceOrdIDDt() == null) {
                log.warn("旧系统支付记录缺少ServiceOrdID，paidMoneyId: {}，跳过同步", paidMoneyId);
                return false;
            }
            
            SysTaskEmergency emergency = sysTaskEmergencyMapper.selectByLegacyServiceOrdId(paidMoney.getServiceOrdIDDt());
            if (emergency == null) {
                log.warn("未找到对应的转运任务，ServiceOrdID: {}，跳过同步", paidMoney.getServiceOrdIDDt());
                return false;
            }
            
            // 4. 验证DispatchOrdID是否匹配
            if (paidMoney.getDispatchOrdIDDt() == null) {
                log.warn("旧系统支付记录缺少DispatchOrdID，paidMoneyId: {}，跳过同步", paidMoneyId);
                return false;
            }
            
            if (!paidMoney.getDispatchOrdIDDt().equals(emergency.getLegacyDispatchOrdId())) {
                log.warn("转运任务DispatchOrdID不匹配，ServiceOrdID: {}, 支付记录DispatchOrdID: {} vs 任务DispatchOrdID: {}，跳过同步",
                    paidMoney.getServiceOrdIDDt(), paidMoney.getDispatchOrdIDDt(), emergency.getLegacyDispatchOrdId());
                return false;
            }
            
            // 5. 查询任务信息
            SysTask task = sysTaskMapper.selectSysTaskByTaskId(emergency.getTaskId());
            if (task == null) {
                log.error("任务不存在，taskId: {}", emergency.getTaskId());
                return false;
            }
            
            // 6. 构建SysTaskPayment对象
            SysTaskPayment payment = new SysTaskPayment();
            payment.setTaskId(task.getTaskId());
            payment.setTotalAmount(paidMoney.getPaidMoney());
            payment.setSettlementAmount(paidMoney.getPaidMoney());
            payment.setPaymentMethod(convertPaymentMethodFromLegacy(paidMoney.getPaidMoneyType()));
            payment.setPayStatus("PAID"); // 已支付
            payment.setPayTime(paidMoney.getPaidMoneyTime() != null ? paidMoney.getPaidMoneyTime() : new Date());
            payment.setOutTradeNo(task.getTaskCode() + "-" + paidMoneyId);
            payment.setTradeNo(paidMoney.getPaidMoneyMono());
            payment.setPid(paidMoneyId);
            payment.setSyncStatus(2); // 同步成功
            payment.setSyncTime(new Date());
            payment.setCreatedBy("system");
            payment.setCreatedTime(paidMoney.getPaidMoneyTime() != null ? paidMoney.getPaidMoneyTime() : new Date());
            
            // 7. 插入新系统支付记录
            int result = sysTaskPaymentMapper.insert(payment);
            if (result > 0) {
                log.info("旧系统支付记录同步到新系统成功，paidMoneyId: {}, paymentId: {}", paidMoneyId, payment.getId());
                return true;
            } else {
                log.error("插入新系统支付记录失败，paidMoneyId: {}", paidMoneyId);
                return false;
            }
            
        } catch (Exception e) {
            log.error("同步旧系统支付记录到新系统异常，paidMoneyId: {}", paidMoneyId, e);
            return false;
        }
    }
    
    /**
     * 批量同步新系统未同步的支付记录到旧系统
     */
    @Override
    public int batchSyncPaymentToLegacy() {
        int successCount = 0;
        try {
            // 查询未同步的支付成功记录
            List<SysTaskPayment> unsyncedPayments = sysTaskPaymentMapper.selectUnsyncedPaidPayments();
            
            log.info("开始批量同步支付记录到旧系统，待同步记录数: {}", unsyncedPayments.size());
            
            for (SysTaskPayment payment : unsyncedPayments) {
                try {
                    if (syncPaymentToLegacy(payment)) {
                        successCount++;
                    }
                    // 每条记录间隔1秒，避免过于频繁
                    Thread.sleep(1000);
                } catch (Exception e) {
                    log.error("同步支付记录失败，paymentId: {}", payment.getId(), e);
                }
            }
            
            log.info("批量同步支付记录到旧系统完成，成功: {}, 总数: {}", successCount, unsyncedPayments.size());
            
        } catch (Exception e) {
            log.error("批量同步支付记录到旧系统异常", e);
        }
        
        return successCount;
    }
    
    /**
     * 批量同步旧系统新增的支付记录到新系统
     */
    @Override    
    public int batchSyncPaymentFromLegacy() {
        int successCount = 0;
        try {
            // 查询旧系统最近7天的支付记录
            List<PaidMoney> recentPayments = paidMoneyMapper.selectRecentRecords(7);
            
            log.info("开始批量同步旧系统支付记录到新系统，最近7天记录数: {}", recentPayments.size());
            
            for (PaidMoney paidMoney : recentPayments) {
                try {
                    if (syncPaymentFromLegacy(paidMoney)) {
                        successCount++;
                    }
                    // 每条记录间隔1秒，避免过于频繁
                    Thread.sleep(1000);
                } catch (Exception e) {
                    log.error("同步旧系统支付记录失败，paidMoneyId: {}", paidMoney.getId(), e);
                }
            }
            
            log.info("批量同步旧系统支付记录到新系统完成，成功: {}, 总数: {}", successCount, recentPayments.size());
            
        } catch (Exception e) {
            log.error("批量同步旧系统支付记录到新系统异常", e);
        }
        
        return successCount;
    }
}