package com.glxp.api.task;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.dao.collect.IoCollectCodeBackMapper;
import com.glxp.api.dao.collect.RelCodeDetailMapper;
import com.glxp.api.dao.schedule.ScheduledDao;
import com.glxp.api.entity.collect.IoCollectCode;
import com.glxp.api.entity.collect.IoCollectCodeBackup;
import com.glxp.api.entity.collect.RelCodeBatch;
import com.glxp.api.entity.collect.RelCodeDetail;
import com.glxp.api.entity.system.ScheduledEntity;
import com.glxp.api.req.system.ScheduledRequest;
import com.glxp.api.service.collect.IoCollectCodeBackService;
import com.glxp.api.service.collect.RelCodeBatchService;
import com.glxp.api.service.collect.RelCodeDetailService;
import com.glxp.api.util.CacheUtils;
import com.glxp.api.util.RedisUtil;
import com.glxp.api.util.redis.RedisDelayedQueue;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Component;
import redis.clients.jedis.resps.Tuple;

import javax.annotation.Resource;
import java.util.*;

@Component
@EnableScheduling
@Slf4j
public class CollectOrderEelCodeCountTask implements SchedulingConfigurer {




    @Resource
    private ScheduledDao scheduledDao;
    @Resource
    private IoCollectCodeBackMapper ioCollectCodeBackMapper;
    @Resource
    private RelCodeDetailMapper relCodeDetailMapper;
    @Resource
    private IoCollectCodeBackService ioCollectCodeBackService;
    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
        scheduledTaskRegistrar.addTriggerTask(() -> process(),
                triggerContext -> {
                    ScheduledRequest scheduledRequest = new ScheduledRequest();
                    scheduledRequest.setCronName("collectOrderEelCodeCountTask");
                    ScheduledEntity scheduledEntity = scheduledDao.findScheduled(scheduledRequest);
                    if (scheduledEntity == null) {
                        return null;
                    }
                    String cron = scheduledEntity.getCron();
                    if (cron.isEmpty()) {
                        log.error("cron is null");
                    }
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                });
    }

    private void process() {
        List<IoCollectCodeBackup> list = ioCollectCodeBackMapper.filterlargePackage();
        if(list!=null ){
            for (IoCollectCodeBackup ioCollectCodeBackup : list) {
                int count = relCodeDetailMapper.selectCount(
                        new LambdaQueryWrapper<RelCodeDetail>()
                                .eq(RelCodeDetail::getParentCode,ioCollectCodeBackup.getCode())
                ).intValue();
                IoCollectCodeBackup ioCollectCodeBackupNew = new IoCollectCodeBackup();
                if(count > 0){
                    ioCollectCodeBackupNew.setRelCodeCount(count);
                    ioCollectCodeBackService.update(
                            ioCollectCodeBackupNew,new LambdaQueryWrapper<IoCollectCodeBackup>()
                                    .eq(IoCollectCodeBackup::getId,ioCollectCodeBackup.getId())
                    );
                }
//                else {
//                    ioCollectCodeBackupNew.setRelCodeCount(ioCollectCodeBackup.getRelCodeCount()-1);
//                }
            }
        }
    }

}