package com.ruoyi.system.service.impl;

import java.math.BigDecimal;
import java.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.SysTask;
import com.ruoyi.system.domain.SysTaskEmergency;
import com.ruoyi.system.domain.SysTaskAdditionalFee;
import com.ruoyi.system.domain.SysTaskPayment;
import com.ruoyi.system.domain.vo.TaskPaymentInfoVO;
import com.ruoyi.system.domain.vo.TaskPaymentCreateVO;
import com.ruoyi.system.domain.vo.TaskPaymentResultVO;
import com.ruoyi.system.mapper.SysTaskMapper;
import com.ruoyi.system.mapper.SysTaskEmergencyMapper;
import com.ruoyi.system.mapper.SysTaskAdditionalFeeMapper;
import com.ruoyi.system.mapper.SysTaskPaymentMapper;
import com.ruoyi.system.service.ISysTaskPaymentService;
import com.ruoyi.system.service.IPaymentModuleService;
import com.ruoyi.system.service.IPaymentSyncService;
import com.ruoyi.system.service.IAdditionalFeeSyncService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 任务支付Service实现
 * 
 * @author ruoyi
 * @date 2025-01-15
 */
@Service
public class SysTaskPaymentServiceImpl implements ISysTaskPaymentService {
    
    private static final Logger log = LoggerFactory.getLogger(SysTaskPaymentServiceImpl.class);
    
    @Autowired
    private SysTaskMapper sysTaskMapper;
    
    @Autowired
    private SysTaskEmergencyMapper sysTaskEmergencyMapper;
    
    @Autowired
    private SysTaskAdditionalFeeMapper additionalFeeMapper;
    
    @Autowired
    private SysTaskPaymentMapper paymentMapper;
    
    @Autowired
    private IPaymentModuleService paymentModuleService;

    @Autowired
    private IPaymentSyncService paymentSyncService;

    @Autowired
    private IAdditionalFeeSyncService additionalFeeSyncService;

    /**
     * 供外部应用回调的接口
     */
    @Value("${payment.callback.base-url:http://localhost:8080}")
    private String callbackBaseUrl;
    
    @Override
    public TaskPaymentInfoVO getPaymentInfo(Long taskId) {
        // 查询任务
        SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
        if (task == null) {
            throw new ServiceException("任务不存在");
        }
        
        // 只有转运任务才支持支付
        if (!"EMERGENCY_TRANSFER".equals(task.getTaskType())) {
            throw new ServiceException("只有转运任务支持支付功能");
        }
        
        // 查询转运任务扩展信息获取成交价
        SysTaskEmergency emergencyInfo = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
        BigDecimal transferPrice = emergencyInfo != null && emergencyInfo.getTransferPrice() != null 
                                   ? emergencyInfo.getTransferPrice() : BigDecimal.ZERO;
        
        // 获取任务基本信息
        String taskCode = task.getTaskCode();
        String taskType = task.getTaskType();
        
        // 获取车辆信息
        String vehicleInfo = "";
        if (task.getAssignedVehicles() != null && !task.getAssignedVehicles().isEmpty()) {
            vehicleInfo = task.getAssignedVehicles().get(0).getVehicleNo();
            if (task.getAssignedVehicles().size() > 1) {
                vehicleInfo += " 等" + task.getAssignedVehicles().size() + "辆";
            }
        }
        
        // 获取出发地和目的地（从转运任务扩展信息）
        String departureAddress = "";
        String destinationAddress = "";
        if (emergencyInfo != null) {
            departureAddress = emergencyInfo.getHospitalOutAddress() != null 
                ? emergencyInfo.getHospitalOutAddress() : "";
            destinationAddress = emergencyInfo.getHospitalInAddress() != null 
                ? emergencyInfo.getHospitalInAddress() : "";
        }
        
        // 查询附加费用
        List<SysTaskAdditionalFee> additionalFees = additionalFeeMapper.selectByTaskId(taskId);
        
        // 计算附加费用汇总
        BigDecimal additionalAmount = additionalFees.stream()
            .map(SysTaskAdditionalFee::getTotalAmount)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
        
        // 计算总金额
        BigDecimal totalAmount = transferPrice.add(additionalAmount);
        
        // 查询所有已支付记录，计算已支付总额
        List<SysTaskPayment> paidPayments = paymentMapper.selectAllPaidByTaskId(taskId);
        BigDecimal paidAmount = paidPayments.stream()
            .map(SysTaskPayment::getSettlementAmount)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
        
        // 查询最近一次支付记录
        SysTaskPayment latestPayment = paymentMapper.selectLatestPaidByTaskId(taskId);
        
        // 构造返回数据
        TaskPaymentInfoVO vo = new TaskPaymentInfoVO();
        vo.setTaskCode(taskCode);
        vo.setTaskType(taskType);
        vo.setVehicleInfo(vehicleInfo);
        vo.setDepartureAddress(departureAddress);
        vo.setDestinationAddress(destinationAddress);
        vo.setTransferPrice(transferPrice);
        vo.setAdditionalFees(additionalFees);
        vo.setAdditionalAmount(additionalAmount);
        vo.setTotalAmount(totalAmount);
        vo.setPaidAmount(paidAmount);
        vo.setPaidPayments(paidPayments); // 设置已支付记录列表
        vo.setLatestPayment(latestPayment);
        vo.setPaymentMethods(Arrays.asList("CASH", "ON_ACCOUNT", "WECHAT", "ALIPAY"));
        
        return vo;
    }
    
