package com.ruoyi.system.service.impl;

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

import com.ruoyi.common.utils.LongUtil;
import com.ruoyi.system.domain.*;
import com.ruoyi.system.mapper.*;
import com.ruoyi.system.service.*;
import com.ruoyi.system.task.ITaskAttachmentService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;

import com.ruoyi.common.config.LegacySystemConfig;

/**
 * 旧系统同步Service业务层处理
 * 
 * @author ruoyi
 * @date 2024-01-20
 */
@Service
public class LegacySystemSyncServiceImpl implements ILegacySystemSyncService {
    
    private static final Logger log = LoggerFactory.getLogger(LegacySystemSyncServiceImpl.class);
    
    @Autowired
    private LegacySystemConfig legacyConfig;
    
    @Autowired
    private SysTaskMapper sysTaskMapper;
    
    @Autowired
    private SysTaskEmergencyMapper sysTaskEmergencyMapper;
    
    @Autowired
    private SysUserMapper sysUserMapper;
    
    @Autowired
    private SysDeptMapper sysDeptMapper;
    
    @Autowired
    private SysTaskVehicleMapper sysTaskVehicleMapper;
    
    @Autowired
    private SysTaskAssigneeMapper sysTaskAssigneeMapper;
    
    @Autowired
    private VehicleInfoMapper vehicleInfoMapper;
    
    @Autowired
    private IDispatchOrdService dispatchOrdService;
    
    @Autowired
    private ISysTaskEmergencyService sysTaskEmergencyService;

    @Autowired
    private ITaskAttachmentSyncService taskAttachmentSyncService;

    @Autowired
    private ISysTaskService sysTaskService;

    @Autowired
    private ITaskAttachmentService taskAttachmentService;


    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    @Autowired
    private LegacyTransferSyncMapper legacyTransferSyncMapper;


    @Autowired
    private TaskEmergencySyncService taskEmergencySyncService;


    @Autowired
    private ITaskDispatchSyncService taskDispatchSyncService;




    @Override
    public Long syncEmergencyTaskToLegacy(Long taskId) {
        return taskEmergencySyncService.syncEmergency(taskId);
    }

    /**
     * 批量同步未同步的急救转运任务
     * 使用分页查询，确保所有符合条件的任务都能被同步
     */
    @Override
    public int batchSyncPendingTasks() {
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用");
            return 0;
        }
        
