package com.tanpu.feo.feojob.service;

import com.tanpu.feo.feojob.dao.personaluser.entity.PersonalCurriculumRes;
import com.tanpu.feo.feojob.dao.personaluser.entity.PersonalTag;
import com.tanpu.feo.feojob.dao.personaluser.entity.PersonalTagCategory;
import com.tanpu.feo.feojob.dao.personaluser.entity.PersonalTagRel;
import com.tanpu.feo.feojob.dao.personaluser.mapper.PersonalCurriculumResMapper;
import com.tanpu.feo.feojob.dao.user.entity.*;
import com.tanpu.feo.feojob.dao.user.mapper.*;
import org.checkerframework.checker.units.qual.C;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class CurriculumResService {

    private static final String OWNER = "auto-job";

    @Autowired
    private PersonalService personalService;

    @Resource
    private CurriculumResMapper curriculumResMapper;

    @Resource
    private TagMapper tagMapper;

    @Resource
    private TagRelMapper tagRelMapper;

    @Resource
    private TagCategoryMapper categoryMapper;

    @Resource
    private UserCsFileRecordMapper userCsFileRecordMapper;

    @Transactional(value = "userTransactionTemplate")
    public void migrateShortVideo(String orgId, Boolean autoOn) {
        // 获取该orgId已有的短视频id
        List<String> shortVideos = curriculumResMapper.selectIdByOrgId(orgId);
        // 获取上次同步的时间
        Date maxCreateTime = curriculumResMapper.selectMaxCreateTimeByOrgId(orgId);

        // 获取个人版的短视频id
        List<PersonalCurriculumRes> personalVideos = personalService.selectAllShortVideosByCreateTime(maxCreateTime);
        // 筛选出需要同步的
        personalVideos = personalVideos.stream().filter(res -> {
            return !shortVideos.contains(orgId + "-" + res.getId());
        }).collect(Collectors.toList());

        // 开始从个人版获取tag category等数据
        List<String> sourceRelIds = personalVideos.stream().map(PersonalCurriculumRes::getId).collect(Collectors.toList());
        List<PersonalTagRel> sourceTagRels = personalService.selectTagRelByResIds(sourceRelIds);

        List<String> sourceTagIds = sourceTagRels.stream().map(PersonalTagRel::getTagId).collect(Collectors.toList());
        List<PersonalTag> sourceTags = personalService.selectTagByIds(sourceTagIds);

        List<String> sourceTagCtgIds = sourceTagRels.stream().map(PersonalTagRel::getTagCategoryId).collect(Collectors.toList());
        List<PersonalTagCategory> sourceCtgs = personalService.selectCategoryByIds(sourceTagCtgIds);


        // 开始构造迁移数据
        List<CurriculumRes> reses = personalVideos.stream()
                .map(ss -> {
                    CurriculumRes s = new CurriculumRes();
                    BeanUtils.copyProperties(ss, s);
                    s.setCreateBy(OWNER);
                    s.setUpdateBy(OWNER);
                    s.setCreateTime(new Date());
                    s.setUpdateTime(new Date());
                    s.setId(buildIdForOrg(ss.getId(), orgId));
                    s.setReadNum(0);
                    s.setReadBaseNum(0);
                    s.setRoomPwd("");
                    s.setTeacherId(null);
                    s.setOrgId(orgId);
                    // 上架1 下架2
                    s.setStatus(autoOn ? 1 : 2);
                    // 1置顶 0不置顶
                    s.setIstop(0);
                    // 101 栖盟精选 102机构自建
                    s.setSource(101);

                    return s;
                }).collect(Collectors.toList());
        for (CurriculumRes res : reses) {
            curriculumResMapper.insert(res);
        }

        // 查询已存在的 TagRel
        List<String> existTagRelIds = tagRelMapper.selectDistinctIdByOrgId(orgId);
        List<TagRel> rels = sourceTagRels.stream()
                .map(sr -> {
                    TagRel r = new TagRel();
                    BeanUtils.copyProperties(sr, r);
                    r.setCreateBy(OWNER);
                    r.setUpdateBy(OWNER);
                    r.setCreateTime(new Date());
                    r.setUpdateTime(new Date());
                    r.setId(buildIdForOrg(sr.getId(), orgId));
                    r.setTagId(buildIdForOrg(sr.getTagId(), orgId));
                    r.setRelId(buildIdForOrg(sr.getRelId(), orgId));
                    r.setTagCategoryId(buildIdForOrg(sr.getTagCategoryId(), orgId));
                    r.setOrgId(orgId);

                    return r;
                }).filter(r -> {
                    return !existTagRelIds.contains(r.getId());
                }).collect(Collectors.toList());
        for (TagRel rel : rels) {
            tagRelMapper.insert(rel);
        }

        // 查询已存在的category
        List<String> existCtgIds = categoryMapper.selectDistinctIdByOrgId(orgId);
        List<TagCategory> ctgs = sourceCtgs.stream()
                .map(sctg -> {
                    TagCategory ctg = new TagCategory();
                    BeanUtils.copyProperties(sctg, ctg);
                    ctg.setCreateBy(OWNER);
                    ctg.setUpdateBy(OWNER);
                    ctg.setCreateTime(new Date());
                    ctg.setUpdateTime(new Date());
                    ctg.setId(buildIdForOrg(sctg.getId(), orgId));
                    ctg.setParentId(null);
                    ctg.setOrgId(orgId);
                    return ctg;
                })
                .filter(ctg -> {
                    return !existCtgIds.contains(ctg.getId());
                }).collect(Collectors.toList());
        for (TagCategory ctg : ctgs) {
            categoryMapper.insert(ctg);
        }

        // 查询已存在的category
        List<String> existTagIds = tagMapper.selectDistinctIdByOrgId(orgId);

        List<Tag> tags = sourceTags.stream()
                .map(st -> {
                    Tag t = new Tag();
                    BeanUtils.copyProperties(st, t);
                    t.setCreateBy(OWNER);
                    t.setUpdateBy(OWNER);
                    t.setCreateTime(new Date());
                    t.setUpdateTime(new Date());
                    t.setTagCategoryId(buildIdForOrg(st.getTagCategoryId(), orgId));
                    t.setId(buildIdForOrg(st.getId(), orgId));
                    t.setOrgId(orgId);
                    return t;
                })
                .filter(t -> {
                    return !existTagIds.contains(t.getId());
                }).collect(Collectors.toList());
        for (Tag tag : tags) {
            tagMapper.insert(tag);
        }

    }

    public List<UserCsFileRecord> selectShortVideoForUndoneVodTask() {
        UserCsFileRecordExample example = new UserCsFileRecordExample();
        example.createCriteria().andFileTypeEqualTo("shortVideo").andExt2NotEqualTo("");
        example.setOrderByClause(" create_time desc limit 10");
        List<UserCsFileRecord> records = userCsFileRecordMapper.selectByExample(example);

        return records;
    }

    private String buildIdForOrg(String sourceId, String orgId) {
        return orgId + "-" + sourceId;
    }
}