    @Override
    @Transactional
    public BigDecimal addAdditionalFee(Long taskId, String feeType, String feeName, 
                                      BigDecimal unitAmount, Integer quantity, String remark) {
        // 验证参数
        if (unitAmount == null || unitAmount.compareTo(BigDecimal.ZERO) <= 0) {
            throw new ServiceException("单价必须大于0");
        }
        if (quantity == null || quantity <= 0) {
            throw new ServiceException("数量必须大于0");
        }
        
        // 计算总金额
        BigDecimal totalAmount = unitAmount.multiply(new BigDecimal(quantity));
        
        // 创建附加费用记录
        SysTaskAdditionalFee fee = new SysTaskAdditionalFee();
        fee.setTaskId(taskId);
        fee.setFeeType(feeType);
        fee.setFeeName(feeName);
        fee.setUnitAmount(unitAmount);
        fee.setQuantity(quantity);
        fee.setTotalAmount(totalAmount);
        fee.setRemark(remark);
        fee.setCreatedBy(SecurityUtils.getUsername());
        
        additionalFeeMapper.insert(fee);
        
        // 异步同步到旧系统
        try {
            additionalFeeSyncService.syncAdditionalFeeToLegacy(fee.getId());
        } catch (Exception e) {
            log.error("同步附加费用到旧系统失败", e);
        }
        
        // 返回当前附加费用汇总
        return calculateAdditionalAmount(taskId);
    }
    
    @Override
    @Transactional
    public BigDecimal removeAdditionalFee(Long taskId, Long feeId) {
        additionalFeeMapper.deleteById(feeId);
        return calculateAdditionalAmount(taskId);
    }
    
