package org.jeecg;

import cn.com.ctop.common.module.entity.BindAccountLogin;
import cn.com.ctop.common.module.entity.CtopOauthToken;
import cn.com.ctop.common.module.entity.UserAllocation;
import cn.com.ctop.common.module.service.IBindAccountLoginService;
import cn.com.ctop.common.module.service.ICtopOauthTokenService;
import cn.com.ctop.common.module.service.IProjectService;
import cn.com.ctop.common.module.service.IUserAllocationService;
import cn.com.ctop.common.module.utils.CtopAdConstant;
import cn.com.ctop.kuaishou.modules.ai.entity.AiKuaishouAccountTargetTemplate;
import cn.com.ctop.kuaishou.modules.ai.service.IAiKuaishouAccountTargetTemplateService;
import cn.com.ctop.kuaishou.modules.ai.service.IAiKuaishouNewCreateCampaign;
import cn.com.ctop.kuaishou.modules.batch.service.*;
import cn.com.ctop.kuaishou.modules.graphql.service.IKuaishouWebInterfaceService;
import cn.com.ctop.kuaishou.modules.report.service.IKuaishouReportDailyAgentService;
import cn.com.ctop.kuaishou.modules.report.service.IKuaishouVideoEtlInfoService;
import cn.com.ctop.kuaishou.modules.report.service.IRuleKuaiShouPlanService;
import cn.com.ctop.oa.modules.service.IWechatCheckinDataService;
import cn.com.ctop.oa.modules.service.IWechatNoListService;
import cn.com.ctop.oa.modules.service.IWechatUserListService;
import cn.com.ctop.toutiao.modules.link.service.IETLReportBytedanceVideoService;
import cn.com.ctop.toutiao.modules.material.service.IByteDanceAdvertiserDataService;
import cn.com.ctop.toutiao.modules.report.entity.BytedanceAccountReportTaskRecord;
import cn.com.ctop.toutiao.modules.report.mapper.BytedanceReportMaterialDailyMapper;
import cn.com.ctop.toutiao.modules.report.service.*;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.util.DateUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import static org.jeecg.common.util.DateUtils.getAnotherDay;

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@ActiveProfiles("dev")
@Slf4j
public class SampleTest {
    @Autowired
    private ICtopOauthTokenService oauthTokenService;
    @Autowired
    private IReportService reportService;
    @Autowired
    private IByteDanceAdvertiserDataService advertiserDataService;
    @Autowired
    private ICtopOauthTokenService tokenService;
    @Autowired
    private IKuaiShouVideoGetService videoGetService;
    @Autowired
    private IKuaishouVideoRelateCreativesService kuaishouVideoRelateCreativesService;
    @Autowired
    private IBindAccountLoginService bindAccountLoginService;
    @Autowired
    private IKuaishouWebInterfaceService kuaishouWebInterfaceService;
    @Autowired
    private IProjectService projectService;
    @Autowired
    private IUserAllocationService allocationService;
 /*   @Autowired
    private IByteDanceAdvertiserDataService advertiserDataService;

*/


