package com.hui.iqiyi.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.hui.iqiyi.Util.ReturnBean;
import com.hui.iqiyi.Util.ReturnProgram;
import com.hui.iqiyi.entity.Content;
import com.hui.iqiyi.entity.Movie;
import com.hui.iqiyi.entity.Program;
import com.hui.iqiyi.mapper.ContentMapper;
import com.hui.iqiyi.mapper.MovieMapper;
import com.hui.iqiyi.mapper.ProgramMapper;
import com.hui.iqiyi.request.ByIdsRequest;
import com.hui.iqiyi.request.ProRequest;
import com.hui.iqiyi.request.ProgramRequest;
import com.hui.iqiyi.response.*;
import com.hui.iqiyi.service.IProgramService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.xmlbeans.impl.xb.xsdschema.Public;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author jobob
 * @since 2021-06-03
 */
@Service
@Primary
public class ProgramServiceImpl extends ServiceImpl<ProgramMapper, Program> implements IProgramService {

    @Resource
    private ProgramMapper programMapper;

    @Autowired
    private MovieMapper movieMapper;

    @Resource
    private ContentMapper contentMapper;

    public Long  CurrCount;

    @Override
    @Transactional
    public ReturnBean updateByProgramIds(List<ByIdsRequest> requests) {
        ReturnBean returnBean = null;
        try {
            if (ObjectUtils.isEmpty(requests))
                returnBean.errorSuccessInfo("传入的ID不能为空");
//            requests.stream().filter(item->item.getType().equals(0)).
            for (ByIdsRequest id : requests) {
                if (id.getType() == 0) {//电影
                    int i1 = programMapper.updateFilm(id.getId());
                    if (i1 == 0) {
                        throw new RuntimeException("添加关注失败!");
                    }
                } else if (id.getType() == 1) {//剧集
                    //MyBatisPlus 的通过id查询
                    int i1 = programMapper.updatePla(id.getId());
                    int pla = programMapper.updateTeleplay(id.getId());
                    if (i1 == 0 && pla == 0) {
                        throw new RuntimeException("添加关注失败!");
                    }
                }
            }
        } catch (Exception e) {
            returnBean.errorSuccessInfo("添加关注异常，原因是" + e.getMessage());
        }
        return returnBean.setSuccessInfo("添加关注成功!");
    }

    /**
     * 获取每一集的下载状态
     *
     * @return
     */
    @Override
    public List<ProgramRequest> selectDownload(ProgramRequest program) {
        return programMapper.selectDownload(program);
    }

    /**
     * 查询关注平台信息
     *
     * @param program
     * @return
     */
    @Override
    public Map<Program, List<Movie>> selectProMov(Program program, int PageNo, int PageSize) {
        Map<Program, List<Movie>> programMovieMap = new HashMap<>();
        //查询集表信息
        QueryWrapper<Program> wrapper = new QueryWrapper<>();
        System.out.println("====================" + program.getPlatformInfo());
        wrapper.eq("platform_info", program.getPlatformInfo());

        //分页查询
        PageHelper.startPage(PageNo, PageSize);
        PageInfo<Program> pageInfo = new PageInfo(programMapper.selectList(wrapper));

        //查询Movie表信息
        QueryWrapper<Movie> wrapper1 = new QueryWrapper<>();
        wrapper1.in("iqiyi_program_id", pageInfo.getList().stream().map(item -> item.getId()).collect(Collectors.toList()));
        List<Movie> listMovie = movieMapper.selectList(wrapper1);

        //循环集表跟Movie表信息进行循环比对，封装成Map进行返回
        //循环集表
        List<Movie> Mo = new ArrayList<>();
        pageInfo.getList().stream().forEach(item -> {
            Mo.clear();
            //循环Movie表 使用并行流
            listMovie.stream().parallel().forEach(movie -> {
                //如果集表ID与Movie表 IqiyiProgramId 相同，则进行封装成
                if (item.getId().compareTo(movie.getIqiyiProgramId()) == 0) {
                    Mo.add(movie);
                }
            });
            programMovieMap.put(item, Mo);
        });
        pageInfo.getList().clear();

        //获取分页数据传递给前台
        ReturnProgram<Program> returnProgram = new ReturnProgram<>();
        returnProgram.setPageNum(pageInfo.getPageNum());
        returnProgram.setPageSize(pageInfo.getPageSize());
        returnProgram.setSize(pageInfo.getSize());
        returnProgram.setStartRow(pageInfo.getStartRow());
        returnProgram.setEndRow(pageInfo.getEndRow());
        returnProgram.setPages(pageInfo.getPages());
        returnProgram.setPrePage(pageInfo.getPrePage());
        returnProgram.setNextPage(pageInfo.getNextPage());

        returnProgram.setProgramMovieMap(programMovieMap);
        return programMovieMap;
    }

    //公共的
    @Override
    public List<ProgramRequest> selectProgramList(ProgramRequest program) {
        return programMapper.selectProgramList(program);
    }