    @Override
    @Transactional
    public TaskPaymentResultVO createPayment(TaskPaymentCreateVO createVO) {
        Long taskId = createVO.getTaskId();
        String paymentMethod = createVO.getPaymentMethod();
        BigDecimal settlementAmount = createVO.getSettlementAmount();
        
        // 获取支付信息并校验
        TaskPaymentInfoVO paymentInfo = getPaymentInfo(taskId);
        BigDecimal paidAmount = paymentInfo.getPaidAmount();
        BigDecimal remainingAmount = paymentInfo.getTotalAmount().subtract(paidAmount);
        
        // 校验结算金额必须大于0且不超过剩余金额
        if (settlementAmount.compareTo(BigDecimal.ZERO) <= 0) {
            throw new ServiceException("结算金额必须大于0");
        }
        if (settlementAmount.compareTo(remainingAmount) > 0) {
            throw new ServiceException("结算金额不能超过剩余未支付金额：" + remainingAmount);
        }
        
        // 查询任务编号
        SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
        String taskCode = task.getTaskCode();
        
        // 生成商户订单号: {taskCode}-{timestampMillis}
        String outTradeNo = taskCode + "-" + System.currentTimeMillis();
        
        // 创建支付记录
        SysTaskPayment payment = new SysTaskPayment();
        payment.setTaskId(taskId);
        payment.setTotalAmount(paymentInfo.getTotalAmount());
        payment.setSettlementAmount(settlementAmount);
        payment.setPaymentMethod(paymentMethod);
        payment.setOutTradeNo(outTradeNo);
        payment.setRemark(createVO.getRemark());
        payment.setCreatedBy(SecurityUtils.getUsername());
        payment.setCreatedTime(new Date());
        
        TaskPaymentResultVO result = new TaskPaymentResultVO();
        
        // 支付方式字典值：1-现金, 2-银行转账, 3-微信支付, 4-支付宝, 5-POS收款, 6-挂账, 7-易医通挂账
        // 1-现金, 2-银行转账, 5-POS收款, 6-挂账, 7-易医通挂账 直接标记为已支付
        if ("1".equals(paymentMethod) || "2".equals(paymentMethod) || "5".equals(paymentMethod) 
                || "6".equals(paymentMethod) || "7".equals(paymentMethod)) {
            payment.setPayStatus("PAID");
            payment.setPayTime(new Date());
            payment.setSyncStatus(0); // 未同步
            paymentMapper.insert(payment);
            
            result.setPaymentId(payment.getId());
            result.setPayStatus("PAID");
            result.setPayTime(payment.getPayTime());
            
            log.info("任务{}创建支付方式{}支付成功，订单号：{}", taskId, paymentMethod, outTradeNo);
            
            // 异步同步到旧系统
            try {
                paymentSyncService.syncPaymentToLegacy(payment);
            } catch (Exception e) {
                log.error("同步支付记录到旧系统失败", e);
            }
        }
        // 3-微信支付, 4-支付宝 需要生成二维码
        else if ("3".equals(paymentMethod) || "4".equals(paymentMethod)) {
            payment.setPayStatus("PENDING");
            // 设置支付提供商：3-WECHAT, 4-ALIPAY
            String provider = "3".equals(paymentMethod) ? "WECHAT" : "ALIPAY";
            payment.setProvider(provider);
            
            // 生成回调地址
            String callbackUrl = callbackBaseUrl + "/payment/callback/" + provider.toLowerCase();
            payment.setCallbackUrl(callbackUrl);
            
            try {
                // 调用支付模块创建二维码
                String subject = "医疗转运支付（" + taskCode + "）";
                String attach = "taskId:" + taskId;
                
                Map<String, Object> qrResult = paymentModuleService.createQrCode(
                    outTradeNo, settlementAmount, provider, subject, attach, callbackUrl
                );
                
                // 保存支付模块返回的信息
                payment.setPaymentRefId((String) qrResult.get("paymentRefId"));
                payment.setCodeUrl((String) qrResult.get("codeUrl"));
                payment.setQrExpireTime((Date) qrResult.get("expireTime"));
                
                paymentMapper.insert(payment);
                
                result.setPaymentId(payment.getId());
                result.setPayStatus("PENDING");
                result.setCodeUrl(payment.getCodeUrl());
                result.setQrExpireTime(payment.getQrExpireTime());
                
                log.info("任务{}创建支付方式{}支付二维码成功，订单号：{}，二维码：{}", 
                        taskId, paymentMethod, outTradeNo, payment.getCodeUrl());
            } catch (Exception e) {
                log.error("调用支付模块失败", e);
                throw new ServiceException("创建支付二维码失败：" + e.getMessage());
            }
        } else {
            throw new ServiceException("不支持的支付方式：" + paymentMethod);
        }
        
        return result;
    }
    
