package com.zteits.charge.job.kelin;

import org.apache.commons.collections4.CollectionUtils;
import com.alibaba.fastjson.JSON;
import com.clouds.common.constants.RedisKeyEnum;
import com.clouds.common.redis.RedisCacheFactory;
import com.clouds.common.utils.DateUtil;
import com.xxl.job.core.biz.model.ReturnT;

import com.xxl.job.core.context.XxlJobHelper;
import com.xxl.job.core.handler.annotation.XxlJob;
import com.zteits.charge.dao.ConnectorInfoDao;
import com.zteits.charge.dao.EquipmentInfoDao;
import com.zteits.charge.dao.StationInfoDao;
import com.zteits.charge.domain.ConnectorInfo;
import com.zteits.charge.domain.EquipmentInfo;
import com.zteits.charge.domain.StationInfo;
import com.zteits.charge.domain.kelin.result.ConnectorInfoResult;
import com.zteits.charge.domain.kelin.result.EquipmentInfoResult;
import com.zteits.charge.service.spi.CallStationInfoSpi;
import com.zteits.charge.domain.kelin.result.StationInfoResult;
import com.zteits.charge.domain.kelin.post.QueryStationsPost;
import com.zteits.charge.domain.kelin.result.QueryStationsResult;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.Date;
import java.util.List;

/**
 * 查询科林充电站信息
 * 如果是all 查询，则可以在一个长周期内查询，例如1天1次，每天0点跑
 * 如果是date查询，则可以在一个短周期，增量查询，例如每30分钟一次
 * @author sl
 */
@Slf4j
@Component
public class QueryStationsInfoJob {
    @Autowired
    private CallStationInfoSpi callStationInfoSpi;
    @Autowired
    private StationInfoDao stationInfoDao;
    @Autowired
    private EquipmentInfoDao equipmentInfoDao;
    @Autowired
    private ConnectorInfoDao connectorInfoDao;
    // 充电站设备创建时默认的orgId，即创建到那个组织下面
    @Value("${charge.orgId}")
    private Long orgId;

    private static Integer PAGE_SIZE = 50;

    /**
     *
     * @param arg arg[0]=operatorId 运营商id；arg[1]=查询类型：all-全部重新查询，date-按查询时间查询；arg[2]:如果第二个类型为data,则该字段有效，如果有值，则取传递的值
     * @return
     * @throws Exception
     */
    @XxlJob(value="QueryStationsInfoJob")
    public ReturnT<String> execute(String... arg) throws Exception {
        String param = XxlJobHelper.getJobParam();
        if (null != param && arg==null) {
            arg = param.split(",");
        }
        if (arg == null) {
            this.logger("参数不能为空，请输入运营商ID");
            return ReturnT.SUCCESS;
        }
        String operatorId = arg[0];
        // 查询时间
        String queryTime = "";
        if ("all".equals(arg[1])) {

        } else if ("date".equals(arg[1]) && arg.length ==3) {
            // 使用指定的值查询
            queryTime = arg[2];
        } else {
            // 读取缓存
            String redisData = RedisCacheFactory.getRedisCacheUtil().get(RedisKeyEnum.QUERY_CHARGE_STATION_TIME.key());
            if (StringUtils.isBlank(redisData)) {
                this.logger("缓存中查询时间为空，不处理");
                return ReturnT.SUCCESS;
            } else {
                queryTime = redisData;
            }
        }
        queryStationsInfo(operatorId,queryTime,1);
        // 设置缓存时间为当前时间
        RedisCacheFactory.getRedisCacheUtil().put(RedisKeyEnum.QUERY_CHARGE_STATION_TIME.key(), DateUtil.getDateString(new Date(),DateUtil.DATETIME_FORMAT));
        return ReturnT.SUCCESS;

    }