        try {
            int totalSuccessCount = 0;
            int pageSize = 100; // 每页100条
            int offset = 0;
            
            while (true) {
                // 分页查询未同步的急救转运任务（同步状态为0或3的任务）
                List<SysTaskEmergency> pendingTasks = sysTaskEmergencyService.selectPendingSyncTasks(offset, pageSize);
                
                if (pendingTasks == null || pendingTasks.isEmpty()) {
                    log.info("没有更多需要同步的任务，offset: {}", offset);
                    break; // 没有更多数据，退出循环
                }
                
//                log.info("开始同步第 {} 页，任务数量: {}", (offset / pageSize) + 1, pendingTasks.size());
                
                int pageSuccessCount = 0;
                for (SysTaskEmergency emergency : pendingTasks) {
                    Long serviceOrdId = syncEmergencyTaskToLegacy(emergency.getTaskId());
                    if (LongUtil.isNotEmpty(serviceOrdId)) {
                        pageSuccessCount++;
                    }
                    
                    // 避免过于频繁的请求
                    try {
                        Thread.sleep(1000); // 每个请求间隔1秒
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        log.warn("同步被中断");
                        return totalSuccessCount + pageSuccessCount;
                    }
                }
                
                totalSuccessCount += pageSuccessCount;
//                log.info("第 {} 页同步完成，总数: {}, 成功: {}",
//                    (offset / pageSize) + 1, pendingTasks.size(), pageSuccessCount);
                
                // 如果本页数据少于每页大小，说明已经是最后一页
                if (pendingTasks.size() < pageSize) {
//                    log.info("已到达最后一页，同步结束");
                    break;
                }
                
                offset += pageSize; // 下一页
            }
            
//            log.info("批量同步完成，总成功数: {}", totalSuccessCount);
            return totalSuccessCount;
            
        } catch (Exception e) {
            log.error("批量同步任务异常", e);
            return 0;
        }
    }
    
    /**
     * 重新同步失败的任务
     */
    @Override    
    public boolean retrySyncTask(Long taskId) {
        try {
            // 重置同步状态
            SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId);
            if (emergency != null) {
                emergency.setSyncStatus(0); // 重置为未同步
                emergency.setLegacyServiceOrdId(null);
                emergency.setSyncErrorMsg(null);
                sysTaskEmergencyService.updateSysTaskEmergency(emergency);
            }
            
            // 重新同步
            Long serviceOrdId = syncEmergencyTaskToLegacy(taskId);
            return LongUtil.isNotEmpty(serviceOrdId);
            
        } catch (Exception e) {
            log.error("重新同步任务失败，任务ID: {}", taskId, e);
            return false;
        }
    }

    @Override
    public Long syncDispatchOrderToLegacy(Long taskId) {
        return taskDispatchSyncService.syncDispatch(taskId);
    }


    /**
     * 同步任务附件到旧系统
     * @param taskAttachments
     * @param serviceOrdId
     * @param dispatchOrdId
     * @param oaUserID
     */
    public void syncAttachmentToLegacy(List<SysTaskAttachment> taskAttachments, Long serviceOrdId,Long dispatchOrdId,Integer oaUserID) {
        taskAttachments.forEach((taskAttachment)->{
            Long imageDataId=  taskAttachmentSyncService.syncAttachmentToImageData(taskAttachment,serviceOrdId,dispatchOrdId,oaUserID);
            if (imageDataId != null && imageDataId > 0) {

                taskAttachment.setSyncedToImageData(1);
                taskAttachment.setSyncTime(new Date());
                taskAttachment.setImageDataId(imageDataId);
                taskAttachmentService.updateAttachment(taskAttachment);
            }
        });
    }


    @Override
    public void syncTaskAttachment(Long taskId, Long dispatchOrdId, Long serviceOrdId, Integer oaUserID){
        List<SysTaskAttachment> taskAttachments= sysTaskService.getAttachmentsByTaskId(taskId);
        if (taskAttachments != null && !taskAttachments.isEmpty()) {
            //同步附件
            this.syncAttachmentToLegacy(taskAttachments,serviceOrdId,dispatchOrdId,oaUserID);
        }
    }

    /**
     * 批量同步未同步的调度单
     * 使用分页查询，确保所有符合条件的任务都能被同步
     */
    @Override
    public int batchSyncPendingDispatchOrders() {
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用");
            return 0;
        }
        
        try {
            int totalSuccessCount = 0;
            int pageSize = 100; // 每页100条
            int offset = 0;
            
            while (true) {
                // 分页查询已同步服务单但未同步调度单的任务
                List<SysTaskEmergency> pendingTasks = sysTaskEmergencyService.selectPendingDispatchSyncTasks(offset, pageSize);
//                log.info("查询到未同步调度单的任务数量: {}", pendingTasks.size());
                if (pendingTasks == null || pendingTasks.isEmpty()) {
                    log.info("没有更多需要同步调度单的任务，offset: {}", offset);
                    break; // 没有更多数据，退出循环
                }
                
//                log.info("开始同步调度单第 {} 页，任务数量: {}", (offset / pageSize) + 1, pendingTasks.size());
                
                int pageSuccessCount = 0;
                for (SysTaskEmergency emergency : pendingTasks) {
//                    log.info("开始同步调度单，任务ID: {}", emergency.getTaskId());
                    Long dispatchOrdId = syncDispatchOrderToLegacy(emergency.getTaskId());

                    if (dispatchOrdId != null && dispatchOrdId > 0) {
                        pageSuccessCount++;
                    }
                    
                    // 避免过于频繁的请求
                    try {
                        Thread.sleep(1000); // 每个请求间隔1秒
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        log.warn("同步调度单被中断");
                        return totalSuccessCount + pageSuccessCount;
                    }
                }
                
                totalSuccessCount += pageSuccessCount;
//                log.info("调度单第 {} 页同步完成，总数: {}, 成功: {}",
//                    (offset / pageSize) + 1, pendingTasks.size(), pageSuccessCount);
                
                // 如果本页数据少于每页大小，说明已经是最后一页
                if (pendingTasks.size() < pageSize) {
//                    log.info("已到达最后一页，调度单同步结束");
                    break;
                }
                
                offset += pageSize; // 下一页
            }
            
//            log.info("批量同步调度单完成，总成功数: {}", totalSuccessCount);
            return totalSuccessCount;
            
        } catch (Exception e) {
            log.error("批量同步调度单异常", e);
            return 0;
        }
    }

    @Override
    public boolean resyncDispatchOrderToLegacy(Long taskId) {
        SysTaskEmergency emergency=sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId);
        Long dispatchOrderId = emergency.getLegacyDispatchOrdId();
        if(LongUtil.isEmpty(dispatchOrderId)){
            Long serviceOrderId= taskEmergencySyncService.syncEmergency(taskId);
            if(LongUtil.isNotEmpty(serviceOrderId)) {
                emergency.setNeedResync(0);
//                emergency.setSyncStatus(2);
                emergency.setSyncTime(new Date());
                sysTaskEmergencyService.updateSysTaskEmergency(emergency);
                return true;
            }
            return false;
        }else {
            return taskDispatchSyncService.resyncDispatchOrderToLegacy(taskId);
        }
    }


    /**
     * 批量重新同步需要更新的调度单
     */
    @Override
    public int batchResyncPendingDispatchOrders() {
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用");
            return 0;
        }
        
        try {
            int totalSuccessCount = 0;
            int pageSize = 100; // 每页100条
            int offset = 0;
            
            while (true) {
                // 分页查询需要重新同步的任务
                List<SysTaskEmergency> needResyncTasks = sysTaskEmergencyMapper.selectNeedResyncTasks(offset, pageSize);

//                log.info("查询到需要重新同步的任务数量: {}", needResyncTasks.size());
                if (needResyncTasks == null || needResyncTasks.isEmpty()) {
                    log.info("没有更多需要重新同步的任务，offset: {}", offset);
                    break; // 没有更多数据，退出循环
                }

//                log.info("开始重新同步调度单第 {} 页，任务数量: {}", (offset / pageSize) + 1, needResyncTasks.size());

                int pageSuccessCount = 0;
                for (SysTaskEmergency emergency : needResyncTasks) {
                    Long dispatchOrdId = emergency.getLegacyDispatchOrdId();
                    Long taskId = emergency.getTaskId();
                    if (LongUtil.isEmpty(dispatchOrdId)) {
                        //没有调度单，我们就调用创建调度单
                        Long serviceOrderId = syncDispatchOrderToLegacy(taskId);
                        if (LongUtil.isNotEmpty(serviceOrderId)) {
                            emergency.setNeedResync(0);
                            emergency.setDispatchSyncTime(new Date());
                            emergency.setDispatchSyncErrorMsg(null);
                            sysTaskEmergencyService.updateSysTaskEmergency(emergency);

                            continue;
                        }
//                    log.info("开始重新同步调度单，任务ID: {}", emergency.getTaskId());
                        boolean success = resyncDispatchOrderToLegacy(emergency.getTaskId());

                        if (success) {
                            pageSuccessCount++;
                        }

                        // 避免过于频繁的请求
                        try {
                            Thread.sleep(1000); // 每个请求间隔1秒
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            log.warn("重新同步调度单被中断");
                            return totalSuccessCount + pageSuccessCount;
                        }
                    }

                    totalSuccessCount += pageSuccessCount;
//                log.info("调度单重新同步第 {} 页完成，总数: {}, 成功: {}",
//                    (offset / pageSize) + 1, needResyncTasks.size(), pageSuccessCount);

                    // 如果本页数据少于每页大小，说明已经是最后一页
                    if (needResyncTasks.size() < pageSize) {
//                    log.info("已到达最后一页，调度单重新同步结束");
                        break;
                    }

                    offset += pageSize; // 下一页
                }
            }
//            log.info("批量重新同步调度单完成，总成功数: {}", totalSuccessCount);
            return totalSuccessCount;
            
        } catch (Exception e) {
            log.error("批量重新同步调度单异常", e);
            return 0;
        }
    }
}