    @Test
    public void loadBytedanceCreativeData() throws ParseException {
        //    1662234704806924
       /* CtopOauthToken token = new CtopOauthToken();
        token.setAccountId(9549277L);
        token.setAccessToken("bc5327c8f2bd8a67513e51148c9206c8");





        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date parse = simpleDateFormat.parse("2021-02-02");
        kuaishouInterfaceService.getAdvertiserReportDaily(token, parse, parse);*/

        QueryWrapper<UserAllocation> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("project_id", 900886);
        List<UserAllocation> list = allocationService.list(queryWrapper);
        for (UserAllocation allocation : list) {
            CtopOauthToken token = tokenService.getTokenByAccountId(allocation.getAccountId());
            kuaishouInterfaceService.getVideoList(token, null, null);
        }


      /*  CtopOauthToken token = new CtopOauthToken();
        token.setAccountId(9767055L);
        token.setAccessToken("28e4e6b124e1443d6971ba4c699de6c9");

        kuaishouInterfaceService.getVideoList(token, null, null);
        kuaishouInterfaceService.getVideoInfo("28e4e6b124e1443d6971ba4c699de6c9", 9767055L, "5208131540349742192");*/

     /*   CtopOauthToken tokenByAccountId = tokenService.getTokenByAccountId(1662234704806924L);
        advertiserDataService.getMaterialList(tokenByAccountId);*/
       /* getVideoByPage(token, "", 1);
        List<KuaiShouVideoGet> KuaiShouVideoGets = videoGetService.selectPhotoIdsByAccountId(9743746L);
        if (!Check.isNull(KuaiShouVideoGets)) {
            JSONArray dateList = new JSONArray();
            JSONArray photoIds = new JSONArray();
            Map<String, Object> statdateMap = new HashMap<>();
            int count = 0;
            for (KuaiShouVideoGet video : KuaiShouVideoGets) {
                count++;
                if (count < 10) {
                    photoIds.add(video.getPhotoId());
                    statdateMap.put(video.getPhotoId(), video.getStatDate());
                } else {
                    photoIds.add(video.getPhotoId());
                    statdateMap.put(video.getPhotoId(), video.getStatDate());
                    dateList.add(photoIds);
                    photoIds = new JSONArray();
                    count = 0;
                }
            }
            dateList.add(photoIds);
            kuaishouVideoRelateCreativesService.videoRelateCreatives(9743746L, dateList, statdateMap);
        }*/
    }

    @Test
    public void loadKuaishouCookie() {
        List<BindAccountLogin> list = bindAccountLoginService.getListByParams(CtopAdConstant.PLATFORM_TYPE_KUAISHOU_PY, 1);
        if (list != null && !list.isEmpty()) {
            int i = 0;
            for (BindAccountLogin login : list) {
                if (null == login.getCookie() || "".equals(login.getCookie().trim())) {
                    kuaishouWebInterfaceService.getkuaishouWebLoginCookie(login);
                    i++;
                }
            }
        }
    }

    static ExecutorService executorService = null;
    static CountDownLatch countDownLatch = null;

    @Test
    public void deleteKuaishouComment() {
        Long start = System.currentTimeMillis();
        List<BindAccountLogin> loginList = bindAccountLoginService.getListByParams(CtopAdConstant.PLATFORM_TYPE_KUAISHOU_PY, 1);
        if (loginList != null && !loginList.isEmpty()) {
            executorService = Executors.newFixedThreadPool(5);
            countDownLatch = new CountDownLatch(loginList.size());
            loginList.forEach(login -> executorService.submit(() -> {
                try {
                    kuaishouWebInterfaceService.deleteAllComment(new HashMap<>(), login);
                } catch (Exception e) {
                    log.error(e.getMessage(), e);
                } finally {
                    countDownLatch.countDown();
                }
            }));
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Long end = System.currentTimeMillis();
            log.info("快手删评论所用时长：{}毫秒", end - start);
        }
    }



    @Test
    public void testLoadBytedanceData() {
        List<UserAllocation> allocations = allocationService.getByParams(633L, null, 0);
        if (null != allocations && !allocations.isEmpty()) {
            for (UserAllocation allocation : allocations) {
                CtopOauthToken token = tokenService.getTokenByAccountId(allocation.getAccountId());
                String startDate = "2020-11-10";
                String endDate = "2020-11-10";
                reportService.getAdvertiserReport(token, DateUtils.parseDate(startDate, "yyyy-MM-dd"), DateUtils.parseDate(endDate, "yyyy-MM-dd"), CtopAdConstant.BYTEDANCE_REPORT_TYPE_HOURLY);
            }
        }
        System.out.println("任务结束");
    }

    @Test
    public void loadKuaishouPlanData() {
        Date getDate = DateUtils.addDay(new Date(), -1);
        //1:查询当日数据
        List<CtopOauthToken> tokens = tokenService.selectKuaiShouToken();
        tokens.forEach(token -> kuaishouInterfaceService.getAdvertiserCampaignReportDaily(token, getDate, getDate));
    }

