package com.yoho.search.consumer.job;

import com.yoho.search.base.utils.DateStyle;
import com.yoho.search.base.utils.DateUtil;
import com.yoho.search.consumer.service.daoService.ProductVectorFeatureService;
import com.yoho.search.dal.*;
import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Calendar;
import java.util.List;

@Component
public class CleanDataJob {

    private final Logger logger = LoggerFactory.getLogger("CLEAN_DATA");

    private static final int CLEAN_BATCH_COUNT = 1000;

    private String getLastFiveDayDate() {
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DAY_OF_MONTH, -5);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        return DateUtil.DateToString(calendar.getTime(), DateStyle.YYYYMMDD);
    }

    private void safeSleep(int second) {
        try {
            Thread.sleep(second * 1000);
        } catch (Exception e) {
        }
    }

    private void addBeginLog(int jobIndex, String jobName, String clearDate, long begin) {
        logger.info("{} 、{} start ---- [clearDate={}] [begin={}]", jobIndex, jobName, clearDate, begin);
    }

    private void addFinishLog(int jobIndex, String jobName, String clearDate, int delCount, long begin) {
        logger.info("{} 、{} end  ----[clearDate={}] [delCount={}] , [cost={} ms]", jobIndex, jobName, clearDate, delCount, System.currentTimeMillis() - begin);
    }


    @Scheduled(cron = "0 0 3 * * ?")
    public void cleanData() {
        int jobIndex = 1;
        //1、清除价格带数据
        this.cleanPriceArea(jobIndex++);
        this.safeSleep(10);
        //2、清除流量补偿数据
        this.cleanSknFlow(jobIndex++);
        this.safeSleep(10);
        //3、清除商品向量数据
        this.cleanProductVectorFeature(jobIndex++);
        this.safeSleep(10);
        //4、清除人气值数据
        this.cleanProductHeatValues(jobIndex++);
        this.safeSleep(10);
        //5、清除一天的人气值数据
        this.cleanProductHeatValuesOneDay(jobIndex++);
        this.safeSleep(10);
        //6、清除销售金额数据
        this.cleanProductSalesInfo(jobIndex++);
        this.safeSleep(10);
        //7、清除相似skn数据
        this.cleanBigdataSimilarSkn(jobIndex++);
        this.safeSleep(10);
        //8、清除BigdataSimilarSknImgYoho
        this.cleanBigdataSimilarSknImgYoho(jobIndex++);
        this.safeSleep(10);
        //9、清除商品价值模型数据
        this.cleanProductModelValue(jobIndex++);
        this.safeSleep(10);
        //10、清除ctr数据【目前没在用这个数据，但是清除job还是要用】
        this.cleanSknCtrValue(jobIndex++);
        this.safeSleep(10);
        //11、拍照购图片向量
        this.cleanBigdataSknImageVectors(jobIndex++);
        this.safeSleep(10);

        //12.bigdata_sales_num
        this.cleanBigdataSalesNum(jobIndex++);
        this.safeSleep(10);

        //13、bigdata_ufo_uvscore [ufo_search]
        this.cleanBigdataUfoUvscore(jobIndex++);
        this.safeSleep(10);
        //14.bigdata_ufo_rank+bigdata_ufo_rank_b  [ufo_search]
        this.cleanBigdataUfoRank(jobIndex++);
        this.safeSleep(10);
        //15.bigdata_ufo_sales_money [ufo_search]
        this.cleanBigdataUfoSalesMoney(jobIndex++);
        this.safeSleep(10);
        //16.bigdata_uvscore
        this.cleanBigdataUvScore(jobIndex++);
        this.safeSleep(10);
    }

    @Autowired
    private BigdataSknPriceareaMapper bigdataSknPriceareaMapper;

    private void cleanPriceArea(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanPriceArea";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);

            // 2、执行清理
            int delCount = 0;
            List<Long> sknList = bigdataSknPriceareaMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(sknList)) {
                delCount = delCount + sknList.size();
                bigdataSknPriceareaMapper.deleteBatch(sknList, generateDateStr);
                sknList = bigdataSknPriceareaMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            }
            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }

    @Autowired
    private SknFlowMapper sknFlowMapper;

    private void cleanSknFlow(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanSknFlow";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);

            // 2、执行清理
            int delCount = 0;
            List<Long> sknList = sknFlowMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(sknList)) {
                delCount = delCount + sknList.size();
                sknFlowMapper.deleteBatch(sknList, generateDateStr);
                sknList = sknFlowMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            }

            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }

    @Autowired
    private ProductVectorFeatureService productVectorFeatureService;

    private void cleanProductVectorFeature(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanProductVectorFeature";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);

            // 2、执行清理
            int delCount = 0;
            List<Long> idList = productVectorFeatureService.selectByGenerateDate(generateDateStr, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(idList)) {
                delCount = delCount + idList.size();
                productVectorFeatureService.deleteBatch(idList);
                idList = productVectorFeatureService.selectByGenerateDate(generateDateStr, CLEAN_BATCH_COUNT);
            }
            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error("ProductVectorFeatureJob.clean failed!", e);
        }
    }

    @Autowired
    private ProductHeatValuesMapper productHeatValuesMapper;

    private void cleanProductHeatValues(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanProductHeatValues";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);

            // 2、执行清理
            int delCount = 0;
            List<Long> sknList = productHeatValuesMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(sknList)) {
                delCount = delCount + sknList.size();
                productHeatValuesMapper.deleteBatch(sknList, generateDateStr);
                sknList = productHeatValuesMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            }
            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }

    @Autowired
    private ProductHeatValuesOneDayMapper productHeatValuesOneDayMapper;

    private void cleanProductHeatValuesOneDay(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanProductHeatValuesOneDay";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);

            // 2、执行清理
            int delCount = 0;
            List<Long> sknList = productHeatValuesOneDayMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(sknList)) {
                delCount = delCount + sknList.size();
                productHeatValuesOneDayMapper.deleteBatch(sknList, generateDateStr);
                sknList = productHeatValuesOneDayMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            }
            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }


    @Autowired
    private ProductSalesInfoMapper productSalesInfoMapper;

    private void cleanProductSalesInfo(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanProductSalesInfo";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);

            // 2、执行清理
            int delCount = 0;
            List<Long> sknList = productSalesInfoMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(sknList)) {
                delCount = delCount + sknList.size();
                productSalesInfoMapper.deleteBatch(sknList, generateDateStr);
                sknList = productSalesInfoMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            }
            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }

    @Autowired
    private BigdataSimilarSknMapper bigdataSimilarSknMapper;

    private void cleanBigdataSimilarSkn(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanBigdataSimilarSkn";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);

            // 2、执行清理
            int delCount = 0;
            List<Integer> sknList = bigdataSimilarSknMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(sknList)) {
                delCount = delCount + sknList.size();
                bigdataSimilarSknMapper.deleteBatch(sknList, generateDateStr);
                sknList = bigdataSimilarSknMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            }
            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }

    @Autowired
    private BigdataSimilarSknImgYohoMapper bigdataSimilarSknImgYohoMapper;

    private void cleanBigdataSimilarSknImgYoho(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanBigdataSimilarSknImgYoho";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);

            // 2、执行清理
            int delCount = 0;
            List<Integer> sknList = bigdataSimilarSknImgYohoMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(sknList)) {
                delCount = delCount + sknList.size();
                bigdataSimilarSknImgYohoMapper.deleteBatch(sknList, generateDateStr);
                sknList = bigdataSimilarSknImgYohoMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            }
            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }


    @Autowired
    private ProductModelValueMapper productModelValueMapper;

    private void cleanProductModelValue(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanProductModelValue";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);

            // 2、执行清理
            int delCount = 0;
            List<Long> sknList = productModelValueMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(sknList)) {
                delCount = delCount + sknList.size();
                productModelValueMapper.deleteBatch(sknList, generateDateStr);
                sknList = productModelValueMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            }
            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }


    @Autowired
    private SknCtrValueMapper sknCtrValueMapper;

    private void cleanSknCtrValue(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanSknCtrValue";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);

            // 2、执行清理
            int delCount = 0;
            List<Long> sknList = sknCtrValueMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(sknList)) {
                delCount = delCount + sknList.size();
                sknCtrValueMapper.deleteBatch(sknList, generateDateStr);
                sknList = sknCtrValueMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            }

            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }

    @Autowired
    private BigdataSknImageVectorsMapper bigdataSknImageVectorsMapper;

    private void cleanBigdataSknImageVectors(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanBigdataSknImageVectors";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);

            // 2、执行清理
            int delCount = 0;
            List<Integer> sknList = bigdataSknImageVectorsMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(sknList)) {
                delCount = delCount + sknList.size();
                bigdataSknImageVectorsMapper.deleteBatch(sknList, generateDateStr);
                sknList = bigdataSknImageVectorsMapper.selectSknByDate(generateDateStr, CLEAN_BATCH_COUNT);
            }

            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }


    @Autowired
    private BigdataUfoUvscoreMapper bigdataUfoUvscoreMapper;

    private void cleanBigdataUfoUvscore(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanBigdataUfoUvscore";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);

            // 2、执行清理
            int delCount = 0;
            List<Integer> idList = bigdataUfoUvscoreMapper.selectIdByDate(generateDateStr, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(idList)) {
                delCount = delCount + idList.size();
                bigdataUfoUvscoreMapper.deleteBatch(idList, generateDateStr);
                idList = bigdataUfoUvscoreMapper.selectIdByDate(generateDateStr, CLEAN_BATCH_COUNT);
            }

            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }

    @Autowired
    private BigdataUfoRankMapper bigdataUfoRankMapper;
    @Autowired
    private BigdataUfoRankBMapper bigdataUfoRankBMapper;

    private void cleanBigdataUfoRank(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanBigdataUfoRank";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            Integer dateId = Integer.valueOf(generateDateStr);
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);

            // 2、执行清理
            int delCount = 0;
            List<Integer> idList = bigdataUfoRankMapper.selectIdListByDate(dateId, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(idList) || CollectionUtils.isNotEmpty(idList)) {
                delCount = delCount + idList.size();
                bigdataUfoRankMapper.deleteBatch(idList, dateId);
                idList = bigdataUfoRankMapper.selectIdListByDate(dateId, CLEAN_BATCH_COUNT);
            }
            List<Integer> idListB = bigdataUfoRankBMapper.selectIdListByDate(dateId, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(idListB)) {
                delCount = delCount + idList.size();
                bigdataUfoRankBMapper.deleteBatch(idListB, dateId);
                idListB = bigdataUfoRankBMapper.selectIdListByDate(dateId, CLEAN_BATCH_COUNT);
            }

            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }


    @Autowired
    private BigdataSalesNumMapper bigdataSalesNumMapper;

    private void cleanBigdataSalesNum(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanBigdataSalesNum";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);
            Integer dateId = Integer.valueOf(generateDateStr);

            // 2、执行清理
            int delCount = 0;
            List<Integer> sknList = bigdataSalesNumMapper.selectSknListByDateId(dateId, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(sknList)) {
                delCount = delCount + sknList.size();
                bigdataSalesNumMapper.deleteBatch(sknList, dateId);
                sknList = bigdataSalesNumMapper.selectSknListByDateId(dateId, CLEAN_BATCH_COUNT);
            }

            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }

    @Autowired
    private BigdataUfoSalesMoneyMapper bigdataUfoSalesMoneyMapper;

    private void cleanBigdataUfoSalesMoney(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanBigdataUfoSalesMoney";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);
            Integer dateId = Integer.valueOf(generateDateStr);

            // 2、执行清理
            int delCount = 0;
            List<Integer> idList = bigdataUfoSalesMoneyMapper.selectIdListByDateId(dateId, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(idList)) {
                delCount = delCount + idList.size();
                bigdataUfoSalesMoneyMapper.deleteBatch(idList, dateId);
                idList = bigdataUfoSalesMoneyMapper.selectIdListByDateId(dateId, CLEAN_BATCH_COUNT);
            }

            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }

    @Autowired
    private BigdataUvScoreMapper bigdataUvScoreMapper;

    private void cleanBigdataUvScore(int jobIndex) {
        try {
            //1、记录开始日志
            String jobName = "cleanBigdataUvScore";
            long begin = System.currentTimeMillis();
            String generateDateStr = getLastFiveDayDate();
            this.addBeginLog(jobIndex, jobName, generateDateStr, begin);
            Integer dateId = Integer.valueOf(generateDateStr);

            // 2、执行清理
            int delCount = 0;
            List<Integer> idList = bigdataUvScoreMapper.selectSknListByDateId(dateId, CLEAN_BATCH_COUNT);
            while (CollectionUtils.isNotEmpty(idList)) {
                delCount = delCount + idList.size();
                bigdataUvScoreMapper.deleteBatch(idList, dateId);
                idList = bigdataUvScoreMapper.selectSknListByDateId(dateId, CLEAN_BATCH_COUNT);
            }

            //3、记录结束日志
            this.addFinishLog(jobIndex, jobName, generateDateStr, delCount, begin);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }




}