    @Override
    public TaskPaymentResultVO getPaymentStatus(Long taskId, Long paymentId) {
        SysTaskPayment payment;
        
        if (paymentId != null) {
            payment = paymentMapper.selectById(paymentId);
        } else {
            // 查询最近一次支付记录
            List<SysTaskPayment> payments = paymentMapper.selectByTaskId(taskId);
            if (payments.isEmpty()) {
                throw new ServiceException("未找到支付记录");
            }
            payment = payments.get(0);
        }
        
        if (payment == null) {
            throw new ServiceException("支付记录不存在");
        }
        
        // 如果是待支付状态，查询支付模块获取最新状态
        if ("PENDING".equals(payment.getPayStatus())) {
            try {
                Map<String, Object> statusResult = paymentModuleService.queryPaymentStatus(
                    payment.getPaymentRefId(), payment.getOutTradeNo()
                );
                
                String status = (String) statusResult.get("status");
                
                // 如果支付成功，更新本地记录
                if ("PAID".equals(status)) {
                    String tradeNo = (String) statusResult.get("tradeNo");
                    paymentMapper.updatePayStatus(payment.getId(), "PAID", tradeNo);
                    payment.setPayStatus("PAID");
                    payment.setTradeNo(tradeNo);
                    payment.setPayTime(new Date());
                    
                    log.info("支付记录{}状态更新为已支付，交易号：{}", payment.getId(), tradeNo);
                    
                    // 异步同步到旧系统
                    try {
                        paymentSyncService.syncPaymentToLegacy(payment);
                    } catch (Exception ex) {
                        log.error("同步支付记录到旧系统失败", ex);
                    }
                }
            } catch (Exception e) {
                log.error("查询支付状态失败", e);
            }
        }
        
        // 构造返回结果
        TaskPaymentResultVO result = new TaskPaymentResultVO();
        result.setPaymentId(payment.getId());
        result.setPayStatus(payment.getPayStatus());
        result.setCodeUrl(payment.getCodeUrl());
        result.setQrExpireTime(payment.getQrExpireTime());
        result.setTradeNo(payment.getTradeNo());
        result.setPayTime(payment.getPayTime());
        
        return result;
    }
    
    @Override
    @Transactional
    public boolean handlePaymentCallback(String outTradeNo, String tradeNo, String provider) {
        log.info("收到支付回调：outTradeNo={}, tradeNo={}, provider={}", outTradeNo, tradeNo, provider);
        
        // 查询支付记录
        SysTaskPayment payment = paymentMapper.selectByOutTradeNo(outTradeNo);
        if (payment == null) {
            log.error("支付回调失败：未找到订单，outTradeNo={}", outTradeNo);
            return false;
        }
        
        // 如果已经是已支付状态，直接返回成功
        if ("PAID".equals(payment.getPayStatus())) {
            log.info("订单{}已支付，忽略重复回调", outTradeNo);
            return true;
        }
        
        // 更新支付状态
        paymentMapper.updatePayStatus(payment.getId(), "PAID", tradeNo);
        
        log.info("支付回调处理成功：订单{}已更新为已支付状态", outTradeNo);
        
        // 异步同步到旧系统
        try {
            paymentSyncService.syncPaymentToLegacy(payment);
        } catch (Exception e) {
            log.error("同步支付记录到旧系统失败", e);
        }
        
        return true;
    }
    
    @Override
    public List<SysTaskAdditionalFee> getAdditionalFees(Long taskId) {
        return additionalFeeMapper.selectByTaskId(taskId);
    }
    
    @Override
    public SysTaskPayment getLatestPayment(Long taskId) {
        return paymentMapper.selectLatestPaidByTaskId(taskId);
    }
    
    /**
     * 计算附加费用汇总
     */
    private BigDecimal calculateAdditionalAmount(Long taskId) {
        List<SysTaskAdditionalFee> fees = additionalFeeMapper.selectByTaskId(taskId);
        return fees.stream()
            .map(SysTaskAdditionalFee::getTotalAmount)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}