    @Autowired
    private IBytedanceFundDailyService bytedanceFundDailyService;

    @Test
    public void loadFoudData() {
        List<CtopOauthToken> tokens = tokenService.selectToutiaoToken();
        for (CtopOauthToken token : tokens) {
            System.out.println(token.getAccountId() + "############################");
            for (int i = 20; i < 130; i++) {
                Date date = DateUtils.addDay(new Date(), -i);
                bytedanceFundDailyService.loadFundDataByPage(token, DateUtils.formatDate(date), DateUtils.formatDate(date), 1);
                System.out.println(i + "############################");
            }
        }
    }

    @Autowired
    private IKuaiShouHistoryReportTaskService reportTaskService;

    /**
     * 测试获取快手图片消耗数据任务
     */
    @Test
    public void loadKuaishouImageTask() {
        List<CtopOauthToken> tokens = tokenService.selectKuaiShouToken();
        for (int i = 1; i < 130; i++) {
            Date getDate = DateUtils.addDay(new Date(), -i);
            String getDateStr = DateUtils.formatDate(getDate);
            tokens.forEach(token -> reportTaskService.createTask(token.getAccountId(), token.getAccessToken(), getDateStr, getDateStr, CtopAdConstant.KUAISHOU_LOAD_JOB_TYPE_DAILY));
        }
    }

    @Autowired
    private IKuaiShouDailyReportTaskService dailyReportTaskService;

    /**
     * 测试获取快手图片消耗数据入库
     */
    @Test
    public void loadKuaishouImageTaskFile() {
        String nowDate = DateUtils.getDate("yyyy-MM-dd");
        List<CtopOauthToken> tokens = tokenService.selectKuaiShouToken();
        for (int i = 1; i < 15; i++) {
            String statDate = getAnotherDay("yyyy-MM-dd", nowDate, -i);
            tokens.forEach(token -> dailyReportTaskService.getTaskList(token.getAccountId(), token.getAccessToken(), statDate));
        }
        //  查询快手token
    }

    @Test
    public void testLoadBytedanceImageData() {
        List<CtopOauthToken> tokens = tokenService.selectToutiaoToken();
        countDownLatch = new CountDownLatch(tokens.size());
        executorService = Executors.newFixedThreadPool(8);
        tokens.forEach(token -> executorService.submit(() -> {
            try {
                advertiserDataService.getMaterialList(token);
            } catch (Exception e) {
            } finally {
                countDownLatch.countDown();
            }
        }));
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("素材数据获取完成");

    }

    @Autowired
    private IKuaishouReportDailyAgentService kuaishouReportDailyAgentService;