    /**
     *
     * @param operatorId
     * @param queryTime
     * @param pageNo
     */
    private void queryStationsInfo(String operatorId,String queryTime,int pageNo) {
        this.logger("开始查询运营商:"+operatorId+"，查询时间:"+queryTime+"，第"+pageNo+"页的充电站信息");
        // 这里是查询全部的运营商
        QueryStationsResult queryStationsResult = callStationInfoSpi.queryStationsInfo(operatorId, new QueryStationsPost().setPageNo(pageNo).setPageSize(PAGE_SIZE).setLastQueryTime(queryTime));
        if (queryStationsResult == null || CollectionUtils.isEmpty(queryStationsResult.getStationInfos())) {
            this.logger("查询第"+pageNo+"返回数据为空，处理结束");
            return;
        }

        List<StationInfoResult> stationInfos = queryStationsResult.getStationInfos();
        for (StationInfoResult infoResult : stationInfos) {
            // 保存站点信息
            StationInfo newStationInfo = new StationInfo();
            BeanUtils.copyProperties(infoResult,newStationInfo);
            newStationInfo.setStationLat(infoResult.getStationLat() == null ? null : BigDecimal.valueOf(infoResult.getStationLat()));
            newStationInfo.setStationLng(infoResult.getStationLng() == null ? null : BigDecimal.valueOf(infoResult.getStationLng()));
            newStationInfo.setPictures(JSON.toJSONString(infoResult.getPictures()));
            if (StringUtils.isBlank(newStationInfo.getOperatorId())) {
                newStationInfo.setOperatorId(operatorId);
            }
            newStationInfo.setOrgId(orgId);
            stationInfoDao.saveStationInfo(newStationInfo);

            // 保存设备信息
            List<EquipmentInfoResult> equipmentInfos = infoResult.getEquipmentInfos();
            if (CollectionUtils.isEmpty(equipmentInfos)) {
                continue;
            }
            for (EquipmentInfoResult equipmentInfoResult : equipmentInfos) {
                EquipmentInfo equipmentInfo = new EquipmentInfo();
                BeanUtils.copyProperties(equipmentInfoResult,equipmentInfo);
                equipmentInfo.setEquipmentLat(equipmentInfoResult.getEquipmentLat() == null ? null : BigDecimal.valueOf(equipmentInfoResult.getEquipmentLat()));
                equipmentInfo.setEquipmentLng(equipmentInfoResult.getEquipmentLng() == null ? null : BigDecimal.valueOf(equipmentInfoResult.getEquipmentLng()));
                equipmentInfo.setPower(equipmentInfoResult.getPower() == null ? null : BigDecimal.valueOf(equipmentInfoResult.getPower()));
                equipmentInfo.setOperatorId(operatorId);
                equipmentInfo.setStationId(newStationInfo.getStationId());
                equipmentInfo.setOrgId(orgId);
                equipmentInfoDao.saveEquipmentInfo(equipmentInfo);

                // 保存设备接口信息
                if (CollectionUtils.isEmpty(equipmentInfoResult.getConnectorInfos())) {
                    continue;
                }
                for (ConnectorInfoResult connectorInfoResult : equipmentInfoResult.getConnectorInfos()) {
                    ConnectorInfo connectorInfo = new ConnectorInfo();
                    BeanUtils.copyProperties(connectorInfoResult,connectorInfo);
                    connectorInfo.setPower(connectorInfoResult.getPower() == null ? null : BigDecimal.valueOf(connectorInfoResult.getPower()));
                    connectorInfo.setOperatorId(operatorId);
                    connectorInfo.setStationId(newStationInfo.getStationId());
                    connectorInfo.setEquipmentId(equipmentInfo.getEquipmentId());
                    connectorInfo.setOrgId(orgId);
                    connectorInfoDao.saveConnectorInfo(connectorInfo);
                }
            }
        }


        if (queryStationsResult.getPageCount() <= pageNo) {
            this.logger("总页数"+queryStationsResult.getPageCount()+",当前页数"+pageNo+"，处理结束");
            return;
        }

        this.queryStationsInfo(operatorId,queryTime,pageNo+1);
    }

    private void logger(String msg){
        XxlJobHelper.log(msg);
        log.info(msg);
    }
}