package com.ghy.order.quartz;

import com.ghy.common.core.domain.AjaxResult;
import com.ghy.common.utils.DateUtils;
import com.ghy.order.domain.AfterServiceRecord;
import com.ghy.order.service.IAfterServiceRecordService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

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

/**
 * @Date: 2024-12-19
 * @Author: 系统
 * @Version: v1.0
 * @Description: 售后倒计时定时任务
 */
@Slf4j
@Component
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class AfterServiceTimeoutTask {

    private final IAfterServiceRecordService afterServiceRecordService;

    /**
     * 售后倒计时定时任务 - 每5分钟执行一次
     * 处理3种倒计时场景：
     * 1. 师傅24小时不操作自动同意完单
     * 2. 师傅重做完成后客户36小时不操作自动同意完单
     * 3. 师傅拒绝后客户36小时不操作自动取消售后
     */
    @Scheduled(cron = "0 0/5 * * * ?")
    public void afterServiceTimeoutProcess() {
        log.info("{}开始售后倒计时定时任务", DateUtils.timeFormat(new Date()));
        
        try {
            // 处理师傅24小时不操作的情况
            processWorkerFeedbackTimeout();
            
            // 处理客户36小时不操作的情况
            processCustomerConfirmTimeout();
            
            log.info("{}售后倒计时定时任务执行完成", DateUtils.timeFormat(new Date()));
        } catch (Exception e) {
            log.error("售后倒计时定时任务执行异常", e);
        }
    }

    /**
     * 处理师傅24小时不操作的情况
     * 倒计时1：客户发起后，师傅24小时不操作任何反馈，直接按同意完单
     */
    private void processWorkerFeedbackTimeout() {
        log.info("开始处理师傅反馈超时情况");
        
        // 查询需要处理的售后记录
        List<AfterServiceRecord> timeoutRecords = afterServiceRecordService.selectWorkerFeedbackTimeoutRecords();
        
        for (AfterServiceRecord record : timeoutRecords) {
            try {
                log.info("处理师傅反馈超时售后记录：{}", record.getId());
                
                // 师傅24小时不操作，直接设置为师傅同意并客户同意，完成售后
              //  record.setWorkerFeedbackResult(1L);
                record.setCustomerFinalCheck(1L);
                record.setRefundApplyTime(new Date());
                record.setIsAutoProcessed(1); // 自动处理
                
                // 根据售后类型选择更新方法
                if (record.getAfterServiceCategory() != null && record.getAfterServiceCategory().equals(1)) {
                    // 商品售后
                    afterServiceRecordService.updateGoodsAfterServiceRecord(record);
                } else {
                    // 服务售后或其他类型
                    afterServiceRecordService.updateAfterServiceRecord(record);
                }
                
                // 师傅24小时不操作，需要执行退款逻辑
                try {
                    afterServiceRecordService.executeRefundLogic(record);
                    log.info("师傅24小时不操作，自动执行退款逻辑完成，售后记录ID：{}", record.getId());
                } catch (Exception e) {
                    log.error("师傅24小时不操作，自动执行退款逻辑异常，售后记录ID：{}", record.getId(), e);
                }
                
                log.info("师傅反馈超时自动处理完成，售后记录ID：{}", record.getId());
            } catch (Exception e) {
                log.error("处理师傅反馈超时异常，售后记录ID：{}", record.getId(), e);
            }
        }
        
        log.info("师傅反馈超时处理完成，共处理{}条记录", timeoutRecords.size());
    }

    /**
     * 处理客户36小时不操作的情况
     * 倒计时2：师傅重做完成后客户36小时不操作自动同意完单
     * 倒计时3：师傅拒绝或同意后客户36小时不操作自动取消售后
     * 倒计时4：师傅选择重发/补发方案后客户36小时不操作自动取消售后
     */
    private void processCustomerConfirmTimeout() {
        log.info("开始处理客户确认超时情况");
        
        // 查询需要处理的售后记录
        List<AfterServiceRecord> timeoutRecords = afterServiceRecordService.selectCustomerConfirmTimeoutRecords();
        
        for (AfterServiceRecord record : timeoutRecords) {
            try {
                log.info("处理客户确认超时售后记录：{}", record.getId());
                
                // 根据师傅反馈结果决定处理方式
                if (record.getWorkerFeedbackResult() != null && record.getWorkerFeedbackResult().equals(3L)) {
                    // 倒计时2：师傅重做完成后客户36小时不操作自动同意完单
                    record.setCustomerFinalCheck(1L);
                    // 师傅重做完成，客户同意，订单完成，不需要退款，不设置refundApplyTime
                    record.setIsAutoProcessed(1); // 自动处理
                    
                    log.info("师傅重做完成后客户超时自动同意，订单完成，售后记录ID：{}", record.getId());
                } else if (record.getWorkerFeedbackResult() != null && 
                          (record.getWorkerFeedbackResult().equals(0L) || record.getWorkerFeedbackResult().equals(1L))) {
                    // 倒计时3：师傅拒绝或同意后客户36小时不操作自动取消售后
                    record.setCustomerFinalCheck(2L);
                    record.setAfterServiceStatus(2); // 设置为已取消状态
                    record.setIsAutoProcessed(1); // 自动处理
                    record.setWorkerReceiveConfirm(0);
                    // // 检查是否需要恢复财务金额
                    // if (record.getOriginalRefund() != null && record.getOriginalRefund().compareTo(java.math.BigDecimal.ZERO) > 0) {
                    //     log.info("售后取消，开始恢复财务金额，记录ID：{}，原退款金额：{}", 
                    //             record.getId(), record.getOriginalRefund());
                        
                    //     // 调用财务恢复逻辑
                    //     try {
                    //         afterServiceRecordService.restoreFinancialAmount(record);
                    //         log.info("售后取消财务金额恢复成功，记录ID：{}", record.getId());
                    //     } catch (Exception e) {
                    //         log.error("售后取消财务金额恢复失败，记录ID：{}，错误：{}", 
                    //                 record.getId(), e.getMessage(), e);
                    //     }
                    // }
                    
                    log.info("师傅拒绝/同意后客户超时自动取消，售后单取消完成，售后记录ID：{}", record.getId());
                }else if (record.getWorkerFeedbackResult() != null && record.getWorkerFeedbackResult().equals(2L)) {
                   //师傅重做补做完成时候，客户36小时不操作自动取消售后
                    record.setCustomerFinalCheck(2L);
                    record.setAfterServiceStatus(2); // 设置为已取消状态
                    record.setIsAutoProcessed(1); // 自动处理
                    record.setWorkerReceiveConfirm(0);
                    
                    log.info("师傅重做补做完成时候，客户36小时不操作自动取消售后，订单完成，售后记录ID：{}", record.getId());
                }
                
                // 更新记录
                 if (record.getAfterServiceCategory() != null && record.getAfterServiceCategory().equals(1)) {
                    // 商品售后
                    afterServiceRecordService.updateGoodsAfterServiceRecord(record);
                } else {
                    // 服务售后或其他类型
                    afterServiceRecordService.updateAfterServiceRecord(record);
                }
                
                // 恢复确认中倒计时
                afterServiceRecordService.resumeConfirmTimeout(record.getOrderDetailId());
                
                log.info("客户确认超时自动处理完成，售后记录ID：{}", record.getId());
            } catch (Exception e) {
                log.error("处理客户确认超时异常，售后记录ID：{}", record.getId(), e);
            }
        }
        
        log.info("客户确认超时处理完成，共处理{}条记录", timeoutRecords.size());
    }

    /**
     * 师傅重发补发超时处理
     * 快递为4天 其他未1天
     * 
     * 超时后自动按客户同意处理
     */
    @Scheduled(fixedRate = 5 * 60 * 1000) // 5分钟执行一次
    public void handleWorkerResendTimeout() {
        log.info("开始处理师傅重发补发超时...");
        
        // 查询需要处理的师傅重发补发超时记录
        List<AfterServiceRecord> timeoutRecords = afterServiceRecordService.selectWorkerResendTimeoutRecords();
        
        for (AfterServiceRecord record : timeoutRecords) {
            try {
                log.info("处理师傅重发补发超时售后记录：{}", record.getId());
                
                // 自动设置为客户同意
                record.setCustomerFinalCheck(1L);
                record.setIsAutoProcessed(1);
                record.setRefundApplyTime(new Date());
                record.setAfterServiceStatus(1);
                
                // 更新记录
                afterServiceRecordService.updateGoodsAfterServiceRecord(record);
                
                // 恢复确认中倒计时
                afterServiceRecordService.resumeConfirmTimeout(record.getOrderDetailId());
                
                log.info("师傅重发补发超时自动同意，售后记录ID：{}，重发方式：{}", 
                        record.getId(), record.getWorkerResendType());
            } catch (Exception e) {
                log.error("处理师傅重发补发超时异常，售后记录ID：{}", record.getId(), e);
            }
        }
        
        log.info("师傅重发补发超时处理完成，共处理{}条记录", timeoutRecords.size());
    }

    /**
     * 定时任务：自动处理超时的师傅确认收货
     * ，查询退货发货时间超过6天且师傅未确认收货的售后记录
     * 自动调用师傅确认收货方法进行退款处理
     */
    @Scheduled(cron = "0 0 8,12,18 * * ?")
    public void autoConfirmReceiveTask() {
        try {
            log.info("开始执行自动确认收货定时任务");
            
            // 查询退货发货时间超过6天且师傅未确认收货的售后记录
            List<AfterServiceRecord> timeoutRecords = afterServiceRecordService.selectReturnShipTimeoutRecords();
            
            if (timeoutRecords == null || timeoutRecords.isEmpty()) {
                log.info("没有找到需要自动确认收货的超时记录");
                return;
            }
            
            log.info("找到{}条需要自动确认收货的超时记录", timeoutRecords.size());
            
            int successCount = 0;
            int failCount = 0;
            
            // 循环处理每条超时记录
            for (AfterServiceRecord record : timeoutRecords) {
                try {
                    log.info("开始自动确认收货，售后记录ID：{}，退货发货时间：{}", 
                            record.getId(), record.getReturnShipTime());
                    
                    // 创建参数对象
                    AfterServiceRecord param = new AfterServiceRecord();
                    param.setId(record.getId());
                    
                    // 调用师傅确认收货方法
                    AjaxResult result = afterServiceRecordService.workerConfirmReceive(param);
                    
                    // if (result.isSuccess()) {
                    //     successCount++;
                        
                    //     // 标记为自动处理
                    //     record.setIsAutoProcessed(1);
                    //     record.setAutoProcessTime(new Date());
                    //     record.setUpdateTime(new Date());
                    //     afterServiceRecordService.updateAfterServiceRecord(record);
                        
                    //     log.info("自动确认收货成功，售后记录ID：{}", record.getId());
                    // } else {
                    //     failCount++;
                    //     log.error("自动确认收货失败，售后记录ID：{}，错误信息：{}", 
                    //             record.getId(), result.getMsg());
                    // }
                    
                } catch (Exception e) {
                    failCount++;
                    log.error("自动确认收货异常，售后记录ID：{}，错误：{}", 
                            record.getId(), e.getMessage(), e);
                }
            }
            
            log.info("自动确认收货定时任务执行完成，总记录数：{}，成功：{}，失败：{}", 
                    timeoutRecords.size(), successCount, failCount);
                    
        } catch (Exception e) {
            log.error("自动确认收货定时任务执行异常：{}", e.getMessage(), e);
        }
    }
}
