package com.ruoyi.system.service.impl;

import com.ruoyi.common.config.LegacySystemConfig;
import com.ruoyi.common.utils.LongUtil;
import com.ruoyi.common.utils.MapValueUtils;
import com.ruoyi.system.domain.SysTask;
import com.ruoyi.system.domain.SysTaskEmergency;
import com.ruoyi.system.event.TaskServiceOrderSyncEvent;
import com.ruoyi.system.mapper.LegacyTransferSyncMapper;
import com.ruoyi.system.mapper.SysTaskMapper;
import com.ruoyi.system.service.ISysTaskEmergencyService;
import com.ruoyi.system.service.ISysTaskService;
import com.ruoyi.system.service.TaskEmergencySyncService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

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

@Slf4j
@Service
public class TaskEmergencySyncServiceImpl implements TaskEmergencySyncService {

    @Autowired
    private ApplicationEventPublisher eventPublisher;



    @Autowired
    private ISysTaskService sysTaskService;

    @Autowired
    private SysTaskMapper sysTaskMapper;

    @Autowired
    private ISysTaskEmergencyService sysTaskEmergencyService;

    @Autowired
    private LegacySystemConfig legacyConfig;

    @Autowired
    private LegacyTransferSyncMapper legacyTransferSyncMapper;

    @Autowired
    private TaskSyncUtilService taskSyncUtilService;

    private Map<String,Object> getLegacyByServiceOrdId(Long serviceOrdId) {
        List<Map<String, Object>> result = legacyTransferSyncMapper.selectByServiceOrdId(serviceOrdId);
        if(!CollectionUtils.isEmpty(result)){
            return result.get(0);
        }else{
            return null;
        }
    }

    /**
     * 同步急救转运任务到旧系统
     */
    public Long syncEmergencyTaskToLegacy(SysTask task,SysTaskEmergency emergency,Boolean isNew) {
       Long taskId=task.getTaskId();
       Long serviceOrderId = emergency.getLegacyServiceOrdId();
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用，跳过任务ID: {}", taskId);
            return null;
        }

        try {
            // 更新同步状态为同步中
            emergency.setSyncStatus(1);
            sysTaskEmergencyService.updateSysTaskEmergency(emergency);

            // 构建请求参数
            Map<String, Object> params = taskSyncUtilService.buildSyncParams(task, emergency);
            String updateUrl=legacyConfig.getEmergencyCreateUrl();
            if(!isNew){
                updateUrl=legacyConfig.getEmergencyUpdateUrl();
                params.put("ServiceOrdID",serviceOrderId);
            }
            // 发送HTTP请求
            String response = taskSyncUtilService.sendHttpPost(updateUrl, params);

            // 解析响应
            Long serviceOrdId = taskSyncUtilService.parseResponse(response);

            if (LongUtil.isNotEmpty(serviceOrderId)) {
                // 同步成功，更新记录
                emergency.setLegacyServiceOrdId(serviceOrdId);
                emergency.setSyncStatus(2); // 同步成功
                emergency.setSyncTime(new Date());
                emergency.setSyncErrorMsg(null);
                Map<String, Object> legacy = getLegacyByServiceOrdId(serviceOrdId);
                String serviceOrdNo = MapValueUtils.getStringValue(legacy, "ServiceOrdNo");
                if(serviceOrdNo!=null) {
                    emergency.setLegacyServiceOrdNo(serviceOrdNo);
                }
                String serviceOrdClass = MapValueUtils.getStringValue(legacy, "ServiceOrdClass");
                if(serviceOrdClass!=null) {
                    emergency.setLegacyServiceOrdClass(serviceOrdClass);
                }
                Date serviceCCTime = MapValueUtils.getDateValue(legacy, "ServiceOrd_CC_Time");
                if(serviceCCTime!=null) {
                    emergency.setLegacyServiceNsTime(serviceCCTime);
                }
                sysTaskEmergencyService.updateSysTaskEmergency(emergency);

                // 更新任务主表同步标记
                task.setLegacySynced(1);
                sysTaskMapper.updateSysTask(task);

                eventPublisher.publishEvent(new TaskServiceOrderSyncEvent(this, taskId, task.getTaskCode(), serviceOrdId,!isNew));
//                log.info("任务同步成功，任务ID: {}, ServiceOrdID: {}", taskId, serviceOrdId);
                return serviceOrdId;
            } else {
                // 同步失败
                emergency.setSyncStatus(3); // 同步失败
                emergency.setSyncTime(new Date());
                emergency.setSyncErrorMsg("旧系统返回无效的ServiceOrdID: " + response);
                sysTaskEmergencyService.updateSysTaskEmergency(emergency);

                log.error("任务同步失败，任务ID: {}, 响应: {}", taskId, response);
                return null;
            }

        } catch (Exception e) {
            log.error("同步任务到旧系统异常，任务ID: {}", taskId, e);

            // 更新同步状态为失败
            try {
                 emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId);
                if (emergency != null) {
                    emergency.setSyncStatus(3); // 同步失败
                    emergency.setSyncTime(new Date());
                    emergency.setSyncErrorMsg("同步异常: " + e.getMessage());
                    sysTaskEmergencyService.updateSysTaskEmergency(emergency);
                }
            } catch (Exception ex) {
                log.error("更新同步状态失败", ex);
            }

            return null;
        }
    }
    @Override
    public Long syncEmergency(Long taskId) {
        SysTask task=sysTaskService.selectSysTaskByTaskId(taskId);
        SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId);
        if(emergency!=null){
            Long dispatchOrderId=emergency.getLegacyDispatchOrdId();
            Long serviceOrderId = emergency.getLegacyServiceOrdId();
            if(LongUtil.isEmpty(dispatchOrderId) && LongUtil.isEmpty(serviceOrderId)){
                //dispatch为空且
                return syncNewEmergency(task,emergency);
            }else if(LongUtil.isNotEmpty(serviceOrderId) && LongUtil.isEmpty(dispatchOrderId)){
                //serviceId不为空，dispatchOrdId为空
                return syncUpdateEmergency(task,emergency);
            }
        }
        return 0L;
    }


    private Long syncNewEmergency(SysTask task,SysTaskEmergency emergency) {
        return this.syncEmergencyTaskToLegacy(task,emergency,true);
    }


    private Long syncUpdateEmergency(SysTask task,SysTaskEmergency emergency) {
        return this.syncEmergencyTaskToLegacy(task,emergency,false);
    }
}