    //查看单集及其状态
    @Override
    public List<ProgramResponse> selectProgramDloadList(ProgramRequest program) {
        //分页查询剧集内的单集详情信息
        List<ProgramResponse> programRequests = programMapper.selectProgramDloadList(program);
        //由于每个单集需要查询出所有的片源信息 两条或三条 所以需要在每个单集详情中 加上一个存储片源信息的List 正好对应两条或三条清晰度的情况
        //返回内容新建了一个response（请求类）因为继续用实体类不能满足多条清晰度的情况下 数据的完整性 于是就在请求类里面加了个list 这个list类型也是一个类（MovieResponse）
        //MovieResponse这个类里面封装了两个字段
        //循环分页后的数据，把多条清晰度加进返回类的list集合里吗
        for (ProgramResponse response : programRequests) {
            //Mybatisplus的方法 通过Program表的id 向Movie的iqiyi_program_id查是否相等 相等就代表 这个数据是这个剧集的莫一条清晰度
            //返回值是list类型的！！！！正好代表多条清晰度的概念 也正好能放在返回类的List<>movieResponseList中
            //不过由于类型不一样需要进行一些别的操作
            List<Movie> movies = movieMapper.selectList(new QueryWrapper<Movie>().eq("iqiyi_program_id", response.getId()));
            //new一个这个是因为需要先存一下子
            List<MovieResponse> movieResponses = new ArrayList<>();
            //循环 通过单集查出的不同清晰度数据 为了能塞进返回类的List<>movieResponseList
            for (Movie m : movies) {
                //因为数据类型不一样 才new的
                MovieResponse movieResponse = new MovieResponse();
                //!!!!这个方法BeanUtils.copyProperties(源对象, 目标对象);
                //把两个类中相同的字段赋值 下面代表 把m 中的值给movieResponse里
                //也就是把m与movieResponse相同的字段 拷贝一份过去
                BeanUtils.copyProperties(m, movieResponse);
                //于是所需要的两个字段也就有值了
                //这个是一个list list由add赋值 add(类型一样的一个值)下标就变成0，再写一个add(类型一样的一个值)就变成下标1
                //理解为!!一个!!剧集的单集下面 所有不同清晰度的片源
                movieResponses.add(movieResponse);
            }
            //set方法 赋值 set(值) 取值 Object i = get（）
            //set方法标识把这个单集的不同清晰度的片源都放进返回类的 movieResponseList字段里面
            response.setMovieResponseList(movieResponses);
        }

        return programRequests;
    }

    @Override
    public List<ProgramXRespone> selectAllSeven(ProRequest proRequest) {
        return programMapper.selectAllSeven(proRequest);
    }

    @Override
    public ProgramSyResponse selectAllProgramCount() {
        ProgramSyResponse programSyResponse = new ProgramSyResponse();
        // 剧集单片数量
        List<Integer> integers = contentMapper.selectAllCont();
        programSyResponse.setDrama(integers.get(1));
        programSyResponse.setMonolithic(integers.get(0));

        List<ProgramQBRequest> qbRequest = programMapper.selectAllProgramCount();
        for (ProgramQBRequest request : qbRequest) {
            if (request.getLocalStatus() != null) {
                if (request.getLocalStatus() == 100) {
                    programSyResponse.setXzNumbe(request.getTotalFee());
                    programSyResponse.setXzSize(request.getTotleSize());
                    programSyResponse.setTotlDuration(request.getTotalduration());
                } else if (request.getLocalStatus() == -10) {
                    programSyResponse.setFailSum(request.getTotalFee());
                } else if (request.getLocalStatus() == 0) {
                    programSyResponse.setTotlSize(request.getTotalFee());
                }
            } else {
                programSyResponse.setTotlFee(request.getTotalFee());
            }
        }

        return programSyResponse;

    }

    @Override
    public ContentResponse selectAllPrograms() {
        List<Integer> integers=programMapper.selectAllPrograms();
        ContentResponse response = new ContentResponse();
        response.setDrama(integers.get(0));
        response.setMonolithic(integers.get(1));
        return response;
    }

    @Override
    public List<Program> selectAllProgra(ProgramRequest programRequest) {
        CurrCount = 1L;
        List<Program> list = null;
        try {
            list = programMapper.selectAllProgra(programRequest);
            if (list.size() == 0)
                return list;
            ProgramRequest request = new ProgramRequest();
            programRequest.setContentIdList(list.stream().map(Long -> Long.getId()).collect(Collectors.toList()));
            List<ProgramRequest> listPro = programMapper.selectDownload(programRequest);
            for (Program program : list) {
                for (ProgramRequest pro : listPro) {
                    if (program.getId().compareTo(pro.getIqiyiContentId()) == 0) {
                        //如果剧头的总集数与下载量一至则显示全部下载完成
                        if (CurrCount.compareTo(pro.getDownloadCount()) == 0) {
                            program.setDownloadStatus("全部下载完成");
                            continue;
                        }
                        //如果剧头的总集数 大于 下载量 就显示未全部下载
                        if (CurrCount.compareTo(pro.getDownloadCount()) > 0) {
                            program.setDownloadStatus("未全部下载");
                            continue;
                        }
                    }
                }
                //里面是关联查询匹配，如果没有下载记录，就塞入未下载
                if (ObjectUtils.isEmpty(program.getDownloadStatus()))
                    program.setDownloadStatus("未下载");
            }
        } catch (Exception e) {
            throw new RuntimeException("服务器错误，错误原因是：" + e.getMessage() + "请联系运维！");
        }
        return list;
    }


}