package com.ruoyi.quartz.task;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.CmsVehicleDeviceResponse;
import com.ruoyi.system.domain.CmsVehicleLocationResponse;
import com.ruoyi.system.domain.VehicleGps;
import com.ruoyi.system.domain.VehicleInfo;
import com.ruoyi.system.service.ICmsGpsCollectService;
import com.ruoyi.system.service.IVehicleGpsService;
import com.ruoyi.system.service.IVehicleInfoService;

/**
 * CMS车辆同步定时任务
 * 
 * @author ruoyi
 */
@Component("cmsVehicleSyncTask")
public class CmsVehicleSyncTask {
    private static final Logger log = LoggerFactory.getLogger(CmsVehicleSyncTask.class);

    @Autowired
    private ICmsGpsCollectService cmsGpsCollectService;

    @Autowired
    private IVehicleInfoService vehicleInfoService;

    @Autowired
    private IVehicleGpsService vehicleGpsService;

    public void syncVehicleInfo() {
        log.info("开始同步CMS车辆信息");
        try {
            // 获取CMS所有车辆信息
            CmsVehicleDeviceResponse response = cmsGpsCollectService.queryVehicleDevices();
            if (response.getResult() != 0) {
                log.error("获取CMS车辆信息失败");
                return;
            }

            // 获取所有CMS车辆的车牌号
            List<String> cmsPlateNos = new ArrayList<>();
            response.getVehicles().forEach(vehicle -> {
                if (StringUtils.isNotEmpty(vehicle.getNm())) {
                    // 从车辆名称中提取车牌号（假设格式为"★车牌号（地区）"）
                    String plateNo =this.getPlateNo(vehicle.getNm());
                    cmsPlateNos.add(plateNo);
                }
            });

            // 获取本地所有车辆
            VehicleInfo query = new VehicleInfo();
            query.setStatus("0");
            List<VehicleInfo> localVehicles = vehicleInfoService.selectVehicleInfoList(query);
            
            //找到所有车辆中不是CMS平台的车辆
            List<String> notCmsVehicles =  localVehicles.stream().filter(e->!e.getPlatformCode().equals("CMS")).map(e->e.getVehicleNo()).collect((Collectors.toList()));


            List<String> onlyCms=cmsPlateNos.stream().filter(e->!notCmsVehicles.contains(e)).collect((Collectors.toList()));

            Integer syncCarCount=0;
            for(String e:onlyCms){
                VehicleInfo vehicleInfo = new VehicleInfo();
                vehicleInfo.setVehicleNo(e);
                vehicleInfo.setPlatformCode("CMS");
                vehicleInfo.setStatus("0");
                //如果车辆不存在，则插入
                if (vehicleInfoService.selectVehicleInfoList(vehicleInfo).size()==0) {
                    vehicleInfoService.insertVehicleInfo(vehicleInfo);
                    syncCarCount++;
                }
            }


            log.info("成功同步{}个CMS车辆信息", syncCarCount);
            log.info("CMS车辆信息同步完成");
        } catch (Exception e) {
            log.error("同步CMS车辆信息异常", e);
        }
    }

    //对车牌处理的通用方法
    private String getPlateNo(String plateNo){
        if (StringUtils.isNotEmpty(plateNo)) {
                // 从车辆名称中提取车牌号（假设格式为"★车牌号（地区）"）
            if(plateNo.contains("(")) {
                plateNo = plateNo.replace("★", "").replace("☆", "").split("\\(")[0];
            }else{
                plateNo = plateNo.replace("★", "").replace("☆", "").split("（")[0];
            }
            }
            return plateNo;
    }

    /**
     * 同步CMS车辆位置信息
     */
    public void syncVehicleLocation() {
        log.info("开始同步CMS车辆位置信息");
        try {
                //先获得本地CMS上的所有CMS车辆
                VehicleInfo query = new VehicleInfo();
                query.setPlatformCode("CMS");
                query.setStatus("0");
                List<VehicleInfo> localVehicles = vehicleInfoService.selectVehicleInfoList(query);

                    // 获取车辆最新位置信息
                    CmsVehicleLocationResponse response = cmsGpsCollectService.getVehicleLocation(
                        null,2,1,null,null);

                    if (response.getResult() != 0 ) {
                        log.warn("获取车辆位置信息失败");
                       return;
                    }

                    List<CmsVehicleLocationResponse.VehicleLocation> cmsVehicles = response.getInfos();
                    Double defaultZero = 0.0;
                    for(CmsVehicleLocationResponse.VehicleLocation vehicle:cmsVehicles){
                        //与车辆信息进行匹配，如果匹配成功，则保存车辆位置信息
                        //对车牌进行处理
                        String plateNo =this.getPlateNo(vehicle.getVi());

                        if (!localVehicles.stream().anyMatch(e->e.getVehicleNo().equals(plateNo))) {
                            continue;
                        }
                        VehicleInfo f=  localVehicles.stream().filter(e->e.getVehicleNo().equals(plateNo)).findFirst().get();
                        if(f==null){
                            continue;
                        }

                    // 创建GPS记录
                    VehicleGps gps = new VehicleGps();
                    gps.setVehicleId(f.getVehicleId());
                    gps.setDeviceId(null);
                    gps.setLongitude(vehicle.getJd()/1000000);
                    gps.setLatitude(vehicle.getWd()/1000000);
                    gps.setSpeed(defaultZero);
                    gps.setVehicleNo(plateNo);
                    gps.setDirection(defaultZero);
                    gps.setAltitude(defaultZero);
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    String deviceTime=sdf.format(new Date(vehicle.getTm()));
                    gps.setDeviceReportTime(deviceTime);
                    gps.setPlatformProcessTime(sdf.format(new Date()));

                    gps.setCreateTime(new Date());
                    gps.setCollectTime(deviceTime);

                    // 保存GPS记录
                    vehicleGpsService.insertVehicleGps(gps);
                    }


                } catch (Exception e) {
                    log.error("同步车辆位置信息异常", e);
                }





    }
}