    @Test
    public void testData() {
        Date date = new Date();
        List<CtopOauthToken> tokens = tokenService.selectToutiaoToken();
        executorService = Executors.newFixedThreadPool(10);
        countDownLatch = new CountDownLatch(tokens.size());
        tokens.forEach(token -> executorService.submit(() -> {
            try {
                reportService.getAdvertiserPlanRuleData(token, date, date, CtopAdConstant.BYTEDANCE_REPORT_TYPE_DAILY);
            } catch (Exception e) {

            } finally {
                countDownLatch.countDown();
            }
        }));
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void loadKuaishouAgentData() {
        kuaishouReportDailyAgentService.loginAgent();
        try {
            for (int i = 1; i < 30; i++) {
                kuaishouReportDailyAgentService.getAccount(i);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Test
    public void loadKuaishouData() {
        Date getDate = DateUtils.addDay(new Date(), -1);
        //1:查询当日数据
        List<CtopOauthToken> tokens = tokenService.selectKuaiShouToken();
        for (CtopOauthToken token : tokens) {
            kuaishouInterfaceService.getAdvertiserCampaignReportDaily(token, getDate, getDate);
        }
    }

    @Autowired
    private IBytedanceReportService bytedanceReportService;

    @Test
    public void loadBytedanceVideoReportData() {
        Date getDate = DateUtils.addDay(new Date(), -1);
        String date = DateUtils.formatDate(getDate);
        List<CtopOauthToken> tokens = tokenService.selectToutiaoToken();
        for (CtopOauthToken token : tokens) {
            bytedanceReportService.bytedanceVideoMaterialReport(token, date, date);
        }
    }

    @Test
    public void loadKuaishouHourlyReportData() {
        Date getDate = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH");
        String hour = simpleDateFormat.format(getDate);
        if ("00".equals(hour)) {
            getDate = DateUtils.addDay(getDate, -1);
        }
        //1:查询当日数据
        List<CtopOauthToken> tokens = tokenService.selectKuaiShouToken();
        Date finalGetDate = getDate;
        tokens.forEach(token -> kuaishouInterfaceService.getAdvertiserReportHourly(token, finalGetDate, finalGetDate));
    }

    @Autowired
    private IKuaishouInterfaceService kuaishouInterfaceService;

    @Test
    public void loadKuaishouGroupData() throws ParseException {
        Date endDate = new Date();
        String anotherDay = DateUtils.getAnotherDay("yyyy-MM-dd", DateUtils.formatDate(endDate), -1);
        SimpleDateFormat sim = new SimpleDateFormat("yyyy-MM-dd");
        Date startDate = sim.parse(anotherDay);
        CtopOauthToken token = tokenService.getTokenByAccountId(7087890L);
        kuaishouInterfaceService.getGroupList(token, startDate, endDate);
    }


    @Test
    public void loadAccountData() {
//        List<UserAllocation> allocations = allocationService.getByParams(776L,null,0);
//        for (UserAllocation allocation:allocations) {
        CtopOauthToken token = tokenService.getTokenByAccountId(93238965516L);
        for (int i = 92; i < 100; i++) {
            Date getDate = DateUtils.addDay(new Date(), -i);
            reportService.getAdvertiserReport(token, getDate, getDate, CtopAdConstant.BYTEDANCE_REPORT_TYPE_DAILY);
        }
//        }
    }

    @Autowired
    private IWechatCheckinDataService wechatCheckinDataService;
    @Autowired
    private IWechatUserListService wechatUserInfoService;
    @Autowired
    private IWechatNoListService wechatNoListService;

    @Test
    public void getData() {
        //汇创 人员
//        wechatUserInfoService.getUserList();
//        //考勤记录
//        wechatCheckinDataService.getCheckinData("2020-11-01 00:00:00", "2020-12-01 23:59:59");
        //异常记录
//        wechatNoListService.getNoDateByNo("2020-11-01 00:00:00", "2020-12-01 23:59:59", "0");
        //优容
        wechatUserInfoService.getYRUserList();
        wechatCheckinDataService.getYRCheckinData("2020-11-01 00:00:00", "2020-11-30 23:59:59");
        wechatNoListService.getNoDateByNo("2020-11-01 00:00:00", "2020-12-01 23:59:59", "1");
    }

    @Autowired
    private IKuaiShouCommentService kuaiShouCommentService;

    @Test
    public void kuaishouDeleteComment() {
        kuaiShouCommentService.shieldComment(8018853L);
    }

    @Autowired
    private IByteDanceVideoReportDailyService videoReportDailyService;

    @Test
    public void formatVideoReportData() {
        for (int i = 1; i < 45; i++) {
            Date getDate = DateUtils.addDay(new Date(), -i);
            String date = DateUtils.formatDate(getDate);
            videoReportDailyService.videoInfoList(date, date);
        }
    }

    @Autowired
    private IRuleKuaiShouPlanService ruleKuaiShouPlanService;

    @Autowired
    private IBytedanceAccountReportTaskRecordService reportTaskRecordService;

    @Test
    public void execute() {
        List<UserAllocation> allocations = allocationService.listByMediaId("3", 0);
        for (UserAllocation allocation : allocations) {
            BytedanceAccountReportTaskRecord reportTaskRecord1 = new BytedanceAccountReportTaskRecord(allocation.getAccountId(), "2020-10-01", "2020-10-31");
            reportTaskRecordService.save(reportTaskRecord1);
            BytedanceAccountReportTaskRecord reportTaskRecord2 = new BytedanceAccountReportTaskRecord(allocation.getAccountId(), "2020-11-01", "2020-11-30");
            reportTaskRecordService.save(reportTaskRecord2);
            BytedanceAccountReportTaskRecord reportTaskRecord3 = new BytedanceAccountReportTaskRecord(allocation.getAccountId(), "2020-12-01", "2020-12-31");
            reportTaskRecordService.save(reportTaskRecord3);
        }
    }

    @Test
    public void loadBDAccoutData() {
        CtopOauthToken token2 = tokenService.getTokenByAccountId(1674206482908163L);
        bytedanceReportService.bytedanceMaterialReport(token2, "2020-10-14", "2020-10-14");
        bytedanceReportMaterialDailyMapper.updateImageReportCode();
        bytedanceReportMaterialDailyMapper.updateImageReportProjectId();
        bytedanceReportMaterialDailyMapper.updateImageReportProjectName();
        bytedanceReportMaterialDailyMapper.updateImageReportPlaneId();
        bytedanceReportMaterialDailyMapper.updateImageReportPlaneName();
    }

    @Resource
    private BytedanceReportMaterialDailyMapper bytedanceReportMaterialDailyMapper;

    private void load12AccountData(CtopOauthToken token) {
        reportService.getAdvertiserReport(token, DateUtils.parseDate("2020-10-01", "yyyy-MM-dd"), DateUtils.parseDate("2020-10-31", "yyyy-MM-dd"), CtopAdConstant.BYTEDANCE_REPORT_TYPE_DAILY);
        reportService.getAdvertiserReport(token, DateUtils.parseDate("2020-11-01", "yyyy-MM-dd"), DateUtils.parseDate("2020-11-30", "yyyy-MM-dd"), CtopAdConstant.BYTEDANCE_REPORT_TYPE_DAILY);
        reportService.getAdvertiserReport(token, DateUtils.parseDate("2020-12-01", "yyyy-MM-dd"), DateUtils.parseDate("2020-12-31", "yyyy-MM-dd"), CtopAdConstant.BYTEDANCE_REPORT_TYPE_DAILY);
    }

    private void load12Data(CtopOauthToken token) {
        bytedanceReportService.bytedanceMaterialReport(token, "2020-10-11", "2020-10-13");
        bytedanceReportService.bytedanceMaterialReport(token, "2020-10-14", "2020-10-16");
        bytedanceReportService.bytedanceMaterialReport(token, "2020-10-17", "2020-10-19");
        bytedanceReportService.bytedanceMaterialReport(token, "2020-10-20", "2020-10-21");
    }

    @Autowired
    private IKuaishouVideoEtlInfoService kuaishouVideoEtlInfoService;

    @Test
    public void etlKuaishouData() {
        String dateString = "2021-01-05";
        Date startDate = DateUtils.parseDate(dateString, "yyyy-MM-dd");
        for (int i = 0; i <= 10; i++) {
            Date getDate = DateUtils.addDay(startDate, i);
            kuaishouVideoEtlInfoService.etlKuaishouVideoInfo(getDate);
            bytedanceVideoEtlInfoService.etlBytedanceVideoInfo(getDate);
        }
    }

    @Autowired
    private IBytedanceVideoEtlInfoService bytedanceVideoEtlInfoService;

    @Test
    public void loadBytedanceVideo() {
        CtopOauthToken token = tokenService.getTokenByAccountId(1673731601820686L);
        for (int i = 15; i < 60; i++) {
            reportService.getAdvertiserReport(token, DateUtils.addDay(new Date(), -i), DateUtils.addDay(new Date(), -i), CtopAdConstant.BYTEDANCE_REPORT_TYPE_DAILY);
        }
    }

    @Test
    public void loadKuaishouVideo() {
        Date date = new Date();
        CtopOauthToken token = tokenService.getTokenByAccountId(9556344L);
//        kuaishouInterfaceService.getAdvertiserCreativeReportDaily(token, new Date(), new Date(), null, null);
        kuaishouInterfaceService.getVideoList(token, DateUtils.formatDate(DateUtils.addDay(date, -5)), DateUtils.formatDate(date));
        // 获取图片信息数据
//        kuaishouInterfaceService.getImageList(token, DateUtils.getNowDate("yyyy-MM-dd"));
    }


    @Autowired
    IRuleByteDanceAccountService ruleByteDanceAccountService;

    @Test
    public void cleanRuleDataAccount() {
        List<CtopOauthToken> tokens = oauthTokenService.selectKuaiShouToken();
        for (CtopOauthToken oauthToken : tokens) {
            ruleKuaiShouPlanService.cleanRuleDataTarget(oauthToken.getAccountId(), 1);
        }
    }

    @Autowired
    IAiKuaishouNewCreateCampaign aiKuaishouNewCreateCampaign;
    @Autowired
    private IAiKuaishouAccountTargetTemplateService aiKuaishouAccountTargetTemplateService;

    @Test
    public void createPlan() {
        List<AiKuaishouAccountTargetTemplate> accountTargetTemplates = aiKuaishouAccountTargetTemplateService.getAllEffectTemplate();
        if (null == accountTargetTemplates || accountTargetTemplates.isEmpty()) {
            return;
        }
        accountTargetTemplates.forEach(targetTemplate -> aiKuaishouNewCreateCampaign.kuaishouAiAdsNewMaterialCreativity(targetTemplate));
    }

    @Test
    public void testCreatePlan() {
//        List<AiKuaishouAccountTargetTemplate> accountTargetTemplates = aiKuaishouAccountTargetTemplateService.getAllEffectTemplate();
//        if (null == accountTargetTemplates || accountTargetTemplates.isEmpty()) {
//            return;
//        }
//        for (AiKuaishouAccountTargetTemplate template:accountTargetTemplates){
//            if(template.getAccountId()!=9556344L){
//                AiKuaishouAccountTargetTemplate accountTargetTemplate2 = aiKuaishouAccountTargetTemplateService.getByAccountId(template.getAccountId());
//                aiKuaishouNewCreateCampaign.kuaishouAiAddNewMaterialCreativity(accountTargetTemplate2,50);
//            }
//        }
        /**
         * 120002
         * 150001
         * 150002
         * 150003
         * 150004
         */

        AiKuaishouAccountTargetTemplate accountTargetTemplate2 = aiKuaishouAccountTargetTemplateService.getById(120002);
        aiKuaishouNewCreateCampaign.kuaishouAiAddNewMaterialCreativity(accountTargetTemplate2, 250);
        accountTargetTemplate2 = aiKuaishouAccountTargetTemplateService.getById(150001);
        aiKuaishouNewCreateCampaign.kuaishouAiAddNewMaterialCreativity(accountTargetTemplate2, 250);
        accountTargetTemplate2 = aiKuaishouAccountTargetTemplateService.getById(150002);
        aiKuaishouNewCreateCampaign.kuaishouAiAddNewMaterialCreativity(accountTargetTemplate2, 250);
        accountTargetTemplate2 = aiKuaishouAccountTargetTemplateService.getById(150003);
        aiKuaishouNewCreateCampaign.kuaishouAiAddNewMaterialCreativity(accountTargetTemplate2, 250);
        accountTargetTemplate2 = aiKuaishouAccountTargetTemplateService.getById(150004);
        aiKuaishouNewCreateCampaign.kuaishouAiAddNewMaterialCreativity(accountTargetTemplate2, 250);
    }

    @Test
    public void testLoadBytedanceDataV2() {
        String accountIds =
                "1675440464386062," +
                        "1688606248211533," +
                        "1669181787105294," +
                        "1687571097467912," +
                        "1650079154438157," +
                        "1680697900744711," +
                        "1678156679964680," +
                        "1670727177043982," +
                        "1676160388944910," +
                        "1687559760306190," +
                        "1687382871519240," +
                        "1680312075164686," +
                        "1675440465991688," +
                        "1664657972166663," +
                        "1688193173408782," +
                        "1675616147056647," +
                        "1687308848716814," +
                        "1686394621234247," +
                        "1683594409340935," +
                        "1683676478859341," +
                        "1686384860112904," +
                        "1668290872519693," +
                        "1674063202781191," +
                        "1685024266033160," +
                        "1669714891201544," +
                        "1687758256277512," +
                        "1675434231118856," +
                        "1686394621807687," +
                        "1678411706704903," +
                        "1686223489547271," +
                        "1660120711467022," +
                        "1686833795211278," +
                        "1680697899143175," +
                        "1661313994984462," +
                        "1661313995480077," +
                        "1636295780727820," +
                        "1676540490482759," +
                        "1675342904713223," +
                        "1686771461984327," +
                        "1685841129360391," +
                        "1683676477736973," +
                        "1661313994470413," +
                        "1663465141771272," +
                        "1687758256732174," +
                        "1686223482927117," +
                        "1686835166313479," +
                        "1642648003678215," +
                        "1639753233213454," +
                        "1675239584963662," +
                        "1674634579279885," +
                        "1650263841162253," +
                        "1672178052130888";
        String[] accountArray = accountIds.split(",");
        for (int i = 0; i < accountArray.length; i++) {
            CtopOauthToken token = tokenService.getTokenByAccountId(Long.parseLong(accountArray[i]));

            reportService.getAdvertiserReport(token, DateUtils.parseDate("2021-01-14", "yyyy-MM-dd"), DateUtils.parseDate("2021-01-14", "yyyy-MM-dd"), CtopAdConstant.BYTEDANCE_REPORT_TYPE_DAILY);
        }
    }


    @Test
    public void checkBytedanceReport() {
        CtopOauthToken token = tokenService.getTokenByAccountId(1678959391271949L);
        String startDate = "2021-01-01 00:00:00";
        String endDate = "2021-01-31 00:00:00";
        bytedanceReportService.checkoutData(token, startDate, endDate);
    }

    @Test
    public void etlKuaishouProjectData() {
        CtopOauthToken token = tokenService.getTokenByAccountId(1660666858777607L);
        reportService.getAdvertiserPlanReport(token, DateUtils.parseDate("2021-01-25", "yyyy-MM-dd"), DateUtils.parseDate("2021-01-25", "yyyy-MM-dd"), CtopAdConstant.BYTEDANCE_REPORT_TYPE_DAILY);
    }

    @Autowired
    IBytedanceVideoReportService bytedanceVideoReportService;

    @Test
    public void etlBytedanceVideoReport() {

//        for (int i = 1; i <= 62; i++) {
//            etlBytedanceVideo(DateUtils.formatDate(DateUtils.addDay(new Date(), -i)));
//        }
        etlBytedanceVideo("2021-02-03");

    }

    private void etlBytedanceVideo(String statDate) {
        List<CtopOauthToken> tokens = oauthTokenService.selectToutiaoToken();
        executorService = Executors.newFixedThreadPool(10);
        countDownLatch = new CountDownLatch(tokens.size());
        tokens.forEach(token -> executorService.submit(() -> {
            try {
                bytedanceVideoReportService.pullVideoReport(token, statDate, statDate, 1);
            } catch (Exception e) {

            } finally {
                countDownLatch.countDown();
            }
        }));
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Autowired
    IETLReportBytedanceVideoService ietlReportBytedanceVideoService;

    @Test
    public void etlBytedanceVideoReportClean() {
        //for (int i = 1; i <= 1; i++) {
        //  String statDate = DateUtils.formatDate(DateUtils.addDay(new Date(), -i));
        ietlReportBytedanceVideoService.cleanETL("2020-12-31");
        //}
    }

    @Test
    public void etlBytedanceVideoReportClean1() {
        //executorService = Executors.newFixedThreadPool(31);
        //countDownLatch = new CountDownLatch(31);
        for (int i = 3; i <= 31; i++) {
            String statDate = DateUtils.formatDate(DateUtils.addDay(new Date(), -i));
            ietlReportBytedanceVideoService.cleanETL(statDate);
        }
    }
}
